Question

假设我有以下代码：

interface HumanoidForm {
    default HumanoidForm reproduce() {
        <appropriate code for humanoid form reproduction>
    }
}

class Android extends Machine implements HumanoidForm {
    public HumanoidForm reproduce() {
        <appropriate code for android reproduction> // how to use HumanoidForm's default implementation here?
    }
}

现在假设＆＃34;适用于Android再现的代码＆＃34;最好通过使用＆＃34;适当的人形生物形式代码来描述＃34;作为一个子程序。我如何访问＆＃34;人形的适当代码＆＃34;从内部＆＃34;适当的代码为Android再现＆＃34;？我可以想到三种方式，但它们都不起作用：

只需调用reproduce（）即可调用覆盖实现。
写（（HumanoidForm）this）.reproduce（）仍然会调用覆盖的实现。
通过重写方法模仿超类中方法实现的重用，可以考虑编写super.reproduce（）。然而，这指的是机器的再现实现，甚至可能不存在。

所以似乎没有办法在默认方法中重用代码来覆盖。真的是这样吗？

Answer 1

HumanoidForm.super.reproduce();

Answer 2

实际上，您可以自由选择现有的实施方式。让我给你一个比你更复杂的场景。更糟糕的是，所有A，B＆amp; C具有相同的方法签名。

interface A {
    default void doWork() {
       System.out.println("Default implementation From A");
    }
}

interface B{
    default void doWork() {
      System.out.println("Default implementation From B");  
    }   
}

class C{
    void doWork(){
        System.out.println("Default implementation From C");
    }       
}

现在，我创建了一个C的子类，它实现了A＆amp; B：

class Tester extends C implements A, B
{
    @Override public void doWork(){
        A.super.doWork();  //Invoke A's implementation
        B.super.doWork();  //Invoke B's implementation
        super.doWork();    //Invoke C's implementation
    }
}

输出将是：

Default implementation From A
Default implementation From B
Default implementation From C

运行：

new Tester().doWork();

Answer 3

看看这个：https://blog.idrsolutions.com/2015/01/java-8-default-methods-explained-5-minutes/

特别是它所说的部分＆＃34;如果我们想在InterfaceA或InterfaceB中专门调用一个sayHi（）方法，我们也可以这样做：＆＃34;

public class MyClass implements InterfaceA, InterfaceB {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    // TODO code application logic here
}

@Override
public void saySomething() {
    System.out.println("Hello World");
}

@Override
public void sayHi() {
   InterfaceA.super.sayHi();
}

}

interface InterfaceA {

public void saySomething();

default public void sayHi() {
    System.out.println("Hi from InterfaceA");
}

}

interface InterfaceB {
 default public void sayHi() {
    System.out.println("Hi from InterfaceB");
}
}

Answer 4

所以似乎没有办法在默认方法中重用代码来覆盖。真的是这样吗？

不，您可以重复使用代码。您可以轻松地测试它，您将看到以下代码有效：

public class Test implements HumanoidForm
{             
    public static void main(String[] args) 
    {       
        new Test().reproduce();         
    }   

    @Override
    public void reproduce(){
        HumanoidForm.super.reproduce();  //Invoking default method
        System.out.println("From implementing class");
    }       
}

interface HumanoidForm {
    default void reproduce() {
       System.out.println("From default interface");
    }
}

<强>输出：

From default interface
From implementing class

如何在覆盖实现中调用接口的方法的默认实现？

4 个答案: