关于Java：为什么接口不能实现另一个接口？


Why an interface can not implement another interface?

我的意思是：

1
2
3
4
5
interface B {...}

interface A extends B {...} // allowed  

interface A implements B {...} // not allowed

我在谷歌上找到了这个：

implements denotes defining an implementation for the methods of an interface. However interfaces have no implementation so that's not possible.

然而，接口是100%抽象类，抽象类可以实现接口(100%抽象类)，而不实现其方法。当它定义为"接口"时，有什么问题？

详细地说，

1
2
3
4
5
6
7
8
9
10
11
12
interface A {
    void methodA();
}

abstract class B implements A {} // we may not implement methodA() but allowed

class C extends B {
   void methodA(){}
}

interface B implements A {} // not allowed.
//however, interface B = %100 abstract class B

implements是指实施，当interface只是为了提供interface而不是为了实施。

100%abstract class在功能上等同于interface，但如果您愿意，它也可以实现(在这种情况下，它不会保持100%abstract)，因此从JVM的角度来看，它们是不同的。

此外，100%抽象类中的成员变量可以具有任何访问限定符，在接口中，它们隐式地是public static final。

相关讨论

implements表示将为abstract方法定义一个行为(显然除了抽象类)，您定义了实现。

extends表示行为是遗传的。

对于接口，可以说一个接口应该具有与另一个相同的行为，甚至没有实际的实现。这就是为什么它对一个与extends的接口，而不是实现另一个接口更有意义的原因。

另一方面，请记住，即使一个abstract类可以定义abstract方法(接口的正常方式)，它仍然是一个类，仍然必须继承(扩展)并且不被实现。

概念上有两个"域"类和接口。在这些域中，您总是在扩展，只有一个类实现一个接口，这有点"跨越边界"。所以基本上，接口的"扩展"反映了类的行为。至少我认为这是背后的逻辑。似乎并不是每个人都同意这种逻辑(我发现这有点做作自己)，事实上，没有任何技术上的理由有两个不同的关键字。

相关讨论

However, interface is 100% abstract class and abstract class can
implements interface(100% abstract class) without implement its
methods. What is the problem when it is defining as"interface" ?

这只是惯例问题。Java语言的作者们认为，"扩展"是描述这种关系的最好方式，所以这就是我们所使用的。

一般来说，即使接口是"100%抽象类"，我们也不会这样想。我们通常认为接口是实现某些关键方法的承诺，而不是从中派生的类。因此，我们倾向于对接口使用不同的语言，而不是对类使用不同的语言。

正如其他人所说，选择"扩展"而不是"工具"是有充分理由的。

相关讨论

希望这将有助于你有点我学到的OOP(核心Java)在我的大学。

implements表示定义接口方法的实现。然而，接口没有实现，所以这是不可能的。但是，一个接口可以扩展另一个接口，这意味着它可以添加更多的方法并继承其类型。

下面是一个例子，这是我的理解，也是我在OOPS中学到的。

1
2
3
4
5
6
7
interface ParentInterface{  
        void myMethod();  
}  

interface SubInterface extends ParentInterface{  
        void anotherMethod();  
}

记住一件事：一个接口只能扩展另一个接口，如果你想在某个类上定义它的函数，那么在下面实现的示例中，只有一个接口

1
2
3
4
5
6
public interface Dog
{
    public boolean Barks();

    public boolean isGoldenRetriever();
}

现在，如果一个类要实现这个接口，它将是这样的：

1
2
3
4
5
6
7
8
9
10
11
public class SomeClass implements Dog
{
    public boolean Barks{
    // method definition here

    }

    public boolean isGoldenRetriever{
    // method definition here
    }
}

如果一个抽象类有一些抽象函数define和declare，而你想要定义那些函数，或者你可以说实现那些函数，那么你应该扩展这个类，因为抽象类只能被扩展。下面是示例。

1
2
3
4
public abstract class MyAbstractClass {

    public abstract void abstractMethod();
}

下面是MyAbstractClass的一个子类示例：

1
2
3
4
5
6
public class MySubClass extends MyAbstractClass {

    public void abstractMethod() {
        System.out.println("My method implementation");
    }
}

Interface是包含无法创建任何对象的抽象方法的类。由于Interface无法创建对象，而且它不是纯类，因此不值得实现它。