java中的clone方法

java语言中取消了指针的概念，但这只是在java语言中没有明确提供指针的概念和语法，而实质上每个new对象返回的都是一个指针的引用，很多开发人员在编程中往往忽略了对象和引用的区别。

如下代码：

package com.dushan.test;

public class Object {

    private String str = "aaa";

    public void setStr(String str) {
        this.str = str;
    }

    public String toString() {
        return str;
    }

}

package com.dushan.test;

public class TestRef {

    private int a = 0;
    private Object object = new Object();

    public Object getObject() {
        return object;
    }

    public int getA() {
        return a;
    }

    public static void ChangeObjectValue(Object object) {
        object.setStr("change value to BBB");

    }

    public static void changeIntValue(int b) {
        b = 1;

    }

    public static void main(String[] args) {
        TestRef testRef = new TestRef();
        System.out.println("============引用类型============");
        System.out.println("调用changeOnject()之前：" + testRef.getObject());
        ChangeObjectValue(testRef.getObject());
        System.out.println("调用changeOnject()之后：" + testRef.getObject());

        System.out.println("============基本数据类型============");
        System.out.println("调用changeInt()之前：" + testRef.getA());
        changeIntValue(testRef.getA());
        System.out.println("调用changeInt()之后：" + testRef.getA());
    }
}

运行结果为

引用类型
调用changeOnject()之前：aaa
调用changeOnject()之后：change value to BBB
基本数据类型
调用changeInt()之前：0
调用changeInt()之后：0

上面两个看似类似的方法却有着不同的运行结果，主要原因是java在处理基本数据类型是（int,char,double等）时，都是采用按值传递（传递的是输入参数的复制）的方式执行，除此之外的其他类型都是按引用传递（传递的是一个对象的引用）的方式执行。对象除了在函数调用时是引用传递，再使用"="赋值时才用的也是按引用传递。代码如下：

package com.dushan.test;

public class TestRef {

    private int a = 0;

    public int getA() {
        return a;
    }

    public void setA(int b) {
        this.a = b;
    }

    public void changeIntValue() {
        this.a = 1;
    }

    public static void main(String[] args) {
        TestRef testRef = new TestRef();
        TestRef c = testRef;
        c.changeIntValue();
        System.out.println("testRef = " + testRef.getA());
        System.out.println("c  = " + c.getA());
    }
}

运行结果如下：

testRef = 1
c = 1

在实际编程过程中，经常遇到从某个已有的对象A创建出另外一个与A具有相同状态对象B，并对B的修改不会影响到A的情况。

例如：设计模式中的原型模式，就需要clone一个对象实例。
在java语言中，仅仅通过简单的赋值操作是无法达到这个目的的，而java提供了一个简单有效的clone()方法来满足这个需求。

java中所有的类，都默认继承自Object类，而Object类提供了一个clone()方法。这个方法的作用是返回一个Object对象的复制，这个复制函数返回的是一个新的对象而不是一个引用。

如何使用clone()方法？
1.实现clone的类需要继承Cloneable接口。Cloneable接口实质上是一个标识接口，没有任何接口方法。
2.在类中重写Object类的clone()方法。
3.在clone()方法中调用super.clone()。无论clone类的继承结构是什么。super.clone()都会直接或者间接调用java.lang.Object类的clone()方法。
4.把浅复制的引用指向原型对象新的克隆体。

package com.dushan.test;

public class Object implements Cloneable {

    private int a = 0;

    public int getA() {
        return a;
    }

    public void setA(int b) {
        this.a = b;
    }

    public void changeIntValue() {
        this.a = 1;
    }

    public Object clone() {
        Object o = null;
        try {
            o = (Object) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

}

package com.dushan.test;

public class TestRef{

    public static void main(String[] args) {
        Object a = new Object();
        Object b = a.clone();
        b.changeIntValue();
        System.out.println("a = " + a.getA());
        System.out.println("b  = " + b.getA());
    }
}

运行结果如下：

a = 0
b = 1

java语言在重载clone()方法时存在浅复制和深复制之分，当类中只有一些基本数据类型时，采用上述方法即可，但是当类中包含一些对象的时候，就需要使用深复制了。实现方法是在对对象调用clone()方法完成复制之后，接着对对象中的非基本类型也调用clone()方法完成深复制。

代码如下：

package com.dushan.test;

import java.util.Date;

public class Object implements Cloneable {

    private int a = 0;
    private Date birth = new Date();

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public int getA() {
        return a;
    }

    public void setA(int b) {
        this.a = b;
    }

    public void changeDate(){
        this.birth.setMonth(4);
    }
    public void changeIntValue() {
        this.a = 1;
    }

    public Object clone() {
        Object o = null;
        try {
            o = (Object) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //实现深复制
        o.birth = (Date) this.getBirth().clone();
        return o;
    }

}

package com.dushan.test;

public class TestRef{

    public static void main(String[] args) {
        Object a = new Object();
        Object b = a.clone();
        b.changeDate();
        System.out.println("a = " + a.getBirth());
        System.out.println("b  = " + b.getBirth());
    }
}

运行结果如下：

a = Mon Aug 05 16:11:32 CST 2019
b = Sun May 05 16:11:32 CST 2019

那么在编程时使用哪种复制方式？
首先检查类有无基本类型（即对象）的数据成员，如果没有，则返回super.clone()方法即可。如有，确保类中的所有非基本类型的成员变量都实现了深复制。

Object o = new Object();
对每一个对象attr 都执行以下语句。
o.attr = this.getAttr().clone();
最后返回o

注意：
clone()方法的保护机制在Object中的clone() 是被声明为protected.以User类为例，通过声明为protected，就可以保证只有User类里面才能克隆User对象。

深复制和浅复制有什么区别？

浅复制： 被复制的对象所有变量都含有与原来对象相同的值。而所有对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅赋值所考虑的对象，而不复制他所应用的对象。

深复制：被复制对象的所有变量都含有和原来对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制的新对象，而不再是原有的那些被引用的对象。换言之：深复制把复制对象所引用的对象都复制了。
class demo{
public int i;
public String s;
}
假如定义一个类：

如下图：