Wie zum Aufruf der überschriebenen Methode der übergeordneten Klasse?

Hier haben Sie die Möglichkeit zu wählen, welche Methode Sie aufrufen möchten:

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");
    }
}

InformationsquelleAutor Andrii Dzhyrma

• Zugriff auf statische Felder Instanz-Felder und statische Methoden hängt von der Klasse der Referenzvariable und nicht das eigentliche Objekt auf das die variable verweist.
• Denken Sie daran, dass die Variablen sind schattiert, nicht überschrieben werden.

• Das ist das Gegenteil von dem, was passiert im Fall von Instanz-Methoden.
  
  Im Fall von Instanzen-Methoden die Methode der tatsächlichen Klasse des Objekts genannt wird.

  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
  }

In diesem Beispiel, obwohl die das Objekt myCat zugeordnet ist, um ein Tier-Objekt-Referenz (Animal myAnimal = myCat) das Eigentliche Objekt ist vom Typ Cat und es sich so verhält, wie es eine Katze ist.

Hoffe, das hilft.

InformationsquelleAutor tharindu_DG

Wenn Sie die Methoden in jeder Klasse statisch ist, sollte es funktionieren.

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

Den oben genannten code, geben Sie die folgende Ausgabe

Cat Eats
Cat Drinks
Animal Eats
Animal Drinks

InformationsquelleAutor Vbee

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");
    }
}

AUSGABE:

Katze Essen() aufgerufen

Katze trinken() aufgerufen

Tier Essen() aufgerufen

Tier trinken() aufgerufen

Müssen Sie erstellen ein Objekt von der super-Klasse Animal ODER eine andere Möglichkeit ist die Verwendung des keyword - super in der abgeleiteten Klasse Methoden, z.B. super.eat() oder super.drink()

InformationsquelleAutor cNgamba

Bitte nicht die Abstimmung über diese Antwort... können Sie Stimmen auf der anderen ein 🙂 Dies ist eine schlechte Antwort, aber er zeigt, wie Sie tun würde, was Sie versuchen zu tun... schlecht.

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

InformationsquelleAutor TofuBeer