重複此java代碼複製

Question

我有大約10多個類，每個類都有一個LUMP_INDEX和SIZE靜態常量。 我想要這些類中的每一個的數組，其中使用這兩個常量來計算數組的大小。 目前我有一個函數爲每個類創建陣列，沿着線的東西：

private Plane[] readPlanes() 
{ 
    int count = header.lumps[Plane.LUMP_INDEX].filelen/Plane.SIZE; 
    Plane[] planes = new Plane[count]; 
    for(int i = 0; i < count; i++) 
     planes[i] = new Plane(); 

    return planes; 
} 

private Node[] readNodes() 
{ 
    int count = header.lumps[Node.LUMP_INDEX].filelen/Node.SIZE; 
    Node[] nodes = new Node[count]; 
    for(int i = 0; i < count; i++) 
     nodes[i] = new Node(); 

    return nodes; 
} 

private Leaf[] readLeaves() 
{ 
    int count = header.lumps[Leaf.LUMP_INDEX].filelen/Leaf.SIZE; 
    Leaf[] leaves = new Leaf[count]; 
    for(int i = 0; i < count; i++) 
     leaves[i] = new Leaf(); 

    return leaves; 
} 

等 有這些功能中的10，唯一的差別是類的類型，從而你可以看到，有很多重複。

有沒有人有任何想法如何避免這種重複？ 謝謝。 （我之前問過類似的問題，但我猜我的方式有點偏離）

Answer 1

Okey doke ...我已經測試了這個以確保它，並且我相信它能做到您要找的。

您需要的接口：

public interface MyInterface 
{ 
    public int getSize(); 
    public int getLumpIndex(); 
} 

你的類實現該接口：

public class Plane implements MyInterface 
{ 

    ... 
    public int getSize() 
    { 
     return SIZE; 
    } 

    public int getLumpIndex() 
    { 
     return LUMP_INDEX; 
    } 

} 

在類header是，你有一個實例...

public <E extends MyInterface> E[] 
    getArray(Class<E> c, MyInterface foo) 
{ 
    int count = lumps[foo.getLumpIndex()].filelen/foo.getSize(); 
    E[] myArray = (E[]) Array.newInstance(c, count); 
    for(int i = 0; i < count; i++) 
     myArray[i] = c.newInstance(); 
    return myArray; 
} 

你可以說，你的飛機班如下：

Plane[] p = header.getArray(Plane.class, this); 

我認爲？ :)有人可以看看這個，看看我是否關閉？

（編輯： Becasue我現在已經測試了它 - 這工作）

在附加的註釋，你可以通過使getArray()採取的規模和指標作爲參數消除每一類干將：

public <E extends MyInterface> E[] 
    getArray(Class<E> c, int size, int index) 
{ 
    int count = lumps[index].filelen/size; 
    E[] myArray = (E[]) Array.newInstance(c, count); 
    for(int i = 0; i < count; i++) 
     myArray[i] = c.newInstance(); 
    return myArray; 
} 

，並調用它爲：

Plane p[] = header.getArray(Plane.class, SIZE, LUMP_INDEX); 

從你的類裏面。接口只是變空以提供泛型類型，而不必定義getter方法。

OR（最後編輯我答應了，但是這確實給你的選擇，並解釋了一些關於仿製藥）

溝的接口。這是什麼去除一些健全檢查，因爲該方法不關心你給什麼類型的對象是：

public <E> E[] 
    getArray(Class<E> c, int size, int index) 
{ 
    ... 

現在，你不必定義接口或者實現它，你只要致電：

Plane p[] = header.getArray(Plane.class, SIZE, LUMP_INDEX); 

Answer 2

使用Java generics。這樣，您可以只編寫一個泛型方法，並在每次使用時指定一個類型參數。

Answer 3

使用泛型，但你需要在某種工廠對象傳遞給構建實例放入您的收藏中，如：

public class MyClass { 

public <E> E[] getArray(IObjectFactory builder, int index, int size){ 
    ArrayList<E> arrayList = new ArrayList<E>(); 
    int count = header.lumps[index].filelen/size;//wasn'tsure where header was coming from... 
    for(int i = 0; i< count; i++){ 
     E newInstance = builder.getNewInstance(); 
     arrayList.add(newInstance); 
    } 
    return (E[]) arrayList.toArray(); 
    } 
}  

interface IObjectFactory { 
<E> E getNewInstance(); 
} 

Answer 4

巴拉的解決方案是密切。儘管你不能訪問泛型類型的常量，所以我會創建一個getCount（）（或者任何你想命名它的東西），並讓每個子類型用適當的常量來實現它。

interface LumpySize<L extends LumpySize> { 
    int getCount(); // subtypes return the appropriate header.lumps[Plane.LUMP_INDEX].filelen/Plane.SIZE; 

    T[] initializeArray(); 

    abstract <T extends LumpySize> static class Base implements LumpySize<T> { 
     protected T[] initializeArray(Class<T> cls) { 
      int count = getCount(); 
      T[] lumps = (T[]) Array.newInstance(cls, count); 
      for(int i = 0; i < count; i++) { 
       try { 
        lumps[i] = cls.newInstance(); 
       } catch (Exception e) { // obviously this isn't good practice. 
        throw new RuntimeException(e); 
       } 
      } 
      return lumps; 
     }  
    }    
} 

class Plane extends LumpySize.Base<Plane> { 
    public int getCount() { 
     return header.lumps[Plane.LUMP_INDEX].filelen/Plane.SIZE; // assuming header is available somewhere 
    } 
    public Plane[] initializeArray() { return initializeArray(Plane.class); } 
}