如何返回一個繼承類的向量？

Question

我正在尋找一個解決方案來實例化並返回一個Vector（或可比較的）類。

我的嘗試是這樣的（文物擴展超類）：

public Vector<? extends SuperClass> getAssignableClasses() 
{ 
Vector<? extends SuperClass> out = new Vector<SuperClass>(); 
out.add(Heritage.class); //does NOT work, IDE shows error message 

return out; 
} 

名單的聲明似乎是錯誤的。 我想通過這個我只能添加對象到列表中，但我怎樣才能使用泛型添加類？

在此先感謝！

Answer 1

我有一段時間沒有這樣做，但是當你需要添加東西時，不是'超'關鍵字嗎？ :)

Here是一個教程:)

Answer 2

我認爲問題是，你告訴Java做一個向量在超類派生的類型的對象。然後你添加一個類而不是一個對象。 一個骯髒的解決方案是創建一個類的向量，並在添加時進行測試，如果它是子類的話。

Answer 3

您正在嘗試添加Class的實例 - 即Heritage.class。您的Vector只允許SuperClass的子類。

您需要添加一個new Heritage()對象，但是您要構建其中的一個。

Answer 4

問題是，您正試圖向Vector（Heritage.class）中添加一個類，而不是具有相應類的對象。東西如下應該工作：

public Vector<? extends SuperClass> getAssignableClasses() 
{ 
    Vector<? extends SuperClass> out = new Vector<SuperClass>(); 
    out.add(new Heritage()); //this line is changed 
          //add appropriate constructor parameters as necessary 
    return out; 
} 

更新我重讀你的問題。回到具體的類，您將需要的東西如下（我沒有嘗試這個）：

public Vector<? extends SuperClass.class> getAssignableClasses() 
    { 
    Vector<? extends SuperClass> out = new Vector<SuperClass>(); 
    out.add(Heritage.class); //does NOT work, IDE shows error message 
    return out; 
    } 

Answer 5

或者-as其他人指出OUT-必須添加遺產的一個實例：new Heritage() ...

或者你必須以正確聲明向量來存儲類，而不是實例：

Vector<Class<? extends SuperClass>> 

Class<? extends SuperClass>意味着SuperClass.class或任何後裔...

重要事項：使用List而不是Vector。這是因爲Java 1.3的:)

添加了recomended列表界面：我檢查的代碼在您的評論，它似乎編譯OK：

import java.util.Vector; 

public class SuperClass { 
    public static void main() throws Exception { 
     Vector<Class<? extends SuperClass>> vector = new Vector<Class<? extends SuperClass>>(); 
     vector.add(SuperClass.class); 
     vector.add(Heritage.class); 
    } 

    public Vector<Class<? extends SuperClass>> getAssignableClasses() { 
     Vector<Class<? extends SuperClass>> out = new Vector<Class<? extends SuperClass>>(); 
     out.add(Heritage.class); 
     return out; 
    } 
} 

class Heritage extends SuperClass { 

} 

Answer 6

Vector是一個古老的，有些過時的類。我將使用一個通用的清單版本而不是：

public static List<Class<?>> getAssignableClasses(final Object o){ 
    final List<Class<?>> list; 
    if(o == null){ 
     list = Collections.emptyList(); 
    } else{ 
     list = new ArrayList<Class<?>>(); 
     Class<?> tmp = o.getClass(); 
     do{ 
      list.add(tmp); 
      tmp = tmp.getSuperclass(); 
     } while(tmp != null); 
    } 
    return list; 
} 

作爲獎勵，這裏是一家集基於上述方法都分配接口的方法：

public static List<Class<?>> getAssignableInterfaces(final Object o){ 
    final List<Class<?>> result; 
    final List<Class<?>> assignableClasses = getAssignableClasses(o); 
    if(assignableClasses.isEmpty()){ 
     result = Collections.emptyList(); 
    } else{ 
     final Set<Class<?>> interfaces = 
      new LinkedHashSet<Class<?>>(assignableClasses.size() * 2); 
     for(final Class<?> clazz : assignableClasses){ 
      interfaces.addAll(Arrays.asList(clazz.getInterfaces())); 
     } 
     result = new ArrayList<Class<?>>(interfaces); 
    } 
    return result; 
} 

測試：

public static void main(final String[] args){ 
    final Map<String, String> map = 
     new ConcurrentHashMap<String, String>(); 
    System.out.println(getAssignableClasses(map)); 
    System.out.println(getAssignableInterfaces(map)); 
} 

輸出：

[class java.util.concurrent.ConcurrentHashMap, class java.util.AbstractMap, class java.lang.Object] 
[interface java.util.concurrent.ConcurrentMap, interface java.io.Serializable, interface java.util.Map]