覆盖父 Class 和接口中存在的方法（具有相同的签名）

Question

我们有一个Class （比如Animal ），我们有一个Interface （比如Behave ）。 Animal和Behave都有一个具有相同签名的方法（比如public void eat() ）。

当我们尝试在extends Animal并implements Behave Behave 的Class （比如Dog ）中编写方法eat()的主体时，实际引用的是哪个eat()方法？ Animal或Behave中的那个。 无论哪种情况发生，为什么会这样发生？

编辑：

在发布此问题之前，我在Eclipse上尝试过这种情况。

这里一个有趣的部分是，即使我正在实现Behave ，如果我不在Dog中创建一个eat()方法（即，如果我不实现Behave's继承抽象方法），就没有错误，因为我已经从Animal扩展了一个eat()方法。

Answer 1

which eat() method is actually referred to? 两个都。

试试这个：如果你根本不覆盖这个方法，当你用接口调用时，你会从父级那里得到一个。

Behave b = new Dog();
System.out.println(b.eat());//this will call eat from Animal if Dog did not override.

如果你覆盖，你总是从孩子那里得到一个：

Behavior b = new Dog();
Animal a = new Dog();

a.eat() and b.eat() will both refer to the eat inside of Dog class.

---

使用这些课程：

public class BClass {
public int add(int a, int b){
    return a*b;
}
}

public interface BInterface {
public int add(int a, int b);
}

public class BChild extends BClass implements BInterface{
public static void main(String... args){
    BInterface bi = new BChild();
    BClass bc = new BChild();
    System.out.println(bi.add(3, 5));
    System.out.println(bi.add(3, 5));
}

@Override
public int add(int a, int b){
    return a+b;
}
}

Answer 2

接口只能包含方法的主体定义，一旦实现，它必须实现所有定义的方法。 在你的例子中

class Dog extends Animal implements Behave
{
    @Override
    public void eat() {...}
 }

 abstract class Animal{
    public abstract void eat();
 }
 interface Behave{
    void eat();
 }

这里它需要一个抽象方法体，就像在 Main 方法中一样。 换个方式

class DOG extends Animal implements Behave{
    ...
}

class Animal{
   public  void eat(){
        ...
   }
}

interface Behave{
    void eat();
}

这里狗 class 在它的超级 class 动物中有吃法身体。 所以它不会要求在 Animal 中再次实现 body，因为它已经实现了。

Answer 3

接口只是定义了 class 必须提供的方法。 如果我们有

public class Animal{
    public void eat(){
        System.out.println("Om nom nom");
    }
}
public class Dog extends Animal{

}

Dog 现在提供了 eat 方法并且可以实现Behave 。

Answer 4

只有一个eat()方法，因为该语言的设计者认为让方法签名由其名称和参数类型组成的简单性比能够指定您正在提供的实现的复杂性更有用一个界面。

在 Java 中，如果两者具有不同的语义，请提供一个方法，该方法返回一个执行其他操作的 Behave 实例：

class Animal { 
    public void eat () { }
}

interface Behave { 
    void eat (); 
}

class Dog extends Animal { 
    public void eat () { 
        // override of Animal.eat()
    } 

    public Behave getBehave() { 
        return new Behave { 
            public void eat() { 
                BehaveEat(); 
            } 
        };
    }

    private void BehaveEat() {
        // effectively the implementation Behave.eat()
    }
}

在其他语言中，您可以显式 state 一个方法实现接口中的一个方法。