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

￡神魔★判官ぃ 2021-10-13 02:47 162阅读 0赞

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

这是我[Java克隆][Java]系列的第三篇文章。在我之前的文章中，用详细的代码解释了[Java 克隆和克隆类型（浅克隆和深克隆）  
][Java _]和 Java 克隆：复制构造函数与克隆，我详细讨论了 Java 克隆，并解释了每个概念，如克隆是什么，  
它是如何工作的，实现克隆的必要步骤、如何使用 `Object.clone（）`、  
浅克隆和深度克隆、[如何使用序列化][Link 1]和复制构造函数实现克隆以及复制构造函数比 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  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI5MzQzMjU_size_16_color_FFFFFF_t_70]

[Java]: https://www.programmingmitra.com/search/label/Java%20Cloning?max-results=6
[Java _]: https://dzone.com/articles/shallow-and-deep-java-cloning
[Link 1]: https://www.programmingmitra.com/2019/08/how-to-deep-clone-an-object-using-java-in-memory-serialization.html
[CopyConstructorExample Java file on GitHub]: https://github.com/njnareshjoshi/exercises/blob/master/src/org/programming/mitra/exercises/CopyConstructorExample.java
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI5MzQzMjU_size_16_color_FFFFFF_t_70]: /images/20211013/ea1a2a29cc4a45518d35cae968de94ed.png