如何在 Java 中克隆具有最终字段的抽象对象？

Question

在this 问题和post 中解释了如何使用受保护的复制构造函数克隆具有最终字段的对象。

但是，假设我们有：

public abstract class Person implements Cloneable
{
    private final Brain brain; // brain is final since I do not want 
                // any transplant on it once created!
    private int age;
    public Person(Brain aBrain, int theAge)
    {
        brain = aBrain; 
        age = theAge;
    }
    protected Person(Person another)
    {
        Brain refBrain = null;
        try
        {
            refBrain = (Brain) another.brain.clone();
            // You can set the brain in the constructor
        }
        catch(CloneNotSupportedException e) {}
        brain = refBrain;
        age = another.age;
    }
    public String toString()
    {
        return "This is person with " + brain;
        // Not meant to sound rude as it reads!
    }
    public Object clone()
    {
        return new Person(this);
    }

    public abstract void Think(); //!!!!
    …
}

返回错误，因为我们无法实例化抽象类。我们如何解决这个问题？

Answer 1

在极少数情况下，我们可能无法使用复制构造函数技术，而必须使用clone() 方法。对于这些情况，值得知道 Java 提供了解决 final 字段问题的方法：

public abstract class Person implements Cloneable {
    private final Brain brain;
    private int age;
    public Person(Brain aBrain, int theAge) {
        brain = aBrain; 
        age = theAge;
    }
    @Override public String toString() {
        return "This is person with " + brain;
        // Not meant to sound rude as it reads!
    }
    @Override public Person clone() {
        try {
            Person clone = (Person)super.clone();
            Field brainField=Person.class.getDeclaredField("brain");
            brainField.setAccessible(true);
            brainField.set(clone, brain.clone());
            return clone;
        } catch (CloneNotSupportedException|ReflectiveOperationException ex) {
            throw new AssertionError(ex);
        }
    }

    public abstract void think();

    …
}

重写final 限制的可能性正是为这样的用例创建的，克隆或反序列化对象，其中不会调用构造函数。 Java Language Specification, §17.5.3. Subsequent Modification of final Fields 声明：

在某些情况下，例如反序列化，系统需要在构造后更改对象的final 字段。 final 字段可以通过反射和其他依赖于实现的方式进行更改。唯一具有合理语义的模式是构造对象，然后更新对象的final 字段。在对象的final 字段的所有更新完成之前，不应使该对象对其他线程可见，也不应读取final 字段。

这正是该示例的工作原理，在克隆构建之后立即设置 final 字段，在克隆暴露给任何人之前，并且不读取任何字段。

如上所述，需要这样做的情况很少见。只要您可以实现基于复制构造函数的解决方案，就可以使用它。

Answer 2

我们不能实例化一个抽象类，但我们可以在子类中实现

class Teacher extends Person {

    public Teacher(Brain aBrain, int theAge) {
        super(aBrain, theAge);
    }

    protected Teacher(Person another) {
        super(another);
    }


    public Object clone() {
        return new Teacher(this);
    }
}

Answer 3

如果您只想要一个类的新实例而不克隆其成员的值，那么您可以使用以下内容：

public  static < T > T getNewInstance ( Class <T> type )
{
    try 
    {
        return type.newInstance()  ;
    } catch ( InstantiationException | IllegalAccessException e) 
    {
        e.printStackTrace();
    }
    return null ;
}

对于对象的深度克隆，您可以使用 com.rits.cloning.Cloner 实用程序。例如。 ：

private T clone(T resource){

    Cloner cloner = new Cloner();
    T cloneObject = (T) cloner.deepClone(obj);
    return cloneObject;
}

Answer 4

您不在抽象类中实现clone() 方法，只在具体子类中实现。

public class SomeConcretePerson extends Person
{
    public SomeConcretePerson (SomeConcretePerson another)
    {
        super (another); // this will invoke Person's copy constructor
    }

    public Object clone()
    {
        return new SomeConcretePerson(this);
    }
}