Java泛型重构咨询：抽象相似子类公共逻辑的实现难题

嘿，作为自学Java的新手，能想到用泛型抽象重复代码真的超棒！你的思路完全没问题，只是在获取子类Class和对应Widget实例化这两个点上需要小技巧，咱们一步步来重构你的代码：

核心问题分析 #

你的两个子类ThingA和ThingB的重复逻辑主要有两部分：

1. newLink方法里创建ThingLink并添加数据的流程
2. createWidget方法里先获取someData再创建对应Widget的结构

要抽象这些逻辑，关键是解决两个痛点：

• 父类如何知道当前子类的Class（用来创建ThingLink）
• 父类如何调用对应子类的Widget.createMe()方法

重构后的泛型抽象类方案 #

我们可以通过构造器传递子类信息+抽象方法委托子类实现特有逻辑的方式解决，代码如下：

1. 泛型抽象父类Thing<T> #

public abstract class Thing<T> extends SomeClass {
    // 用final修饰，确保初始化后不修改，更安全
    private final String infoType;
    private final Class<?> thingClass;

    // 让子类在构造时传入自己的infoType和Class对象
    protected Thing(String infoType, Class<?> thingClass) {
        this.infoType = infoType;
        this.thingClass = thingClass;
    }

    // 公共的newLink逻辑，完全抽离到父类
    public ThingLink newLink(Parent parent, T info) {
        ThingLink link = new ThingLink(parent, thingClass);
        link.addData(infoType, info);
        return link;
    }

    // 公共的createWidget流程：先获取数据，再创建对应Widget
    @Override
    public Widget createWidget() {
        // 这里写两个子类都有的获取someData的公共逻辑
        Object someData = getSomeData();
        // 交给子类创建具体的Widget
        return createSpecificWidget(someData);
    }

    // 子类实现：获取当前类需要的someData（如果两个子类获取逻辑不同，就留空让子类实现）
    protected abstract Object getSomeData();

    // 子类必须实现：创建对应类型的Widget
    protected abstract Widget createSpecificWidget(Object someData);
}

2. 子类ThingA的实现 #

public class ThingA extends Thing<Integer> {
    private static final String INFO_TYPE = "int";

    public ThingA() {
        // 传入自己的INFO_TYPE和Class对象
        super(INFO_TYPE, ThingA.class);
    }

    @Override
    protected Object getSomeData() {
        // 这里写ThingA特有的获取someData的逻辑
        return someDataForThingA; // 替换成你的实际数据
    }

    @Override
    protected Widget createSpecificWidget(Object someData) {
        return ThingAWidget.createMe(someData);
    }
}

3. 子类ThingB的实现 #

public class ThingB extends Thing<String> {
    private static final String INFO_TYPE = "String";

    public ThingB() {
        // 传入自己的INFO_TYPE和Class对象
        super(INFO_TYPE, ThingB.class);
    }

    @Override
    protected Object getSomeData() {
        // 这里写ThingB特有的获取someData的逻辑
        return someDataForThingB; // 替换成你的实际数据
    }

    @Override
    protected Widget createSpecificWidget(Object someData) {
        return ThingBWidget.createMe(someData);
    }
}

关键细节说明 #

• 子类Class的传递：通过构造器让子类传入ThingA.class/ThingB.class，比用递归泛型（比如Thing<T, SELF extends Thing<T, SELF>>）更直观，适合新手理解，也避免了反射可能带来的问题。
• Widget的抽象：把创建具体Widget的逻辑委托给子类实现，父类只负责公共的流程（先获取数据再创建），符合单一职责原则。
• infoType的处理：用final修饰并通过构造器初始化，避免了用setter可能带来的状态混乱，因为每个子类的infoType是固定常量。

扩展优化（可选） #

如果getSomeData的逻辑在两个子类里是完全一样的，你可以直接在父类Thing<T>里实现这个方法，不用子类重复写，进一步减少冗余~

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