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

Question

I'm trying to create an abstract class with an abstract method, which should be able to return any type of a list with items extending a SuperBean .

Later I then want to create a generic class which can add items to that lists. Example:

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;
        }
}

Question: how to I have to define the abstract getSublist() class so that I can add any T item that is an implementation of SuperBean ?

Answer 1

You will need to add to your generics in 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);
    }
}

Next, you will need to make SuperBean generic, with its subclasses defining the generic type parameter <T> :

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

Each subclass defines its generic type parameter appropriately:

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

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

And MyBean2 is defined similarly:

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

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

This allows you to declare services as follows:

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

Answer 2

Your generic parameters don't make sense here. If you make the generic types explicit, you can see where it's going wrong:

Add the generic parameter to your SuperBean :

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

and make that type explicit in the subtypes:

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

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

Now, in your service, you would have

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);
    }
}

The alternative would be to make the service as

class AbstractService<T extends SuperBean<T>>

Then you would be able to add items to the sublist, but your beans are not of the right type. For instance, MyBean1 does not extend SuperBean<MyBean1> , but it extends SuperBean<MyBean2> .

Answer 3

I'm not sure if this is what you want, but doesn't produce errors.

There are two abstract declarations, SuperBean and AbstractService (though AbstractService is defined, I assume that it should be abstract).

There are three declarations that are not abstract, MyBean{1,2,3}

I define awSuperBean just to see if it works.

The code you pasted doesn't have a (-grr- concrete) superBean defined yet. So, I define a superBean called awSuperBean and use it in the (abstract?) add method.

. .

///  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();
}

I think you should only use the parametric type identifier, T, in the abstract classes. Use the declared types in the superbean subtype definitions instead of confusing Ts.