Comment appeler la méthode de remplacement d'une super-classe?

Ici, vous aurez une option pour choisir la méthode qui vous voulez invoquer:

public class Cat extends Animal {

    public void superEat() {
        super.eat();
    }

    public void superDrink() {
        super.drink();
    }

    @Override
    public void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public void drink() {
        System.out.println("Cat Drinks");
    }
}

• L'accès à des champs statiques, des champs d'instance et des méthodes statiques dépend de la classe de la variable de référence et pas l'objet réel à laquelle la variable de points.
• Rappelez-vous que les variables de membre sont l'ombre, elle n'est pas remplacée.

• Ce qui est l'opposé de ce qui se passe dans le cas des méthodes d'instance.
  
  Dans le cas des méthodes d'instance de la méthode de la de la classe réelle de l'objet est appelé.

  class ABCD {
      int x = 10;
      static int y = 20;
  
      public String getName() {
          return "ABCD";
      }
  }
  
  class MNOP extends ABCD {
      int x = 30;
      static int y = 40;
  
      public String getName() {
          return "MNOP";
      }
  }
  
  public static void main(String[] args) {
  
    System.out.println(new MNOP().x + ", " + new MNOP().y);
  
    ABCD a = new MNOP();
    System.out.println(a.x); //10
    System.out.println(a.y); //20
    System.out.println(a.getName()); //MNOP
  }

Dans cet exemple, même si l'objet myCat est attribué à un Animal de référence de l'objet, (Animal myAnimal = myCat) l'objet Réel est de type Cat et il se comporte comme c'est un chat.

Espère que cette aide.

Si vous faites des méthodes de chaque classe statique, il devrait fonctionner.

public class Animal {
    public static void eat() {
        System.out.println("Animal Eats");
    }

    public static void drink() {
        System.out.println("Animal Drinks");
    }
}


public class Cat extends Animal {
    @Override
    public static void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public static void drink() {
        System.out.println("Cat Drinks");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        Animal myAnimal = myCat;        
        myAnimal.eat();
        myAnimal.drink();
    }
}

Le code ci-dessus donne le résultat suivant

Cat Eats
Cat Drinks
Animal Eats
Animal Drinks

public class Main {
    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        Animal myAnimal = new Animal();
        myAnimal.eat();
        myAnimal.drink();
    }
}

public class Animal {
    public void eat(){
        System.out.println("Animal eat() called");
    }
    public void drink(){
        System.out.println("Animal drink() called");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat eat() called");
    }

    @Override
    public void drink() {
        System.out.println("cat drink() called");
    }
}

De SORTIE:

Chat manger() appelée

chat à boire() appelée

Animal manger() appelée

Animal à boire() appelée

Vous avez besoin de créer un objet de la classe super Animal OU une autre option est d'utiliser le mot-clé super, chez l'enfant, les méthodes de la classe par exemple, super.eat() ou super.drink()

Merci de ne pas voter sur cette réponse... vous pouvez voter sur l'autre 🙂 C'est une mauvaise réponse, mais montre comment vous pourriez faire ce que vous essayez de faire... mal.

public class Main
{
    public static void main(final String[] argv) 
    {        
        Child  child;
        Parent parent;

        child  = new Child();
        parent = child;

        child.a();
        parent.a();
        child.otherA();
        parent.otherA();
    }
}

class Parent
{
    public void a()
    {
        System.out.println("Parent.a()");
    }

    public void otherA()
    {
        //doesn't matter what goes here... really should be abstract
    }
}

class Child
    extends Parent
{
    @Override
    public void a()
    {
        System.out.println("Child.a()");
    }

    @Override
    public void otherA()
    {
        super.a();
    }
}