假如說你想複制一個簡單變量。很簡單：
int apples = 5;
int pears = apples;
不僅僅是int類型，其它七種原始資料類型(boolean,char,byte,short,float,double.long)同樣适用于該類情況。
但是如果你複制的是一個對象，情況就有些複雜了。
假設說我是一個beginner，我會這樣寫：
class Student {
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
public class Test {
public static void main(String args[]) {
Student stu1 = new Student();
stu1.setNumber(12345);
Student stu2 = stu1;
System.out.println("學生1:" + stu1.getNumber());
System.out.println("學生2:" + stu2.getNumber());
}
}
列印結果：
學生1:12345
學生2:12345
這裡我們自定義了一個學生類，該類隻有一個number字段。
我們建立了一個學生執行個體，然後将該值指派給stu2執行個體。(Student stu2 = stu1;)
再看看列印結果，作為一個新手，拍了拍胸腹，對象複制不過如此，
難道真的是這樣嗎？
我們試着改變stu2執行個體的number字段，再列印結果看看：
stu2.setNumber(54321);
System.out.println("學生1:" + stu1.getNumber());
System.out.println("學生2:" + stu2.getNumber());
列印結果:
學生1:54321
學生2:54321
這就怪了，為什麼改變學生2的學号，學生1的學号也發生了變化呢？
原因出在(stu2 = stu1) 這一句。該語句的作用是将stu1的引用指派給stu2，
這樣，stu1和stu2指向記憶體堆中同一個對象。如圖：
那麼，怎樣才能達到複制一個對象呢？
是否記得萬類之王Object。它有11個方法，有兩個protected的方法，其中一個為clone方法。
該方法的簽名是：
protected native Object clone() throws CloneNotSupportedException;
因為每個類直接或間接的父類都是Object，是以它們都含有clone()方法，但是因為該方法是protected，是以都不能在類外進行通路。
要想對一個對象進行複制，就需要對clone方法覆寫。
一般步驟是（淺複制）：
1. 被複制的類需要實作Clonenable接口（不實作的話在調用clone方法會抛出CloneNotSupportedException異常) 該接口為标記接口(不含任何方法)
2. 覆寫clone()方法，通路修飾符設為public。方法中調用super.clone()方法得到需要的複制對象，（native為本地方法)
下面對上面那個方法進行改造：
class Student implements Cloneable{
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
}
public class Test {
public static void main(String args[]) {
Student stu1 = new Student();
stu1.setNumber(12345);
Student stu2 = (Student)stu1.clone();
System.out.println("學生1:" + stu1.getNumber());
System.out.println("學生2:" + stu2.getNumber());
stu2.setNumber(54321);
System.out.println("學生1:" + stu1.getNumber());
System.out.println("學生2:" + stu2.getNumber());
}
}
列印結果：
學生1:12345
學生2:12345
學生1:12345
學生2:54321
如果你還不相信這兩個對象不是同一個對象，那麼你可以看看這一句：
System.out.println(stu1 == stu2); // false
上面的複制被稱為淺複制(Shallow Copy)，還有一種稍微複雜的深度複制(deep copy)：
我們在學生類裡再加一個Address類。
class Address {
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
}
class Student implements Cloneable{
private int number;
private Address addr;
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
}
public class Test {
public static void main(String args[]) {
Address addr = new Address();
addr.setAdd("杭州市");
Student stu1 = new Student();
stu1.setNumber(123);
stu1.setAddr(addr);
Student stu2 = (Student)stu1.clone();
System.out.println("學生1:" + stu1.getNumber() + ",位址:" + stu1.getAddr().getAdd());
System.out.println("學生2:" + stu2.getNumber() + ",位址:" + stu2.getAddr().getAdd());
}
}
列印結果：
學生1:123,位址:杭州市
學生2:123,位址:杭州市
乍一看沒什麼問題，真的是這樣嗎？
我們在main方法中試着改變addr執行個體的位址。
addr.setAdd("西湖區");
System.out.println("學生1:" + stu1.getNumber() + ",位址:" + stu1.getAddr().getAdd());
System.out.println("學生2:" + stu2.getNumber() + ",位址:" + stu2.getAddr().getAdd());
列印結果：
學生1:123,位址:杭州市
學生2:123,位址:杭州市
學生1:123,位址:西湖區
學生2:123,位址:西湖區
這就奇怪了，怎麼兩個學生的位址都改變了？
原因是淺複制隻是複制了addr變量的引用，并沒有真正的開辟另一塊空間，将值複制後再将引用傳回給新對象。
是以，為了達到真正的複制對象，而不是純粹引用複制。我們需要将Address類可複制化，并且修改clone方法，完整代碼如下：
package abc;
class Address implements Cloneable {
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
@Override
public Object clone() {
Address addr = null;
try{
addr = (Address)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return addr;
}
}
class Student implements Cloneable{
private int number;
private Address addr;
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone(); //淺複制
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
stu.addr = (Address)addr.clone(); //深度複制
return stu;
}
}
public class Test {
public static void main(String args[]) {
Address addr = new Address();
addr.setAdd("杭州市");
Student stu1 = new Student();
stu1.setNumber(123);
stu1.setAddr(addr);
Student stu2 = (Student)stu1.clone();
System.out.println("學生1:" + stu1.getNumber() + ",位址:" + stu1.getAddr().getAdd());
System.out.println("學生2:" + stu2.getNumber() + ",位址:" + stu2.getAddr().getAdd());
addr.setAdd("西湖區");
System.out.println("學生1:" + stu1.getNumber() + ",位址:" + stu1.getAddr().getAdd());
System.out.println("學生2:" + stu2.getNumber() + ",位址:" + stu2.getAddr().getAdd());
}
}
列印結果：
學生1:123,位址:杭州市
學生2:123,位址:杭州市
學生1:123,位址:西湖區
學生2:123,位址:杭州市
這樣結果就符合我們的想法了。
最後我們可以看看API裡其中一個實作了clone方法的類：
java.util.Date:
/**
* Return a copy of this object.
*/
public Object clone() {
Date d = null;
try {
d = (Date)super.clone();
if (cdate != null) {
d.cdate = (BaseCalendar.Date) cdate.clone();
}
} catch (CloneNotSupportedException e) {} // Won't happen
return d;
}
該類其實也屬于深度複制。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)