在 Java 8 中实现两个具有相同签名的默认方法的两个接口

Question

假设我有两个接口：

public interface I1
{
    default String getGreeting() {
        return "Good Morning!";
    }
}

public interface I2
{
    default String getGreeting() {
        return "Good Afternoon!";
    }
}

如果我想同时实现它们，将使用什么实现？

public class C1 implements I1, I2
{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }
}

Answer 1

这是一个编译时错误。两个接口不能有两个实现。

但是，如果你在C1中实现getGreeting方法是正确的：

public class C1 implements I1, I2 // this will compile, bacause we have overridden getGreeting()
{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }

    @Override public String getGreeting()
    {
        return "Good Evening!";
    }
}

我只想补充一点，即使 I1 中的方法是抽象的，并且在 I2 中是默认的，你也不能同时实现它们。所以这也是编译时错误：

public interface I1
{
    String getGreeting();
}

public interface I2
{
    default String getGreeting() {
        return "Good afternoon!";
    }
}

public class C1 implements I1, I2 // won't compile
{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }
}

Answer 2

这不是特定于问题的。但是，我仍然认为它为上下文增加了一些价值。作为@toni77 答案的补充，我想补充一点，可以从实现类调用默认方法，如下所示。在下面的代码中，interface I1 中的默认方法 getGreeting() 是从被覆盖的方法中调用的：

public interface I1 {
     default String getGreeting() {
        return "Good Morning!";
     }
}

public interface I2 {
    default String getGreeting() {
        return "Good Night!";
    }
}

public class C1 implements I1, I2 {       
    @Override
    public String getGreeting() {
        return I1.super.getGreeting();
    }
}

Answer 3

如果一个类实现了 2 个接口，这两个接口都具有具有相同签名的 java-8 默认方法（如您的示例中所示），则实现类为 obliged to override the method。类can still access the default method 使用I1.super.getGreeting();。它可以访问其中一个、两个或一个都不访问。所以以下将是 C1 的有效实现

public class C1 implements I1, I2{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }

    @Override //class is obliged to override this method
    public String getGreeting() {
        //can use both default methods
        return I1.super.getGreeting()+I2.super.getGreeting();
    }

    public String useOne() {
        //can use the default method within annother method
        return "One "+I1.super.getGreeting();
    }

    public String useTheOther() {
        //can use the default method within annother method
        return "Two "+I2.super.getGreeting();
    }


}

Answer 4

根据解析规则，这实际上是有效的。如果其中一个接口扩展了其他接口之一。

使用上面的例子：

public interface I2 extends I1 {
    default String getGreeting() {
        return "Good Afternoon!";
    }
}

结果是：

下午好！

但是，我相信这将是一个大问题。默认接口的全部原因是允许库开发人员在不破坏实现者的情况下发展 api。

可以理解，它们不允许通过扩展在没有继承结构的情况下编译方法，因为库开发人员可能会劫持行为。

但是，这有可能会弄巧成拙。如果一个类实现了两个与分层视图无关的接口，但都定义了相同的默认方法签名，则扩展这两个接口的类将无法编译。 （如上所示）

可以想象，两个不同的库开发人员可以决定在不同的时间使用公共签名添加默认方法；事实上，这很可能会发生在实现类似概念的库中，例如数学库。如果您碰巧是在同一个类中实现两个接口的遗憾灵魂，那么您将在更新时崩溃。

Answer 5

我相信规则是实现重复默认方法的类“必须”覆盖实现。以下编译并运行良好...

public class DupeDefaultInterfaceMethods {

interface FirstAbility {
    public default boolean doSomething() {
        return true;
    }
}

interface SecondAbility {
    public default boolean doSomething() {
        return true;
    }
}

class Dupe implements FirstAbility, SecondAbility {
    @Override
    public boolean doSomething() {
        return false;
    }
}

public static void main(String[] args) {
    DupeDefaultInterfaceMethods ddif = new DupeDefaultInterfaceMethods();
    Dupe dupe = ddif.new Dupe();
    System.out.println(dupe.doSomething());

    }
}

---

> false

Answer 6

Java 8 中的默认方法可以看作是多重继承的一种形式（除了属性不能被继承）。

默认方法背后的主要动机是，如果在某些时候我们需要向现有接口添加方法，我们可以在不更改现有实现类的情况下添加方法。这样，该接口仍然与旧版本兼容。这是一个很酷的功能。但是，我们应该记住使用默认方法的动机，并且应该保持接口和实现的分离。

interface First{ 
    // default method 
    default void show(){ 
         System.out.println("Default method implementation of First interface."); 
}  } 

interface Second{ 
   // Default method 
   default void show(){ 
        System.out.println("Default method implementation of Second interface."); 
}  } 

// Implementation class code 
public class Example implements First, Second{ 
    // Overriding default show method 
    public void show(){
       First.super.show();
       Second.super.show();
} 
    public static void main(String args[]){ 
       Example e = new Example(); 
       e.show(); 
}  }