Java 如何在ArrayList中检索值<；对象>；其中包含两个不同的对象类型arraylist。。？

我有两种类型的ArrayList

ArrayList

和

ArrayList

然后我创建了另一个

ArrayList

，因为object是每种对象类型的超类

ArrayList<Object1> obj1 = new ArrayList<Object1>();

ArrayList<Object2> obj2 = new ArrayList<Object2>();

ArrayList obj1=新的ArrayList（）；
ArrayList obj2=新的ArrayList（）；

这两个对象类有自己特定的getter和setters方法

ArrayList<Object> obj3 = new ArrayList<Object>();


obj3.add(obj1);
obj3.add(obj2);

ArrayList obj3=新的ArrayList（）；
obj3.添加（obj1）；
obj3.add（obj2）；

现在，当我访问obj3时，我想获取obj1和obj2的getter和setter

---

任何人都可以提供解决方案吗？

您将从

obj3

中提取对象识别为

Object

，而不是它们各自的类型

您可以：

检查通过

instanceof

提取的每个对象的类型，并在访问getter之前进行适当的强制转换。这很讨厌

或者，（更好）实现一个包含适当getter的公共接口。该接口将由

obj3

列表中的每个对象实现，该列表将被定义为

ArrayList

，其中

MyInterface

定义了您的getter

---

从根本上说，这是一个建模问题。通过将所有内容放入

对象的列表中

，您可以说您对这些对象所了解的只是它们是

对象

。相反，您需要充分利用您的解决方案。

您会发现，您将对象从

obj3

中提取为

对象，而不是它们各自的类型

您可以：

检查通过
instanceof
提取的每个对象的类型，并在访问getter之前进行适当的强制转换。这很讨厌
或者，（更好）实现一个包含适当getter的公共接口。该接口将由
obj3
列表中的每个对象实现，该列表将被定义为
ArrayList
，其中
MyInterface
定义了您的getter
从根本上说，这是一个建模问题。通过将所有内容放入
对象的列表中
，您可以说您对这些对象所了解的只是它们是
对象
。相反，您需要充分利用您的解决方案。
您会发现，您将对象从
obj3
中提取为
对象，而不是它们各自的类型

您可以：

检查通过
instanceof
提取的每个对象的类型，并在访问getter之前进行适当的强制转换。这很讨厌
或者，（更好）实现一个包含适当getter的公共接口。该接口将由
obj3
列表中的每个对象实现，该列表将被定义为
ArrayList
，其中
MyInterface
定义了您的getter
从根本上说，这是一个建模问题。通过将所有内容放入
对象的列表中
，您可以说您对这些对象所了解的只是它们是
对象
。相反，您需要充分利用您的解决方案。
您会发现，您将对象从
obj3
中提取为
对象，而不是它们各自的类型

您可以：

检查通过
instanceof
提取的每个对象的类型，并在访问getter之前进行适当的强制转换。这很讨厌
或者，（更好）实现一个包含适当getter的公共接口。该接口将由
obj3
列表中的每个对象实现，该列表将被定义为
ArrayList
，其中
MyInterface
定义了您的getter
从根本上说，这是一个建模问题。通过将所有内容放入
对象的列表中
，您可以说您对这些对象所了解的只是它们是
对象
。相反，您需要充分利用您的解决方案。
如果它是一个扩展范围很少的简单对象，您可以使用
instanceof

class ObjectType1 {
    String getData1() {
        return "data 1";
    }
}

class ObjectType2 {
    String getData2() {
        return "data 2";
    }
}
private String getData(Object obj) {
    if (obj instanceof ObjectType1)
        return ((ObjectType1) obj).getData1();
    else
        return ((ObjectType2) obj).getData2();
}

但是，为了获得良好的编程实践，请尝试使用接口或抽象
基本接口实现可能如下所示

interface DataHolder{
    String getData();
}
class ObjectType1 implements DataHolder {
    String getData1() {
        return "data 1";
    }
    public String getData(){
        return getData1();
    }
}

