Java—一般处理子类的创建

除了一个方法之外，我有三个非常相似的类。因此，我选择将它们的其余功能放入一个抽象超类中。然而，当涉及到创建这些类的实例时，我不知道如何实现我认为“显而易见”或“优雅”的方法。它们的构造函数本质上是相同的，我需要每个构造函数的多个实例，因此我想做如下操作：

private SubclassA[] subclassA_array, SubclassB[] subclassB_array, SubclassC[] subclassC_array;
subclassA_array = new SubclassA[getNumInstancesOfClassANeeded()]
subclassB_array = new SubclassA[getNumInstancesOfClassBNeeded()]
subclassC_array = new SubclassA[getNumInstancesOfClassCNeeded()]

// might have my syntax wrong here; array of the three subclass arrays
private Superclass[][] superArray = new Superclass[][3];
superArray[0] = subclassA_array;
superArray[1] = subclassA_array;
superArray[2] = subclassA_array;
for ( Superclass[] array: superArray )
    for(int i = 0; i< array.length; i++)
      //  array[i] = new..... what goes here?
    }
}

private subassa[]subassa_数组，subassb[]subassb_数组，subassc[]subassc_数组；
Subassa_数组=新的Subassa[GetNumInstanceOfClassaneded（）]
子类B_数组=新的子类[getNumInstancesOfClassBNeeded（）]
subassc_array=新的subassa[getNumInstancesOfClassCNeeded（）]
//这里可能有我的语法错误；三个子类数组的数组
私有超类[][]超数组=新超类[][3]；
superArray[0]=子SSA_数组；
superArray[1]=子SSA_数组；
superArray[2]=子SSA_数组；
for（超类[]数组：超数组）
for（int i=0；i

---

如何在最内部的循环中找到要构造的适当类？这真的是一种处理问题的奇怪方式吗；我错过了更明显的东西吗？我是不是应该说“见鬼去吧！”然后就有三个独立的循环？

您可以在内部循环中使用反射，比如

array.getClass（）.getComponentType（）.newInstance（）

，但我认为可能有更好的解决方案来解决整个问题（为了回答这个问题，我需要更多关于您想要编写什么代码的信息）

您可以创建一个静态方法

public static subclassA[] getNewInstances(int numberOfInstances);

无需创建新实例即可访问静态方法

subassa.getNewInstances（3）

在矩阵的定义中，首先需要定义第一个维度（因此它成为

新的超类[3][]

我应该说“见鬼去吧！”然后就有三个独立的循环吗

对

---

您可以执行以下操作：

private SubclassA[] subclassA_array, SubclassB[] subclassB_array, SubclassC[] subclassC_array;
subclassA_array = new SubclassA[getNumInstancesOfClassANeeded()]
subclassB_array = new SubclassA[getNumInstancesOfClassBNeeded()]
subclassC_array = new SubclassA[getNumInstancesOfClassCNeeded()]

// might have my syntax wrong here; array of the three subclass arrays
private Superclass[][] superArray = new Superclass[][3];
superArray[0] = subclassA_array;
superArray[1] = subclassA_array;
superArray[2] = subclassA_array;
for ( Superclass[] array: superArray )
    for(int i = 0; i< array.length; i++)
      //  array[i] = new..... what goes here?
    }
}

使用

array.getClass（）

获取数组的类

使用

getConComponentType（）

获取数组的基类型

使用

newInstance（）

创建实例

将实例引用指定给数组

---

…但这会产生脆弱的代码，就像用大锤敲碎核桃一样。

我不认为我会走这条路，但这是一个有趣的视角。谢谢！你能解释一下“脆弱”吗注释？它很脆弱，因为步骤2和步骤3涉及可能引发异常的反射操作。相比之下，使用简单的方法，大多数/所有检查都发生在编译时。编译时类型安全性/类型检查更健壮。