Java 从离散类和接口(interface)子类化？

Question

下图描述了 MyClass 的层次结构和MyOtherClass 。使用 Java 可以定义一个变量来保存 MyClass 的值。和MyOtherClass ，即将值限制为 JComponent 的子类的实例的变量定义。和 MyInterface 的实现以便从 JComponent 开始运行和MyInterface可以同时使用吗？

我意识到执行此操作的正常方法是创建一个扩展 JComponent 的中间抽象类。并实现MyInterface ，所以我想知道如果不这样做，这种行为是否可能。

奇怪的类层次结构背后的原因是我最初创建了 MyAbstractClass用作通用视觉类型，现在想为其添加一些功能，即 MyInterface ，用于其他地方。但是我还需要创建一些具有与 MyInterface 相同的附加功能的新类。但不是 MyAbstract 类的实例。如果我不必创建重复的 MyAbstractClass 那就太好了扩展了其他一些扩展 Jcomponent 的中间类和MyInterface .

o       JComponent
|
|\
| \
|  \
|   o   MyInterface
|   |
|   |\
|   | |
|\  | o MyClass
| | |
| o |   MyAbstractClass
| | |
| | |
| | /
| |/
| |
| o     MyOtherClass

Answer 1

只要变量对于任何给定实例都保持相同的类型，您就可以为变量使用上限泛型类型，并通过构造函数或变异方法注入(inject)对象。

以您的层次结构为例，下面的 Foo 有一个 T 类型的变量 bar，它必然是 的子类型在本例中为 >JComponent 和 MyInterface。然后您可以构造一个定义具体类型的 Foo 实例。实际上，您最好定义一个提供 MyInterface 方法的 JComponent 抽象子类。这样您就不会受到泛型类型的束缚。

福

public class Foo<T extends JComponent & MyInterface> {

    private T bar;

    public Foo(T bar) {
        this.bar = bar;
    }

    public void fooAction() {
        bar.interfaceMethod(); // MyInterface method
        System.out.println(bar.getWidth()); // JComponent method
    }
}

使用

public class Main {

    public static void main(String[] args) {
        Foo<MyClass> a = new Foo<>(new MyClass());
        Foo<MyOtherClass> b = new Foo<>(new MyOtherClass());
        a.fooAction();
        b.fooAction();
    }
}

输出

MyClass
0
MyOtherClass
0

同样的原则可以应用于静态方法，例如:

public class Main {

    public static void main(String[] args) {
        staticAction(new MyClass());
        staticAction(new MyOtherClass());
    }

    public static <T extends JComponent & MyInterface> void staticAction(T bar) {
        bar.interfaceMethod();
        System.out.println(bar.getWidth());
    }
}

<小时/>

为了完整起见，本示例中使用的类:

MyAbstractClass

public abstract class MyAbstractClass extends JComponent { }

我的界面

public interface MyInterface {

    void interfaceMethod();

}

我的类(class)

public class MyClass extends JComponent implements MyInterface {

    @Override
    public void interfaceMethod() {
        System.out.println("MyClass");
    }
}

我的其他类(class)

public class MyOtherClass extends MyAbstractClass implements MyInterface {

    @Override
    public void interfaceMethod() {
        System.out.println("MyOtherClass");
    }
}