class ObjectType2  implements DataHolder {
    String getData2() {
        return "data 2";
    }
    public String getData(){
        return getData2();
    }
}
List<DataHolder> dataSet = new ArrayList<DataHolder>();

private void print() {
    dataSet.add(new ObjectType1());
    dataSet.add(new ObjectType2());
    for (DataHolder iHolder : dataSet){
        System.out.println(iHolder.getData());
    }
}

接口数据持有者{
字符串getData（）；
}
类ObjectType1实现DataHolder{
字符串getData1（）{
返回“数据1”；
}
公共字符串getData（）{
返回getData1（）；
}
}
类ObjectType2实现数据持有者{
字符串getData2（）{
返回“数据2”；
}
公共字符串getData（）{
返回getData2（）；
}
}
列表数据集=新的ArrayList（）；
私人作废打印（）{
add（新的ObjectType1（））；
add（新的ObjectType2（））；
对于（数据持有者iHolder:dataSet）{
System.out.println（ihold.getData（））；
}
}
如果它是一个扩展范围很少的简单对象，例如，你可以使用
instanceof

class ObjectType1 {
    String getData1() {
        return "data 1";
    }
}

class ObjectType2 {
    String getData2() {
        return "data 2";
    }
}
private String getData(Object obj) {
    if (obj instanceof ObjectType1)
        return ((ObjectType1) obj).getData1();
    else
        return ((ObjectType2) obj).getData2();
}

但是，为了获得良好的编程实践，请尝试使用接口或抽象
基本接口实现可能如下所示

interface DataHolder{
    String getData();
}
class ObjectType1 implements DataHolder {
    String getData1() {
        return "data 1";
    }
    public String getData(){
        return getData1();
    }
}

class ObjectType2  implements DataHolder {
    String getData2() {
        return "data 2";
    }
    public String getData(){
        return getData2();
    }
}
List<DataHolder> dataSet = new ArrayList<DataHolder>();

private void print() {
    dataSet.add(new ObjectType1());
    dataSet.add(new ObjectType2());
    for (DataHolder iHolder : dataSet){
        System.out.println(iHolder.getData());
    }
}

接口数据持有者{
字符串getData（）；
}
类ObjectType1实现DataHolder{
字符串getData1（）{
返回“数据1”；
}
公共字符串getData（）{
返回getData1（）；
}
}
类ObjectType2实现数据持有者{
字符串getData2（）{
返回“数据2”；
}
公共字符串getData（）{
返回getData2（）；
}
}
列表数据集=新的ArrayList（）；
私人作废打印（）{
add（新的ObjectType1（））；
add（新的ObjectType2（））；
对于（数据持有者iHolder:dataSet）{
System.out.println（ihold.getData（））；
}
}
如果它是一个扩展范围很少的简单对象，例如，你可以使用
instanceof

class ObjectType1 {
    String getData1() {
        return "data 1";
    }
}

class ObjectType2 {
    String getData2() {
        return "data 2";
    }
}
private String getData(Object obj) {
    if (obj instanceof ObjectType1)
        return ((ObjectType1) obj).getData1();
    else
        return ((ObjectType2) obj).getData2();
}

但是，为了获得良好的编程实践，请尝试使用接口或抽象
基本接口实现可能如下所示

interface DataHolder{
    String getData();
}
class ObjectType1 implements DataHolder {
    String getData1() {
        return "data 1";
    }
    public String getData(){
        return getData1();
    }
}

class ObjectType2  implements DataHolder {
    String getData2() {
        return "data 2";
    }
    public String getData(){
        return getData2();
    }
}
List<DataHolder> dataSet = new ArrayList<DataHolder>();

private void print() {
    dataSet.add(new ObjectType1());
    dataSet.add(new ObjectType2());
    for (DataHolder iHolder : dataSet){
        System.out.println(iHolder.getData());
    }
}

接口数据持有者{
字符串getData（）；