如何在实例方法中从抽象类中创建新实例？

Question

我希望能够在类型为抽象的变量中创建一个类的新实例。

class Scratch {
    public static void main(String[] args) {
        Implementation implementation = new Implementation();
        // ...Later in the code Implementation is abstracted away and it's AbstractClass
        AbstractClass implementedAbstractClass = implementation;
        AbstractClass newInstance = implementedAbstractClass.newInstance();
    }
}

abstract class AbstractClass {
    protected abstract AbstractClass createNewInstance();
    
    public AbstractClass newInstance() {
        return createNewInstance();
    }
}

class Implementation extends AbstractClass {
    @Override
    protected AbstractClass createNewInstance() {
        return new Implementation();
    }
}

这可行，但我想避免在我所做的每个实现中都必须实现 createNewInstance() 的样板。

我尝试更改 AbstractClass 以接受类型参数：AbstractClass<T extends AbstractClass<T>>，然后是 Implementation extends AbstractClass<Implementation> 然后调用new T()，当然这也不起作用，因为Java在编译时不知道T是什么，所以它不能在类文件中添加构造指令。

之后我尝试调用AbstractClass.class.getDeclaredConstructor().newInstance()，但这更没有意义，因为我只是在尝试构造一个 AbstractClass 的实例，这是不可能的，因为它是抽象的，也不是我需要的。

Answer 1

AbstractClass.class.newInstance() 的尝试非常接近。

要构造实现类的实例，我们需要使用this 关键字获取它自己的类。由于抽象类无法实例化，所以在抽象类的实例方法中使用this会引用实现类。

正确的调用代码是this.getClass().getDeclaredConstructor().newInstance()。

那么createNewInstance()方法就可以去掉了：

class Scratch {
    public static void main(String[] args) {
        Implementation implementation = new Implementation();
        // ...Later in the code Implementation is abstracted away and it's AbstractClass
        AbstractClass implementedAbstractClass = implementation;
        AbstractClass newInstance = implementedAbstractClass.newInstance();
    }
}

abstract class AbstractClass {
    public AbstractClass newInstance() {
        try {
            return this.getClass().getDeclaredConstructor().newInstance();
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException("Failed to construct instance of " + this, e);
        }
    }
}

class Implementation extends AbstractClass {
}

Answer 2

构造函数不是继承的，因此没有安全的方法在抽象中引用它们。但是您可以将它们作为方法引用传递：

abstract class AbstractClass {
    private final Supplier<AbstractClass> constructor;

    protected AbstractClass(Supplier<AbstractClass> constructor) {
        this.constructor = constructor;
    }

    public AbstractClass newInstance() {
        return constructor.get();
    }
}

class Implementation extends AbstractClass {
    public Implementation() {
        super(Implementation::new);
    }
}

就个人而言，我觉得在每个实例上保留一个额外的引用来存储本质上是静态的信息有点问题。但它可以使子类更简洁（如果你仍然声明了一个构造函数）。

您还可以进一步扩展它并使超类通用（如您在问题中建议的那样），以便Implementation.newInstance() 返回Implementation 而不是AbstractClass：

abstract class AbstractClass<T extends AbstractClass<T>> {
    private final Supplier<T> constructor;

    protected AbstractClass(Supplier<T> constructor) {
        this.constructor = constructor;
    }

    public T newInstance() {
        return constructor.get();
    }
}

class Implementation extends AbstractClass<Implementation> {
    public Implementation() {
        super(Implementation::new);
    }
}