如何重构仅泛型列表字段不同的两个重复类？

当然可以移除Class2！针对你的需求，有几种实用的解决方案，咱们一个个来看：

这是最灵活也最符合Java类型安全原则的做法。把原来的Class1改成泛型类，让field3的元素类型可以动态指定：

public class GenericClass<T> {
    private String field1;
    private String field2;
    private List<T> field3;

    // 构造器示例
    public GenericClass(String field1, String field2, List<T> field3) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
    }

    // 对应的getter和setter
    public String getField1() { return field1; }
    public void setField1(String field1) { this.field1 = field1; }
    // ... 其他getter/setter省略
}

使用的时候，需要存String就实例化GenericClass<String>，需要存Object1就用GenericClass<Object1>：

// 存String的情况
List<String> stringList = Arrays.asList("a", "b");
GenericClass<String> stringInstance = new GenericClass<>("f1", "f2", stringList);

// 存Object1的情况
List<Object1> objList = Arrays.asList(new Object1(), new Object1());
GenericClass<Object1> objInstance = new GenericClass<>("f1", "f2", objList);

这种方式完全不需要额外的类，还支持未来扩展其他类型的元素，而且全程类型安全，不用做强制转换。

如果你的场景很简单，只是需要存储这两种类型，不需要频繁对元素做特定类型的操作，可以直接把field3定义为List<Object>：

public class UnifiedClass {
    private String field1;
    private String field2;
    private List<Object> field3;

    // 构造器、getter/setter
}

使用时可以直接往列表里加String或Object1：

UnifiedClass instance = new UnifiedClass();
instance.getField3().add("test string");
instance.getField3().add(new Object1());

不过要注意，从列表中取出元素时，你需要做强制类型转换，并且最好先判断类型避免ClassCastException：

for (Object item : instance.getField3()) {
    if (item instanceof String) {
        String str = (String) item;
        // 处理String的逻辑
    } else if (item instanceof Object1) {
        Object1 obj = (Object1) item;
        // 处理Object1的逻辑
    }
}

这种方式适合快速实现，但类型安全性不如泛型方案，代码可读性也稍差。

如果String和Object1有一些共同的行为，你可以定义一个统一的接口，让两者（或String的包装类）实现这个接口，然后用List<接口类型>来存储：

首先定义接口：

public interface Element {
    // 定义共同的方法，比如处理元素的方法
    void process();
}

因为String是final类无法直接实现接口，所以可以写一个包装类：

public class StringElement implements Element {
    private String value;

    public StringElement(String value) {
        this.value = value;
    }

    @Override
    public void process() {
        // 处理String的逻辑，比如打印value
        System.out.println("Processing string: " + value);
    }
}

让Object1实现这个接口：

public class Object1 implements Element {
    @Override
    public void process() {
        // 处理Object1的逻辑
        System.out.println("Processing Object1");
    }
}

最后修改统一类：

public class UnifiedClass {
    private String field1;
    private String field2;
    private List<Element> field3;

    // 构造器、getter/setter
}

使用时，把元素包装成Element类型存入列表，处理时直接调用接口方法即可，不用判断类型：

UnifiedClass instance = new UnifiedClass();
instance.getField3().add(new StringElement("test"));
instance.getField3().add(new Object1());

// 统一处理所有元素
for (Element elem : instance.getField3()) {
    elem.process();
}

这种方式完全符合OOP的多态思想，代码优雅且易于维护，但需要额外定义接口和包装类，适合有共同行为的场景。

内容的提问来源于stack exchange，提问作者Saad