浅拷贝是只拷贝基本类型和引用，不拷贝引用指向的对象。
深拷贝是不仅拷贝基本类型引用，而且拷贝引用所指向的对象。
一、浅拷贝、深拷贝
浅拷贝会对对象中的成员变量进行拷贝：如果是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ；
深拷贝，除了基本类型外，引用类型所引用的对象也会进行拷贝；（引用的对象只要求浅拷贝即可；若要深层拷贝，一般可利用序列化和反序列化来实现，也可手动实现各级引用对象的深层拷贝；）
假如说你想复制一个简单变量。很简单：
1. int apples = 5;
2. int pears = apples;
不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。
但是如果你复制的是一个对象，情况就有些复杂了。
假设说我是一个beginner，我会这样写：
1. class Student {
2. private int number;
3.
4. public int getNumber() {
5. return number;
6. }
7.
8. public void setNumber(int number) {
9. this.number = number;
10. }
11.
12. }
13. public class Test {
14.
15. public static void main(String args[]) {
16.
17. new Student();
18. 12345);
19. Student stu2 = stu1;
20.
21. "学生1:" + stu1.getNumber());
22. "学生2:" + stu2.getNumber());
23. }
24. }
打印结果：
1. 学生1:12345
2. 学生2:12345
这里我们自定义了一个学生类，该类只有一个number字段。
我们新建了一个学生实例，然后将该值赋值给stu2实例。(Student stu2 = stu1;)
再看看打印结果，作为一个新手，拍了拍胸腹，对象复制不过如此，
难道真的是这样吗？
我们试着改变stu2实例的number字段，再打印结果看看：
1. stu2.setNumber(54321);
2.
3. System.out.println("学生1:" + stu1.getNumber());
4. System.out.println("学生2:" + stu2.getNumber());
打印结果:
1. 学生1:54321
2. 学生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为本地方法)
下面对上面那个方法进行改造：
1. class Student implements Cloneable{
2. private int number;
3.
4. public int getNumber() {
5. return number;
6. }
7.
8. public void setNumber(int number) {
9. this.number = number;
10. }
11.
12. @Override
13. public Object clone() {
14. null;
15. try{
16. super.clone();
17. catch(CloneNotSupportedException e) {
18. e.printStackTrace();
19. }
20. return stu;
21. }
22. }
23. public class Test {
24.
25. public static void main(String args[]) {
26.
27. new Student();
28. 12345);
29. Student stu2 = (Student)stu1.clone();
30.
31. "学生1:" + stu1.getNumber());
32. "学生2:" + stu2.getNumber());
33.
34. 54321);
35.
36. "学生1:" + stu1.getNumber());
37. "学生2:" + stu2.getNumber());
38. }
39. }
打印结果：
1. 学生1:12345
2. 学生2:12345
3. 学生1:12345
4. 学生2:54321
如果你还不相信这两个对象不是同一个对象，那么你可以看看这一句：
1. System.out.println(stu1 == stu2); // false
上面的复制被称为浅复制(Shallow Copy)，还有一种稍微复杂的深度复制(deep copy)：
我们在学生类里再加一个Address类。
1. class Address {
2. private String add;
3.
4. public String getAdd() {
5. return add;
6. }
7.
8. public void setAdd(String add) {
9. this.add = add;
10. }
11.
12. }
13.
14. class Student implements Cloneable{
15. private int number;
16.
17. private Address addr;
18.
19. public Address getAddr() {
20. return addr;
21. }
22.
23. public void setAddr(Address addr) {
24. this.addr = addr;
25. }
26.
27. public int getNumber() {
28. return number;
29. }
30.
31. public void setNumber(int number) {
32. this.number = number;
33. }
34.
35. @Override
36. public Object clone() {
37. null;
38. try{
39. super.clone();
40. catch(CloneNotSupportedException e) {
41. e.printStackTrace();
42. }
43. return stu;
44. }
45. }
46. public class Test {
47.
48. public static void main(String args[]) {
49.
50. new Address();
51. "杭州市");
52. new Student();
53. 123);
54. stu1.setAddr(addr);
55.
56. Student stu2 = (Student)stu1.clone();
57.
58. "学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
59. "学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
60. }
61. }
打印结果：
1. 学生1:123,地址:杭州市
2. 学生2:123,地址:杭州市
乍一看没什么问题，真的是这样吗？
我们在main方法中试着改变addr实例的地址。
1. addr.setAdd("西湖区");
2.
3. System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
4. System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
打印结果：
1. 学生1:123,地址:杭州市
2. 学生2:123,地址:杭州市
3. 学生1:123,地址:西湖区
4. 学生2:123,地址:西湖区
这就奇怪了，怎么两个学生的地址都改变了？
原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。
所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：
1. package abc;
2.
3. class Address implements Cloneable {
4. private String add;
5.
6. public String getAdd() {
7. return add;
8. }
9.
10. public void setAdd(String add) {
11. this.add = add;
12. }
13.
14. @Override
15. public Object clone() {
16. null;
17. try{
18. super.clone();
19. catch(CloneNotSupportedException e) {
20. e.printStackTrace();
21. }
22. return addr;
23. }
24. }
25.
26. class Student implements Cloneable{
27. private int number;
28.
29. private Address addr;
30.
31. public Address getAddr() {
32. return addr;
33. }
34.
35. public void setAddr(Address addr) {
36. this.addr = addr;
37. }
38.
39. public int getNumber() {
40. return number;
41. }
42.
43. public void setNumber(int number) {
44. this.number = number;
45. }
46.
47. @Override
48. public Object clone() {
49. null;
50. try{
51. super.clone(); //浅复制
52. catch(CloneNotSupportedException e) {
53. e.printStackTrace();
54. }
55. //深度复制
56. return stu;
57. }
58. }
59. public class Test {
60.
61. public static void main(String args[]) {
62.
63. new Address();
64. "杭州市");
65. new Student();
66. 123);
67. stu1.setAddr(addr);
68.
69. Student stu2 = (Student)stu1.clone();
70.
71. "学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
72. "学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
73.
74. "西湖区");
75.
76. "学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
77. "学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
78. }
79. }
打印结果：
1. 学生1:123,地址:杭州市
2. 学生2:123,地址:杭州市
3. 学生1:123,地址:西湖区
4. 学生2:123,地址:杭州市
这样结果就符合我们的想法了。
最后我们可以看看API里其中一个实现了clone方法的类：
java.util.Date:
1. /**
2. * Return a copy of this object.
3. */
4. public Object clone() {
5. null;
6. try {
7. super.clone();
8. if (cdate != null) {
9. d.cdate = (BaseCalendar.Date) cdate.clone();
10. }
11. catch (CloneNotSupportedException e) {} // Won't happen
12. return d;
13. }
该类其实也属于深度复制。
推荐使用序列化实现对象的拷贝
原文链接：
上面建议说了对象的浅拷贝问题，实现Cloneable接口就具备了拷贝能力，那我们来思考这样一个问题：如果一个项目中有大量的对象是通过拷贝生成的，那我们该如何处理？每个类都写一个clone方法，并且还要深拷贝？想想看这是何等巨大的工作量呀，是否有更好的方法呢？
其实，可以通过序列化方式来处理，在内存中通过字节流的拷贝来实现，也就是把母对象写到一个字节流中，再从字节流中将其读出来，这样就可以重建一个新对象了，该新对象与母对象之间不存在引用共享的问题，也就相当于深拷贝了一个新对象，代码如下：
1. public class CloneUtils {
2. // 拷贝一个对象
3. @SuppressWarnings("unchecked")
4. public static <T extends Serializable> T clone(T obj) {
5. // 拷贝产生的对象
6. T clonedObj = null;
7. try {
8. // 读取对象字节数据
9. ByteArrayOutputStream baos = new ByteArrayOutputStream();
10. ObjectOutputStream oos = new ObjectOutputStream(baos);
11. oos.writeObject(obj);
12. oos.close();
13. // 分配内存空间，写入原始对象，生成新对象
14. ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
15. ObjectInputStream ois = new ObjectInputStream(bais);
16. //返回新对象，并做类型转换
17. clonedObj = (T)ois.readObject();
18. ois.close();
19. } catch (Exception e) {
20. e.printStackTrace();
21. }
22. return clonedObj;
23. }
24. }此工具类要求被拷贝的对象必须实现Serializable接口，否则是没办法拷贝的（当然，使用反射那是另外一种技巧），上一个建议中的例子只要稍微修改一下即可实现深拷贝，代码如下：
1. class Person implements Serializable{
2. private static final long serialVersionUID = 1611293231L;
3. /*删除掉clone方法，其他代码保持不变*/
4. }上去的，然后我们就可以通过CloneUtils工具进行对象的深拷贝了。用此方法进行对象拷贝时需要注意两点：
（1）对象的内部属性都是可序列化的
如果有内部属性不可序列化，则会抛出序列化异常，这会让调试者很纳闷：生成一个对象怎么会出现序列化异常呢？从这一点来考虑，也需要把CloneUtils工具的异常进行细化处理。
（2）注意方法和属性的特殊修饰符
比如final、static变量的序列化问题会被引入到对象拷贝中来（参考第1章），这点需要特别注意，同时transient变量（瞬态变量，不进行序列化的变量）也会影响到拷贝的效果。
当然，采用序列化方式拷贝时还有一个更简单的办法，即使用Apache下的commons工具包中的SerializationUtils类，直接使用更加简洁方便。
注：a. clone 和 序列化都不会调用对象的构造方法；
b. 序列化 不会对 static 和 transient修饰的变量序列化；
c. 序列化的对象中引用类型变量的对象 也要实现Serializable，不要在序列化时会抛出 NotSerializableException；
