Question

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

当我们尝试在eat()（比如Class）Dog和extends Animal implements Behave中编写方法eat()的正文时，{{1}方法实际上是指？ Animal或Behave中的那个。无论发生哪种情况，为什么会这样？

修改

在发布此问题之前，我在Eclipse上尝试了此方案。

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

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

这里狗类在其超级动物中吃方法体。所以它要求在Animal中再次实现body，因为它已经实现了。

Answer 3

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

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

在其他语言中，您可以明确声明方法从接口实现方法。

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

4 个答案: