首先來看看淺拷貝和深拷貝的定義：

      淺拷貝：使用一個已知例項對新建立例項的成員變數逐個賦值，這個方式被稱為淺拷貝。

      深拷貝：當一個類的拷貝構造方法，不僅要複製物件的所有非引用成員變數值，還要為引用型別的成員變數建立新的例項，並且初始化為形式引數例項值。這個方式稱為深拷貝

      也就是說淺拷貝只複製一個物件，傳遞引用，不能複製例項。而深拷貝對物件內部的引用均複製，它是建立一個新的例項，並且複製例項。

      對於淺拷貝當物件的成員變數是基本資料型別時，兩個物件的成員變數已有儲存空間，賦值運算傳遞值，所以淺拷貝能夠複製例項。但是當物件的成員變數是引用資料型別時，就不能實現物件的複製了。

      存在一個物件Person，程式碼如下：

public class Person {
    private String name;
    private String sex;
    private int age;
    
    public Person(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    
    public Person(Person p){                   //
 
拷貝構造方法，複製物件
        this.name = p.name;
        this.sex = p.sex;
        this.age = p.age;
    }
}

      上面的物件Person有三個成員變數。name、sex、age。兩個構造方法。第二個的引數為該物件，它稱為拷貝構造方法，它將建立的新物件初始化為形式引數的例項值，通過它可以實現物件複製功能。

      又有一個物件Asian,如下：

public class Asian {
    private String skin;
    Person person;
    
    
 
public Asian(String skin,Person person){
        this.skin = skin;
        this.person = person;                    //引用賦值
    }

    public Asian(Asian asian){                 //拷貝構造方法，複製物件
        this(asian.skin,asian.person);           
    }
}

      上面物件也存在著兩個成員變數，skin 和Person物件

      對於person物件有如下：

Person p1 = new Person("李四","mam",23);

 Person p2 = new Person(P1);

      當呼叫上面的語句時。P2物件將會對P1進行復制。執行情況如下如下圖：

      對於Asian物件有：

Asian a1 = new Asian("yellow",new Person("李四","mam",23));
Asian a2 = new Asian(a1);

      New Asian(a1)執行Asian類的拷貝構造方法，由於物件賦值是引用賦值。使得a1和a2引用同一個物件

      如下圖：

      當a1執行某條可以改變該值的語句時，那麼a1將會通過這個語句也可以改變a2物件的成員變數

      如果執行以下語句：a2.name = new Person(a1.name)

      這時將會建立一個新的Person物件

      如下圖：

實現程式碼：

package com.pojo;

import java.io.Serializable;

public class A implements Serializable{

	private int a;

	public int getA() {
		return a;
	}

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

	public A(int a) {
		this.a = a;
	}

}

package com.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import com.pojo.A;

public class Test implements Cloneable,Serializable {

	int b = 10;
	private A a = new A(10);

	public Object deepclone() {
		ObjectOutputStream os = null;
		ObjectInputStream ois = null;
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		Object target = null;
		try {
			os = new ObjectOutputStream(bos);
			os.writeObject(this);

			ByteArrayInputStream bis = new ByteArrayInputStream(
					bos.toByteArray());
			ois = new ObjectInputStream(bis);
			target = ois.readObject();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return target;

	}

	public static void main(String[] args) throws CloneNotSupportedException {
		Test test = new Test();
		Test test2 = (Test) test.clone();

		test.b = 20;
		System.out.println(test2.b);

		System.out.println(test.a.getA());
		test2.a.setA(20);
		System.out.println(test.a.getA());

		Test test3 = (Test) test.deepclone();
		test.a.setA(30);
		System.out.println(test3.a.getA());

	}
}

可以用發現淺度克隆和深度克隆的結果是不同的，但是值得注意的是，對於基本資料型別和String型別而言，沒有深度和淺度之說，他們克隆的物件都是不同的物件。