复制构造函数很有用，但它们不是多态的。无参数方法可以帮助弥合差距，使代码保持松散耦合且易于克隆。
这是我Java克隆系列的第三篇文章。在我之前的文章中，用详细的代码解释了Java 克隆和克隆类型（浅克隆和深克隆）
和 Java 克隆：复制构造函数与克隆，我详细讨论了 Java 克隆，并解释了每个概念，如克隆是什么，
它是如何工作的，实现克隆的必要步骤、如何使用 Object.clone（）、
浅克隆和深度克隆、如何使用序列化和复制构造函数实现克隆以及复制构造函数比 Java 克隆具有优势。
为什么复制构造函数是不够的
如果您已经阅读了这些文章，您可以轻松地理解为什么最好使用复制构造函数来克隆或 Object.clone()。在本文中，我将讨论为什么复制构造函数是不够的。
复制构造函数本身是不够的。复制构造函数不是多态的，因为子类不会从父类继承构造函数。如果我们尝试从父类引用引用子对象，
我们将面临使用复制构造函数克隆它的问题。为了理解它，让我们举两个类的例子：Mammal和Human类和Human继承了Mammal，而Mammal类有一个字段类型和两个构造函数，
一个用于创建对象，另一个用于创建对象副本的一个构造函数：
class Mammal {
protected String type;
public Mammal(String type) {
this.type = type;
}
public Mammal(Mammal original) {
this.type = original.type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Mammal mammal = (Mammal) o;
if (!type.equals(mammal.type)) return false;
return true;
}
@Override
public int hashCode() {
return type.hashCode();
}
@Override
public String toString() {
return "Mammal{" + "type='" + type + "'}";
}
}
Human类继承了Mammal类，只有一个name的属性，一个正常的构造方法和一个复制构造函数来创建副本：
class Human extends Mammal {
protected String name;
public Human(String type, String name) {
super(type);
this.name = name;
}
public Human(Human original) {
super(original.type);
this.name = original.name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
Human human = (Human) o;
if (!type.equals(human.type)) return false;
if (!name.equals(human.name)) return false;
return true;
}
@Override
public int hashCode() {
int result = super.hashCode();
result = 31 * result + name.hashCode();
return result;
}
@Override
public String toString() {
return "Human{" + "type='" + type + "', name='" + name + "'}";
}
}
接着为两个类创建对象：
Mammal mammal = new Mammal("Human");
Human human = new Human("Human", "Naresh");
执行此操作时不会出错，并且两个对象都将成功克隆，如下图所示：
执行此操作时不会出错，并且两个对象都将成功克隆，如下图所示：
但是如果我们从一个Mammal引用引用一个Human对象会发生什么？
Mammal mammalHuman = new Human("Human", "Mahesh");
为了克隆mammalHuman，我们不能使用Human的构造器。它会给我们一个编译错误，
因为mammalHuman的类型是Mammal的类型，而Human类的构造器期望的是Human类型参数。
Mammal clonedMammalHuman = new Human(mammalHuman); // compilation error
并且，如果我们尝试使用Mammal类的复制构造函数来克隆mammalHuman，我们将会得到一个Mammal对象而不是Human对象，
但是mammalHuman会拥有Human对象
Mammal clonedMammalHuman = new Mammal(mammalHuman);
这样的话就像你在输出中看到的那样mammalHuman和clonedMammalHuman不是相同的对象
System.out.println("Object " + mammalHuman + " and copied object " + clonedMammalHuman + " are == : " + (mammalHuman == clonedMammalHuman));
System.out.println("Object " + mammalHuman + " and copied object " + clonedMammalHuman + " are equal : " + (mammalHuman.equals(clonedMammalHuman)) + "\n");
输出：
Object Human{type='Human', name='Mahesh'} and copied object Mammal{type='Human'} are == : false
Object Human{type='Human', name='Mahesh'} and copied object Mammal{type='Human'} are equal : false
我们可以看到，复制构造函数存在继承问题，并且不是多态的。那么，我们如何解决这个问题呢？嗯，有各种解决方案，如创建静态工厂方法或创建一些通用类，将为我们做到这一点
但有一个非常简单的解决方案，将需要复制构造函数，并且也将是多态的。我们可以使用防御性复制方法解决此问题，我们将在类中包括此方法，并从中调用复制构造函数.
防御性复制方法也将给我们带来依赖注入的优势。我们可以注入依赖关系，而不是使我们的代码紧密耦合。我们可以让它松散耦合，我们甚至可以创建一个接口来定义我们的防御性复制方法，然后我们可以在类中实现它并重写该方法。
public Mammal cloneObject() {
return new Mammal(this);
}
我们在Human类中也可以重写该方法：
@Override
public Human cloneObject() {
return new Human(this);
}
现在再次进行克隆mammalHuman：
Mammal clonedMammalHuman = mammalHuman.cloneObject();
对于最后两个系统输出，我们将获得以下输出，这是我们的预期行为:
Object Human{type='Human', name='Mahesh'} and copied object Human{type='Human', name='Mahesh'} are == : false
Object Human{type='Human', name='Mahesh'} and copied object Human{type='Human', name='Mahesh'} are equal : true
正如我们可以看到的，除了获得多态性的优势外，此选项还赋予我们传递任何参数的自由。您可以在 CopyConstructorExample Java file on GitHub找到完整的代码，请随时提供您的宝贵反馈。
原文链接：https://dzone.com/articles/java-cloning-even-copy-constructors-are-not-suffic
作 者： Naresh Joshi
译 者：lee
