Question

我正在尝试使用抽象方法创建一个抽象类，它应该能够返回任何类型的列表，其中的项目扩展为SuperBean。

稍后我想创建一个可以向该列表添加项目的泛型类。例如：

class AbstractService<T extends SuperBean> {
    //this is what I'm aiming for
    void add(T item) {
        // "is not applicable for the arguments (T)"
        superBean.getSublist().add(item);
    }
}

abstract class SuperBean {
    abstract List<? extends SuperBean> getSublist();
}

class MyBean1 extends SuperBean {
    List<MyBean2> sublist;

    List<MyBean2> getSublist() {
        return sublist;
    }
}

class MyBean2 extends SuperBean {
    List<MyBean3> sublist;

    List<MyBean3> getSublist() {
            return sublist;
        }
}

问题：如何定义abstract getSublist()类，以便我可以添加T item的任何SuperBean？

Answer 1

您需要在AbstractService：

中添加您的仿制品

//        Add S to be T's type parameter         Add <S> to SuperBean here
class AbstractService<S extends SuperBean, T extends SuperBean<S>> {
    // I'm assuming superBean is defined here.
    T superBean;

    //this is what I'm aiming for
    void add(S item) {
        superBean.getSublist().add(item);
    }
}

接下来，您需要使SuperBean泛型，其子类定义泛型类型参数<T>：

abstract class SuperBean<T extends SuperBean> {
    // Now you can define the abstract method properly:
    abstract List<T> getSublist();
}

每个子类都适当地定义其泛型类型参数：

class MyBean1 extends SuperBean<MyBean2> {
    List<MyBean2> sublist;

    List<MyBean2> getSublist() {
        return sublist;
    }
}

MyBean2的定义类似：

class MyBean2 extends SuperBean<MyBean3> {
    List<MyBean3> sublist;

    List<MyBean3> getSublist() {
            return sublist;
    }
}

这允许您按如下方式声明服务：

AbstractService<MyBean2, MyBean1> service1 = new AbstractService<MyBean2, MyBean1>();
AbstractService<MyBean3, MyBean2> service2 = new AbstractService<MyBean3, MyBean2>();

Answer 2

您的通用参数在这里没有意义。如果你明确地使用泛型类型，你可以看到它出错的地方：

将通用参数添加到SuperBean：

abstract class SuperBean<T extends SuperBean> {
    abstract List<T> getSublist();
}

并在子类型中明确指出该类型：

class MyBean1 extends SuperBean<MyBean2> {
    List<MyBean2> sublist;

    List<MyBean2> getSublist() {
        return sublist;
    }
}

现在，在您的服务中，您将拥有

class AbstractService<T extends SuperBean<S>> {

    void add(T item) {
        // you cannot do this because the items in the sublist of 
        // your super bean are of the wrong type.
        superBean.getSublist().add(item);
    }
}

另一种方法是将服务作为

class AbstractService<T extends SuperBean<T>>

然后您可以将项目添加到子列表中，但您的bean的类型不正确。例如，MyBean1不会延伸SuperBean<MyBean1>，但会扩展SuperBean<MyBean2>。

Answer 3

我不确定这是否是您想要的，但不会产生错误。

有两个抽象声明，SuperBean和AbstractService（虽然定义了AbstractService，但我认为它应该是抽象的。）

有三个非抽象的声明，MyBean {1,2,3}

我定义awSuperBean只是为了看它是否有效。

您粘贴的代码尚未定义（-grr-具体）superBean。所以，我定义了一个名为awSuperBean的superBean，并在（abstract？）add方法中使用它。

。

///  testing superbean implementation
//
class awSuperBean<MyBean1> extends SuperBean {
    List<MyBean1>  getSublist() { return new java.util.ArrayList<MyBean1>(); }
}
//
///

class AbstractService<T extends SuperBean> {

/// tests a superbean definition
//
    awSuperBean<T> asuperBean;

    //this is what I'm aiming for
    void add(T item) {
        // "is not applicable for the arguments (T)"

/// use the superbean
        asuperBean.getSublist().add(item);
    }
}

/// every defined SuperBean subtype will need to specify the type 
//  of SuperBean it will produce in it's getSublist call
// 
abstract class SuperBean<getSublist extends SuperBean> {  

/// use the type parameter
//
    abstract List<getSublist> getSublist();
}

我认为你应该只在抽象类中使用参数类型标识符T.在superbean子类型定义中使用声明的类型，而不是混淆Ts。

如何在抽象超类中定义泛型List？

3 个答案: