Java克隆：只复制构造函数远远不够

最新推荐文章于 2021-02-24 19:18:19 发布

陆理手记

最新推荐文章于 2021-02-24 19:18:19 发布

阅读量365

点赞数

点击左上角蓝字，关注“锅外的大佬” 640?wx_fmt=gif

专注分享国外最新技术内容

复制构造函数很有用，但它们不是多态的。无参数方法可以帮助弥合差距，使代码保持松散耦合且易于克隆。

这是我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找到完整的代码，请随时提供您的宝贵反馈。

640?wx_fmt=gif