Question

这是我的代码。我有一个基本界面来定义常用功能。

    interface BaseInterface<T> {
        void baseFunc(T param)
    }

    interface MyInterface1 extends BaseInterface<MyEntity1> {
        void func1()
    }

    interface MyInterface2 extends BaseInterface<MyEntity2> {
        void func2()
    }

我的班级是：

    abstract class BaseClass implements BaseInterface<T> {
        // ...some common things
    }

    class ClassA extends BaseClass implements MyInterface1 {
        @Override
        public void func1() {...}

        @Override
        public void baseFunc(MyEntity1 param) {...}
    }

    class ClassB extends BaseClass implements MyInterface2 {
        @Override
        public void func2() {...}

        @Override
        public void baseFunc(MyEntity2 param) {...}
    }

不同的类使用不同的bean MyEntity1和MyEntity2来做同样的事情。所以我用通用T。

定义了baseFunc（）

但这里有一个问题。 “两种方法都有相同的擦除但是没有覆盖其他baseFunc（T）和baseFunc（MyEntity1）......”

如何解决这个问题？

顺便说一下，当我删除泛型并将baseFunc移动到MyInterface1和MyInterface2时，它工作正常。但我不认为这是最好的方式。

Answer 1

声明

abstract class BaseClass implements BaseInterface<T>

除非T是实际的类，否则

没有意义。如果它正在实现通用接口，则需要

是通用类，或
提供一个类型参数来代替泛型类型参数。

我相信你真正想写的是

abstract class BaseClass<T> implements BaseInterface<T>

将BaseClass保留为通用类。然后，您可以将其他类声明为

class ClassA extends BaseClass<MyEntity1> implements MyInterface1

和

class ClassB extends BaseClass<MyEntity2> implements MyInterface2

然后传递给baseFunc方法的类型不会发生冲突。

使用泛型实现接口，两种方法都具有相同的擦除

1 个答案: