如何調用超類的重載方法

Question

如何在代碼中使用myAnimal實例調用Animal類的吃喝方法？

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

輸出我得到：

Cat Eats 
Cat Drinks 
Cat Eats 
Cat Drinks 

這是我期望的輸出：

Cat Eats 
Cat Drinks 
Animal Eats 
Animal Drinks 

Answer 1

你不能做你想做的。多態性的工作方式是通過做你所看到的。基本上貓總是知道它是一隻貓，並且總是表現得像一隻貓，無論你如何對待貓是貓，貓，貓科，貓科，貓科動物，食肉目，Theria，哺乳動物，脊椎動物，脊索動物，Eumetazoa，動物界，動物，對象，或其他任何東西:-)

Answer 2

這條線：

Animal myAnimal = myCat;

分配變量myAnimal對象myCat，這你之前創建。因此，當你在此之後調用myAnimal.eat()時，實際上是調用原始myCat對象的方法，該對象輸出Cat Eats。

如果要輸出Animal Eats，則必須將Animal實例指定給變量。所以，如果你這樣做，而不是：

Animal myAnimal = new Animal()

變量myAnimal將是Animal一個實例，從而將以前的分配改寫爲Cat。

如果你會打電話給在此之後myAnimal.eat()，你實際上調用Animal實例的eat()方法您已經創建，將輸出Animal Eats。

結論：你的代碼應該閱讀：

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 = new Animal();   
     myAnimal.eat(); 
     myAnimal.drink(); 
    } 
} 

Answer 3

請不要對這個答案投票......你可以在另外一個投票:-)這是一個不好回答，但顯示你將如何做你正在努力做的事......糟透了。

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

Answer 4

貓不能停止成爲一隻貓，即使它是一隻動物。貓會吃，貓會用貓的方式喝。它可能與動物所做的相似，這就是爲什麼它會覆蓋該方法。如果你想讓它做默認動物，不要重寫。你也許可以做一些奇怪的東西與反思並作出訪問父方法，如不同的方法：

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

但可能是矯枉過正你不覺得嗎？

當然，這可能不會工作，因爲它不是靜態的。

Answer 5

在這裏，你將有一個選項，選擇你要調用的方法。

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

Answer 6

如果您在每類中的方法靜態的，它應該工作。

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

上面的代碼將提供以下輸出

Cat Eats 
Cat Drinks 
Animal Eats 
Animal Drinks 

Answer 7

您可以創建類動物的構造，即另需馬斯作爲參數，並創建新的實例基礎上提供一個。

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

Answer 8

• 訪問靜態字段，實例字段和靜態方法依賴於類參考變量和不實際的對象到的變量指向的。
• 請記住，成員變量是被映射的，沒有被覆蓋。

• 這與在實例方法中發生的情況相反。
  在實例方法的情況下，調用對象的實際類別的方法。

  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 
  } 
  

在本例中雖然對象myCat被分配​​給一個動物對象的引用，（Animal myAnimal = myCat）實際的對象是Cat類型的，並且它的行爲，因爲它是貓。

希望這會有所幫助。

Answer 9

幾點建議：

1. 子類的引用不要傳遞給超類和除超類方法被調用的重寫的方法。從超類實例中調用超類方法。

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

2. 如果你想從調用子類的超類的方法，顯式調用父類方法的名稱與super.methodName（）;

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

3. 請勿在子類中重寫超類方法。總是調用超類方法。

Answer 10

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

OUTPUT：

貓吃（）稱爲

貓飲料（）稱爲

動物吃的（）稱爲

動物飲料（）稱爲

您需要創建超類Animal的對象或另一種選擇是使用關鍵字super在子類中的方法如super.eat()或super.drink()