如何编写一个抽象类作为接口

Question

我已经在Google上广泛搜索该问题的答案，但是我或者不知道该术语是什么，否则就不可能，因此请原谅我的任何无知。

---

首先是代码，然后是原因。

package package1;
public interface MyInterface {
    public ... method1(...);
    public ... method2(...);
    public ... method3(...);
    public ... method4(...);

    public static interface|class DEFAULT extends|implements MyInterface {
        public abstract ... method1(...);

        public ... method2(...) {
            // code
        }

        public ... method3(...) {
            // code
        }

        public abstract ... method4(...);
    }
}

现在，通常我将抽象一个类来实现MyInterface ，但是在这种情况下，我不能这样做，因为Java（可以理解）不支持从多个类继承类（尽管接口可以扩展多个其他接口）。

我的（理想）用例应遵循以下原则：

package package3;
import package1.MyInterface;
import package2.SomeBaseClass;
public class MyClass extends SomeBaseClass implements MyInterface.DEFAULT {
    // other class code

    public ... method1(...) {
        // code
    }

    public ... method4(...) {
        // code
    }
}

我可能会想出一些解决方法，但是我想知道是否有一种更简单/更优雅的方法来进行此操作，然后再花大量时间编写可能最终被我未曾想到的东西所超越的代码。

---

编辑：我应该指定每个类/接口都来自不同的程序包（上面的代码已被修改以反映这种区别）。 基本上，我将两个程序包的功能合并为第三个程序包。

---

编辑：我想出了下面，我相信遵循建议的组成解决这个问题的解决方案\\评论。

package MyPackage;

import package1.SomeBaseClass;
import package2.MyInterface;

public class MyClass extends SomeBaseClass {
    private .. someVariable;

    private MyInterface myInterface = new MyInterface.DEFAULT() {
        public ... method1(...) {
            // do something with someVariable
        }

        public ... method4(...) {
            // code
        }
    };

    public void doSomethingThatRequiresMyInterface() {
        myInterface.method1(...);
    }
}

我理解正确吗？

Answer 1

如果您正在使用/可以使用Java 8，则“默认方法”可能就是您要寻找的-> http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

但是，我认为您离上面列出的代码想要达到的目标并不遥远。

MyInterface.java

    public interface MyInterface {
        public ... method1(...);
        public ... method2(...);
        public ... method3(...);
        public ... method4(...);
    }

Default.java

public abstract class Default implements MyInterface {
    public abstract ... method1(...);

    public ... method2(...) {
        // code
    }

    public ... method3(...) {
        // code
    }

    public abstract ... method4(...);
}

SomeBaseClass.java

public abstract class SomeBaseClass extends Default {
    public void someNewMethod();
}

MyClass.java

public class MyClass extends SomeBaseClass {
    // other class code

    @Override
    public ... method1(...) {
        // code
    }

    @Override
    public ... method4(...) {
        // code
    }
}

Answer 2

如果我很了解您的需求，那么我认为Java 8中引入的新默认方法（也称为防御者方法）可以为您提供帮助（ Oracle的教程 ）。

它们允许为接口方法定义默认行为，这样，实现它们的类就不必重复此默认行为（如果足够的话）。

引入它的主要目的是使Java开发团队可以在不破坏实现这些接口的现有代码的情况下向API接口添加新方法。

范例：

介面

public interface MyInterface {
    default void method1(String arg1, Object arg2){
        //code...
    }

    default String method2(){
        //code...
    }

    String method3();
}

实现类：

public class MyClass implements MyInterface {

    private String field1;

    public String method3(){
        //code...
    }

    public void someOtherMethod(){
        //code...
    }
}

在这种情况下，实现类不会实现标记为default的接口方法，因此仍可以调用它们，并将使用默认实现。 但是，它仍然必须实现接口中没有默认实现的method3 。

尽管有一些限制和警告，但在本博客文章中列出了其中的一些限制，请务必小心。

顺便说一句：您不必为Java中的接口方法指定“公共”访问器，因为它已经是默认的，

Answer 3

您可以使用组合，在其中您将创建一个实现该接口并提供默认功能的类，然后将默认实现的一个实例传递给具体的类。 如果具体类不提供功能，请调用默认实例实现的版本。

接口：

public interface Foo {

    int method1(int a, String b);

    String method2(int a);

    String method3(String b);

}

默认实现：

public class DefaultFoo implements Foo {

    @Override
    public int method1(int a, String b) {
        return a + b.length();
    }

    @Override
    public String method2(int a) {
        return a;
    }

    @Override
    public String method3(String b) {
        return b;
    }

}

具体实施：

public class GreenFoo implements Foo {

    Foo defaultFoo = new DefaultFoo();

    @Override
    public int method1(int a, String b) {
        return "Green " + a + ", Mean" + b;
    }

    @Override
    public int method2(int a) {
        return a*a;
    }

    @Override
    public int method3(Sting b) {
        // I don't want to implement this, so I just call the default.
        return defaultFoo.method3(b);
    }

}