web-dev-qa-db-fra.com

Comment appeler la méthode surchargée d'une superclasse?

Comment appeler la méthode manger et boire de la classe Animal avec l'instance myAnimal dans le code?

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

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

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

    @Override
    public 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();
    }
}

Sortie que je reçois: 

Cat Eats
Cat Drinks
Cat Eats
Cat Drinks

Ceci est ma sortie attendue:

Cat Eats
Cat Drinks
Animal Eats
Animal Drinks
javainheritanceoverridemethod-overriding
38
Hisham Muneer

Vous ne pouvez pas faire ce que vous voulez. Le polymorphisme fonctionne en faisant ce que vous voyez.

Fondamentalement, un chat sait toujours qu’il est un chat et se comportera toujours comme un chat, que vous le traitiez comme un chat, Felis, Felinae, Felidae, Feliformia, Carnivora, Theria, Mammalia, Vertébrata, Chordata, Eumetazoa, Animalia, Animal Objet ou autre chose :-)

61
TofuBeer

Ici, vous aurez une option pour choisir quelle méthode voulez-vous 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");
    }
}
18
Andrii Dzhyrma

Si vous définissez des méthodes dans chaque classe, cela 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 donnera la sortie suivante

Cat Eats
Cat Drinks
Animal Eats
Animal Drinks
2
Vbee
  • L'accès aux champs statiques, aux champs d'instance et aux méthodes statiques dépend de la classe de la variable de référence et et non de l'objet réel vers lequel la variable pointe. 
  • Rappelez-vous que les variables membres sont ombrées et non remplacées.

  • C'est l'inverse de ce qui se passe dans le cas des méthodes d'instance.
    Dans le cas de méthodes d'instance, la méthode de la classe actuelle de l'objet est appelée.

    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, bien que l'objet myCat soit affecté à une référence d'objet Animal, (Animal myAnimal = myCat), l'objet Actual est de type Cat et se comporte comme s'il s'agissait d'un chat.

J'espère que cela t'aides.

2
tharindu_DG

Vous pouvez créer un constructeur pour la classe Animal, qui prend un autre Animas en paramètre et crée une nouvelle instance en fonction de celle fournie.

public class Animal {
    //some common animal's properties
    private int weight;
    private int age;

    public Animal() {
        // empty.
    }

    public Animal(final Animal otherAnimal) {
        this.weight = otherAnimal.getWeight();
        this.age = otherAnimal.getAge();
    }

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

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

    // setters and getters.
}

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

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

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

        // note: myAnimal is not a Cat, it's just an Animal.
        Animal myAnimal = new Animal(myCat);         
        myAnimal.eat();
        myAnimal.drink();
    }
}
2
friednail
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");
    }
}

SORTIE:

Chat manger () appelé

boisson de chat () appelé

Animal manger () appelé

Boisson animale () appelée

Vous devez créer un objet de la super classe Animal OR. Une autre option consiste à utiliser le mot clé super dans les méthodes de classe enfant, par exemple, super.eat() ou super.drink()

0
cNgamba

Quelques suggestions:

  1. Ne transmettez pas la référence de classe enfant à la super classe et la méthode de la super classe doit être invoquée pour la méthode remplacée. Appelez les méthodes de super classe à partir d'une instance de super classe. 

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

  2. Si vous souhaitez appeler une méthode de classe super depuis une classe enfant, appelez explicitement le nom de la méthode de classe avec super.methodName ();

    public void eat() {
    super.eat();
    System.out.println("Cat Eats");
}
  3. Ne substituez pas la méthode super classe dans la classe enfant. La méthode toujours de la classe super est invoquée. 
0
Ravindra babu

Chat ne peut pas cesser d'être un chat, même s'il s'agit d'un animal. Le chat va manger et le chat va boire à la manière d'un chat. Cela pourrait ressembler à ce que fait un animal, raison pour laquelle il remplace la méthode. Si vous voulez qu'il fasse ce que l'animal fait par défaut, ne le remplacez pas. Vous pouvez probablement faire des choses étranges avec réflexion et créer des méthodes distinctes qui accèdent aux méthodes parent telles que:

public void superDrink() {
   Animal.class.getMethod("drink").invoke();
}

mais cela pourrait être exagéré, vous ne pensez pas?

Bien sûr, cela ne fonctionnerait probablement pas car ce n'est pas statique. 

0
Jimi Kimble