5

我有大约 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 个，唯一的区别是类类型，所以你可以看到，有很多重复。

有人对如何避免这种重复有任何想法吗？谢谢。（我之前问过类似的问题，但我想我问的方式有点不对劲）

4

4 回答 4

3

使用Java 泛型。这样，您只需编写一个泛型方法并在每次使用时指定一个类型参数。

于 2011-03-26T19:06:36.763 回答
2

巴拉的解决方案很接近。但是，您无法从泛型类型访问常量，因此我将创建一个 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); }
}
于 2011-03-26T19:36:59.153 回答
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 类中调用它：

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

我想？:) 有人可以看看这个，看看我是否离开？

（编辑：因为我现在已经测试过了 - 有效）

另外需要注意的是，您可以通过getArray()将大小和索引作为参数来消除每个类中的 getter：

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 方法。

或者（我保证最后一次编辑，但这确实给了你选择并解释了一些关于泛型的信息）

放弃界面。这消除了一些健全性检查，因为该方法不关心你给它什么类型的对象：

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

现在您不必定义或实现接口，只需调用：

Plane p[] = header.getArray(Plane.class, SIZE, LUMP_INDEX);
于 2011-03-26T20:11:08.220 回答
0

使用泛型，但您需要传入某种工厂对象来构造实例以放入您的集合中，例如：

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();
}
于 2011-03-26T19:16:35.010 回答