浅拷贝和深拷贝

一：定义

浅拷贝：浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

深拷⻉ ：深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

二：为什么需要克隆

克隆的对象可能包含一些已经修改过的属性,保留着你想克隆对象的值，而new出来的对象的属性全是一个新的对象，对应的属性没有值，所以我们还要重新给这个对象赋值。即当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，Object类里面的clone是一个native方法，执行速度快，在底层实现的（C++）。
protected native Object clone() throws CloneNotSupportedException;

三：如何实现克隆

分三步：

1. 对象的类实现Cloneable接口；
2. 覆盖Object类的clone()方法 （覆盖clone()方法，访问修饰符设为public，默认是protected）；
3. 在clone()方法中调用super.clone()；

package com.zhang.prototype.demo01;
import java.util.Date;

/*
*  1、实现一个接口  Cloneable
* 2、重写一个方法    clone()
*
* */

// Video ： 视频的原型
public class Video implements Cloneable{  // 无良up主，克隆别人的视频！

    private String name;
    private Date createTime;

    public Video() {
    }

    public Video(String name, Date createTime) {
        this.name = name;
        this.createTime = createTime;
    }

    public String getName() {
        return name;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "Video{" +
                "name='" + name + '\'' +
                ", createTime=" + createTime +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

4、理解浅克隆和深克隆

浅克隆：

package com.zhang.prototype.demo01;


import java.util.Date;

/*
*   客户端 ： 克隆
* */
public class Blibili {

    public static void main(String[] args) throws CloneNotSupportedException {
        // 原型对象 v1
        Date date = new Date();
        Video v1 = new Video("狂神说java", date);

        // Video v2 = new Video("狂神说java", date);  // 之前的方式可以通过再new一个对象来得到v2,但是麻烦
        // v2 克隆 v1
        Video v2 = (Video) v1.clone();

        System.out.println("v1===>"+v1);
        System.out.println("v1=>hash："+v1.hashCode());
        System.out.println("v2===>"+v2);
        System.out.println("v2=>hash："+v2.hashCode());
        
        System.out.println("========================");
        date.setTime(2345671);
        System.out.println("v1===>"+v1);
        System.out.println("v2===>"+v2);
    }
}

结果：
分析：

1. 从v1和v2的值（包括基本类型和引用类型）是一模一样的，说明完成了拷贝
2. v1和v2的hashcode不同，说明在克隆的过程中，是创建了一个新的对象。
3. 更改了一次v1的date的值，v1和v2的createTime同时发生了改变，说明在浅拷贝的过程中，v1和v2只想了同一个对象。对于引用类型，拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。而对于基本类型，拷贝的就是基本类型的值。

示意图如下：

深克隆：
深克隆的实现方法有

1. 重写clone()方法，已完成对引用类型的拷贝。
2. 序列化
3. 反序列化

但是序列化和反序列化设计IO的操作，效率较低，所以这里我示范一下重写clone()方法的方法。

重写clone()方法

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();
        Video v = (Video) obj;

        // 实现深克隆，通过重写clone()方法，此外还有序列化和反序列化的方法，但是这两种方法需要和IO打交道，效率会降低
        v.createTime = (Date)this.createTime.clone();      // 将这个对象的属性也进行克隆~
        return obj;
    }

结果：

分析：
可以看到修改了v1的date后，只有v1的createTime发生了改变，v2的没有发生变化，说明也完成了对引用类型的拷贝，实现了深拷贝。

示意图如下：