Java如何转换为泛型类型

Question

This is my class structure

public abstract class SuperClass

public class A extends SuperClass

public class B extends SuperClass

Now I have a frame which is going to display a list of A elements or a list of B elements, in order not to duplicate code I want to make it the most generic as possible. My idea is to save the class of the elements of the frame in a field:

public class MyFrame extends Frame {
    private final Class type; // type of the elements i'm going to display
    private final DefaultListModel list; // elements to show in a SelectionList

    public <T extends SuperClass> MyFrame(final List<T> elementsToDisplay, Class<T> type) {
         this.list = createListModel(elementsToDisplay);
         this.type = type;
    }

Now it's possible to call smth like

List<A> list = new LinkedList<>(...);
MyFrame frame = new MyFrame(list, A.class);

My problem is how to use the field type , for example when one item is selected in the frame I want to cast it to type class, but I don't know how. The following lines are pseudo-code

<T extend SuperClass> foo(T item) { ... }

// ----

Object selectedItem = list.get(selectionList.getSelectedIndex());
[type.class] castedItem = type.cast(selectedItem);
foo(castedItem);  

How can I cast from Object to the class that is holding type ?

Answer 1

If your goal is really to minimize code duplication by "making it the most generic as possible" (sic), why not do

class MyFrame<T extends SuperClass> {
    private final DefaultListModel list; 

    public MyFrame(final List<T> elementsToDisplay) {
        this.list = createListModel(elementsToDisplay);
    }
}

I would caution you, though, that it's easy to go overboard with your use of generics (especially right after you learn to use them :), and this may well be one of those cases. Also: As a general rule of thumb, any time you find yourself storing the type of a generic class as a field of that class, you should see that as a red flag that you probably need to reexamine your design.

Answer 2

if i proper understand your question the main reason to use generics is to avoid casting i suppose so at your method implementation where you know what type of object you need , you wont use the <T extends SuperClass> but <A> so that certain class will know its generic type to use. if u want to keep the method with <T extends SuperClass> then you have to check the instance of class inside the method and decide which type you ll cast. fe

if( object instanceof A)
 ((A)object).somethinkA();

else if(object instanceof B)
 ((B)object).somethinkB();

else
.....