重复此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); } 
}