說在前面
在進入理解clone前，我們需要對“基本數據類型”和“引用數據類型”的存儲模式有一個清晰的認識。
基本數據類型，變量的內容保存的是實際的值；引用數據類型，變量的內容保存的是一個地址，該地址的指向纔是實際的值。
int baseData = 5; // 基本數據類型，baseData對應的內存保存的是具體的值：5
System.out.println(baseData); // 直接打印，返回：5
HandClass handData = new HandClass(); //引用數據類型，handData對應的內存保存的是一個16進制的內存地址，該地址纔是保存值的地方
System.out.println(handData); //直接打印，返回內存地址：HandClass@3c6f579
需要注意的是，不管是基本數據類型，還是引用數據類型，賦值(=)操作都是將變量自身內容賦值給另一個變量。唯一不同的是，我們常用操作中，基本數據類型是針對自身內容(值)進行的；而引用數據類型則是針對自身內容(地址)的指向進行的。
int data1 = 1;
int data2 = data1; // 將data1的內容(1)賦值給data2
System.out.println(data1); // 返回：1
System.out.println(data2); // 返回：1
data1 = 2; // 即使修改data1的內容，data2不受影響
System.out.println(data1); // 返回：2
System.out.println(data2); // 返回：1
System.out.println("--------------------");
HandClass handData1 = new HandClass();
handData1.ele = 1;
HandClass handData2 = handData1; // 將handData1的內容(實際內存地址)賦值給handData2
System.out.println(handData1.ele); // 返回：1
System.out.println(handData2.ele); // 返回：1
// 直接將handData1和handData2打印出來，返回相同的內容(地址)
System.out.println(handData1); // 返回：HandClass@66edc3a2
System.out.println(handData2); // 返回：HandClass@66edc3a2
handData1.ele = 2; // 修改handData1.ele的內容，handData2受影響，因爲他們的內容相同(指向了同一個內存)
System.out.println(handData1.ele); // 返回：2
System.out.println(handData2.ele); // 返回：2
handData1 = new HandClass(); // 爲handData1開闢一個新的內地址，並將該地址賦值給handData1的內容
// 直接將handData1和handData2打印出來，返回不相同的內容(地址)：handData1的內容
System.out.println(handData1); // 返回：HandClass@3ced0338
System.out.println(handData2); // 返回：HandClass@66edc3a2
handData1.ele = 3; // 此時再次修改handData1.ele的內容，handData2不受影響，因爲他們的內容已經不相同(指向了不同的內存)
System.out.println(handData1.ele); // 返回：3
System.out.println(handData2.ele); // 返回：2
總結：無論是基本數據類型，還是引用數據類型，賦值操作的實質都是內容賦值。
進入正題
先拋出結論：數組的clone方法，本質是“降維賦值”。即將數組進行降低維度後，開闢一個與之一摸一樣的內存空間，然後進行遍歷賦值。
(此文不討論數組的存儲模式，對數組存儲模式比較薄弱的朋友，請先自行了解)
一維數組：
一維數組降維後是一組變量。
int intArrayA[] = new int[]{1,2,3};
int intArrayB[] = intArrayA.clone(); // 將intArrayA的克隆賦值給intArrayB
/**
* 先對intArrayA進行降維
* 降維後，變成一組變量：intArrayA[0]、intArrayA[1]、intArrayA[2]
* 在內存中申請一組與intArrayA類型、長度相同數組: int tmp[] = new int[2];
* 將變量進行遍歷賦值：tmp[0]=intArrayA[0]、tmp[1]=intArrayA[1]、tmp[2]=intArrayA[2]
* 將數組tmp的內容(地址)返回(注：tmp是一個數組，即屬於引用類型)
* */
System.out.println(intArrayA[1]); // 返回：2
System.out.println(intArrayB[1]); // 返回：2
intArrayA[1] = 100;
System.out.println(intArrayA[1]); // 返回：100
System.out.println(intArrayB[1]); // 返回：2
/**
* 上述結論："無論是基本數據類型，還是引用數據類型，賦值操作的實質都是內容賦值。"
* intArrayA降維後，intArrayA[0]～intArrayA[2]是一組基本數據類型的變量
* 賦值的時候，將intArrayA[0]～intArrayA[2]的內容(實際的值)賦值給tmp[0]～tmp[2]
* 而後tmp[0]～tmp[2]組成的tmp的內容(一個地址)又返回給intArrayB
* 因此，intArrayB[1]和intArrayA[1]的內容是一致的，他們的內容均是"2"
* 當我們通過intArrayA[1]進行操作時，僅僅是修改自身的內容，intArrayB[1]不會受到影響
* */
System.out.println("--------------------");
HandClass handArrayA[] = new HandClass[]{new HandClass(),new HandClass(),new HandClass()};
HandClass handArrayB[] = handArrayA.clone();
/**
* 先對handArrayA進行降維
* 降維後，編程一組變量：handArrayA[0]、handArrayA[1]、handArrayA[2]
* 在內存中申請一組與handArrayA類型長度、相同數組: HandClass tmp[] = new HandClass[2];
* 將變量進行遍歷賦值：tmp[0]=handArrayA[0]、tmp[1]=handArrayA[1]、tmp[2]=handArrayA[2]
* 將數組tmp的內容(地址)返回(注：tmp是一個數組，即屬於引用類型)
* */
System.out.println(handArrayA[1].ele); // 返回：0 注：此處的0，是實例化時，系統賦與的默認初始值
System.out.println(handArrayB[1].ele); // 返回：0
handArrayA[1].ele = 100;
System.out.println(handArrayA[1]); // 返回：HandClass@7b1ddcde
System.out.println(handArrayB[1]); // 返回：HandClass@7b1ddcde
System.out.println(handArrayA[1].ele); // 返回：100
System.out.println(handArrayB[1].ele); // 返回：100
/**
* 上述結論："無論是基本數據類型，還是引用數據類型，賦值操作的實質都是內容賦值。"
* handArrayA降維後，handArrayA[0]～handArrayA[2]是一組引用類型的變量
* 賦值的時候，將handArrayA[0]～handArrayA[2]的內容(一個地址)賦值給tmp[0]～tmp[2]
* 而後tmp[0]～tmp[2]組成的tmp的內容(一個地址)又返回給handArrayB
* 因此，handArrayB[1]和handArrayA[1]的內容是一致的，他們均指向了同一個內存
* 當我們通過handArrayA[1]進行操作時(實際是修改其內容對應的實際對象的內容)，handArrayB[1](內容所指向的實際對象)也會受到影響
* */
二維及多維數組：
二維數組降維後是一組數組，數組本身就是引用類型。因此二維及多維的數組的克隆中的賦值，均屬於引用類型賦值。
int multIntArrayA[][] = new int[][]{{11,12,13},{21,22,23}};
int multIntArrayB[][] = multIntArrayA.clone();
/**
* 先對multIntArrayA進行降維
* 降維後，變成一組一維數組：multIntArrayA[0]、multIntArrayA[1]
* 在內存中申請一組與multIntArray類型、長度相同數組: int tmp[][] = new int[2][3];
* 將數組進行遍歷賦值：tmp[0]=multIntArray[0]、tmp[1]=multIntArray[1]，
* 特別着重說明的事，這裏是數組(引用類型)的賦值，而並非數組元素(int類型)的賦值
* 將數組tmp的內容(地址)返回(注：tmp是一個數組，即屬於引用類型)
* */
System.out.println(multIntArrayA[0][1]); // 返回：12
System.out.println(multIntArrayB[0][1]); // 返回：12
multIntArrayA[0][1] = 66;
System.out.println(multIntArrayA[0][1]); // 返回：66
System.out.println(multIntArrayB[0][1]); // 返回：66
/**
* 我們注意到，multIntArrayB已經受到了multIntArrayA的影響
* 因爲clone只會降低一個維度後進行遍歷賦值，即：將multIntArrayA[0]的內容(一個地址)賦值給multIntArrayB[0]
* 當我們操作multIntArrayA[0][1]時，實際是操作了multIntArrayA[0]的內容所指向的實際的數組第一個元素的值
* multIntArrayB[0]保存的內容與multIntArrayA[0]一致，同樣指向的是同一個數組
* 因此multIntArrayB[0][1]全等於multIntArrayA[0][1]（變量自身一模一樣）
* 再次也可以明確，clone的降維，只會降低一個維度
* 若要數組元素也克隆，則需要再次clone，以將維度降低至數組元素
* */
multIntArrayB[0] = multIntArrayA[0].clone();
multIntArrayA[0][1] = 77;
System.out.println(multIntArrayA[0][1]); // 返回：77
System.out.println(multIntArrayB[0][1]); // 返回：66
/**
* 可以看出，當我們對multIntArrayA[0]進行克隆
* multIntArrayA[0]降維後，就是一組基本數據類型的變量(int)
* 因此multIntArrayB[0]中的各個元素(基本數據類型)全等於multIntArrayA[0]中的元素，而是一個"克隆品"
* 當我們修改multIntArrayA[0][1]後，multIntArrayB[0][1]並不會隨之變化
* 爲了加強驗證這一現象，我們將"基本數據類型"改爲"引用數據類型"
* 如果我們的猜想沒錯，進行上述操作後，最後輸出的應該也一樣是"77"，而不是"66"
* */
System.out.println("--------------------");
HandClass multHandArrayA[][] = new HandClass[][]{{new HandClass(),new HandClass(),new HandClass()},{new HandClass(),new HandClass(),new HandClass()}};
HandClass multHandArrayB[][] = multHandArrayA.clone();
System.out.println(multHandArrayA[0][1]); // 返回：HandClass@7b1ddcde
System.out.println(multHandArrayB[0][1]); // 返回：HandClass@7b1ddcde
multHandArrayA[0][1].ele = 66;
System.out.println(multHandArrayA[0][1].ele); // 返回：66
System.out.println(multHandArrayB[0][1].ele); // 返回：66
multHandArrayB[0] = multHandArrayA[0].clone();
multHandArrayA[0][1].ele = 77;
System.out.println(multHandArrayA[0][1].ele); // 返回：77
System.out.println(multHandArrayB[0][1].ele); // 返回：77
/**
* 如果只是進行multHandArrayA的clone，那麼"基本數據類型"和"引用數據類型"是一樣的
* 但是，當我們再次對multHandArrayA[0]進行克隆後，效果就不一樣了
* 由於multHandArrayA[0]降維後，是一組引用數據類型的數組
* 因此multHandArrayB[0]中的各個元素(引用數據類型)的內容與multIntArrayA[0]中對應的元素一致，即指向同一個地址
* 當我們修改multHandArrayA[0][1]的值(實際修改的是它內容指向的地址對應的實際對象)，multHandArrayB[0][1]也會隨之變化
* */
總結：Java中，數組的克隆(clone)只會降一次維，而後開闢一塊新的空間，遍歷所有元素進行賦值操作。
值得一提
一維數組，由於降維後就是數組的基本元素，因此看起來就像是進行了“深拷貝”，實際是錯誤的。只有基本數據類型的一維數組的clone纔是“深拷貝”的效果；引用數據類型的一維數組clone，還需要額外進行“對象拷貝”；
二維或者多維數組可以通過遞歸方式，進行更低維度（直至降低至一維）的clone，從而達到“深拷貝”的目的。