4

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

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

编辑：

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

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

4

4 回答 4

2

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;
}
}
于 2012-04-11T22:11:24.600 回答
1

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

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

这里的 Dog 类在其超类 Animal 中具有吃方法体。所以它不会要求在 Animal 中再次实现 body，因为它已经实现了。

于 2012-04-11T09:34:34.033 回答
0

只有一种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()
    }
}

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

于 2012-04-11T09:43:35.807 回答
0

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

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

}

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

于 2012-04-11T09:35:26.213 回答