如何用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()方法，只能在具体的子类中实现。

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); 
    } 
} 

Answer 2

如果你只是想在类的新实例，而不克隆其成员的值，那么你可以使用以下命令：

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 3

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

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 4

在某些罕见的情况下做到这一点，我们可能无法使用拷贝构造技术和有使用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字段，并且不读取任何字段。

如上所述，这是必需的情况，很少见。只要你可以实现一个基于拷贝构造函数的解决方案，就可以使用它。