复制构造函数很有用,但它们不是多态的。无参数方法可以帮助弥合差距,使代码保持松散耦合且易于克隆。
这是我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