假克隆，浅克隆，深克隆

快来打我* 2023-06-16 08:11 10阅读 0赞

**假克隆**：

我觉得就是一个引用操作，不过注意引用类型的参数在源对象被改变后，假克隆的对象也会被改变

![20191125155039647.png][]

**浅克隆**：

这个需要注意的是 浅克隆 对基本数据类型和不可变类对象的是可以进行的，但是是可变的引用类型需要使用深克隆

首先类需要实现Cloneable接口

![20191125155706583.png][]

并且要实现clone方法 需要重写父类的clone方法

![20191125155832884.png][]

因为父类的protocol类型修饰 如果要在其他包使用 需要改成public类型

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70][]

整个浅克隆的类代码如下：

package method;
    
    import java.util.Objects;
    
    
    public class OverrideHash implements Cloneable {
    
        private int id;
        private String name;
        private int age;
        private int gender;
    
        public OverrideHash() {
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public int getGender() {
            return gender;
        }
    
        public void setGender(int gender) {
            this.gender = gender;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            OverrideHash that = (OverrideHash) o;
            return id == that.id &&
                    age == that.age &&
                    gender == that.gender &&
                    Objects.equals(name, that.name);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(id, name, age, gender);
        }
    
        @Override
        public OverrideHash clone() {
            OverrideHash overrideHash = null;
    
            try {
                overrideHash = (OverrideHash) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
    
            return overrideHash;
        }
    
        @Override
        public String toString() {
            return "OverrideHash{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", gender=" + gender +
                    '}';
        }
    }

这里可以和假克隆一起做个栗子 比较下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 1][]

最后得到结论是：

![2019112516024736.png][]

很明显看到在两个克隆对象后面修改了原对象的一个参数，假克隆的对应参数被修改了，而浅克隆的没有。

**深克隆**:

深克隆的条件时如果需要克隆的对象的参数中包括了可变引用类型，则在克隆时使用深克隆

直接举个栗子：

一个只有基本数据类型和不可变的引用类型  address类

public class Address implements Cloneable {
    
        private int id;
        private String contry;
        private String province;
        private String city;
        private String street;
    
        public Address(int id, String contry, String province, String city, String street) {
            this.id = id;
            this.contry = contry;
            this.province = province;
            this.city = city;
            this.street = street;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getContry() {
            return contry;
        }
    
        public void setContry(String contry) {
            this.contry = contry;
        }
    
        public String getProvince() {
            return province;
        }
    
        public void setProvince(String province) {
            this.province = province;
        }
    
        public String getCity() {
            return city;
        }
    
        public void setCity(String city) {
            this.city = city;
        }
    
        public String getStreet() {
            return street;
        }
    
        public void setStreet(String street) {
            this.street = street;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Address address = (Address) o;
            return id == address.id &&
                    Objects.equals(contry, address.contry) &&
                    Objects.equals(province, address.province) &&
                    Objects.equals(city, address.city) &&
                    Objects.equals(street, address.street);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(id, contry, province, city, street);
        }
    
        @Override
        public Object clone() {
            Address address = null;
            try {
                address = (Address) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return address;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "id=" + id +
                    ", contry='" + contry + '\'' +
                    ", province='" + province + '\'' +
                    ", city='" + city + '\'' +
                    ", street='" + street + '\'' +
                    '}';
        }
    }

再来个user对象，用于深克隆

public class User implements Cloneable {
    
        private int id;
    
        private String name;
    
        private int age;
    
        private int gender;
    
        private Address address;
    
        public User(int id, String name, int age, int gender, Address address) {
            this.id = id;
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.address = address;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public int getGender() {
            return gender;
        }
    
        public void setGender(int gender) {
            this.gender = gender;
        }
    
        public Address getAddress() {
            return address;
        }
    
        public void setAddress(Address address) {
            this.address = address;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            User user = (User) o;
            return id == user.id &&
                    age == user.age &&
                    gender == user.gender &&
                    Objects.equals(name, user.name) &&
                    Objects.equals(address, user.address);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(id, name, age, gender, address);
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", gender=" + gender +
                    ", address=" + address.toString() +
                    '}';
        }
    
        @Override
        public Object clone() {
            User user = null;
            try {
                user = (User) super.clone();
                user.address = (Address) address.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return user;
        }
    }

注意得到的是 user在克隆的时候将Address对象单独进行了一次克隆。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 2][]

这样才能保证address对象的参数克隆过去

举个栗子尝试下：

![20191125163446624.png][]

得到的结果:

![20191125163502473.png][]

引用对象也克隆成功了

**如果 不将Address对象克隆会怎样呢？**

**地址信息克隆失败，直接引用过去了。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 3][]

还有一个问题，使用序列化也可以实现"克隆",就是将 克隆的类序列化 ，然后将其保存到硬盘，再从硬盘中读取出来存到一个新的对象当中去。

不过效率低于克隆

[20191125155039647.png]: https://img-blog.csdnimg.cn/20191125155039647.png
[20191125155706583.png]: https://img-blog.csdnimg.cn/20191125155706583.png
[20191125155832884.png]: https://img-blog.csdnimg.cn/20191125155832884.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191125155741505.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2019112516012741.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx,size_16,color_FFFFFF,t_70
[2019112516024736.png]: https://img-blog.csdnimg.cn/2019112516024736.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191125162502472.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx,size_16,color_FFFFFF,t_70
[20191125163446624.png]: https://img-blog.csdnimg.cn/20191125163446624.png
[20191125163502473.png]: https://img-blog.csdnimg.cn/20191125163502473.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191125163625884.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx,size_16,color_FFFFFF,t_70