深浅克隆

克隆之所以有深浅之分，是因为在Java、python中，数据类型有基本数据类型、引用数据类型

先说一下Java中的

java中的基本数据类型存储在栈中，引用数据类型存储在堆里

• Java中的克隆需要 implement Cloneable这个标记接口
• 并实现clone接口。（因为clone接口是 protected 的，Object包外、非Object子类无法使用。java访问控制）

标记接口里并没有成员，其作用只是为这个类打上一个标记。就像公务员招考，对于某个工作岗位A，你行我也行，但是这个招考要求必须是“ 计算机科学与技术软件工程方向 ”，而你的学位证不是这个，那它就不让你参加考试。

浅克隆，只要求被克隆的类implement Cloneable，并重写clone方法

目录结构：
C继承A，T是main类

A：

public class A{
	public String sa;
	public A() {
		
	}
	public A(String s) {
		this.sa = s;
	}
}

C:

// Class C 中既有“基本数据类型”，也有“引用数据类型”
public class C implements Cloneable {
	// 基本数据类型
	public String name;
	// 引用数据类型
	public A a;

	public C(String name, A a) {
		this.name = name;
		this.a = a;
	}

	@Override
	protected C clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		C c = (C)super.clone();
		return c;
	}

}

T：

// 浅拷贝，引用数据类型未被clone
public class T {
	public static void main(String[] args) throws CloneNotSupportedException {
		C c1 = new C("this is C", a1);
		C c2 = (C)c1.clone();
		System.out.println(c2.a.sa); // this is a1
		c1.a.sa = "this is c1's A";
		System.out.println(c2.a.sa); // this is c1's A，c1中引用类型被修改后，c2中的引用类新型也被修改了
	}
}

深克隆，被克隆的类、以及该类引用的类都要implement Cloneable，并都重写 clone方法

A：

public class A implements Cloneable{
	public String sa;
	public A() {
		
	}
	public A(String s) {
		this.sa = s;
	}
	
	@Override
	public A clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return (A)super.clone();
	}

}

C:

// Class C 中既有“基本数据类型”，也有“引用数据类型”
public class C implements Cloneable {
	// 基本数据类型
	public String name;
	// 引用数据类型
	public A a;

	public C(String name, A a) {
		this.name = name;
		this.a = a;
	}

	@Override
	protected C clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		C c = (C)super.clone();
		c.a = a.clone();
		return c;
	}

}

T：

// 深拷贝，引用数据类型被clone
public class T {
	public static void main(String[] args) throws CloneNotSupportedException {
		C c1 = new C("this is C", a1);
		C c2 = (C)c1.clone();
		System.out.println(c2.a.sa); // this is a1
		c1.a.sa = "this is c1's A";
		System.out.println(c2.a.sa); // this is a1，深克隆后，c1修改自己的引用类，c2未发生改变
	}
}

通过序列化来实现深克隆

A：

import java.io.Serializable;

// Class A 中只有“基本数据类型”，所以在浅克隆时不会出现问题
public class A implements Serializable{
	public String sa;
	public A() {
		
	}
	public A(String s) {
		this.sa = s;
	}
}

C:

import java.io.Serializable;

// Class C 中既有“基本数据类型”，也有“引用数据类型”
public class C implements Serializable {
	// 基本数据类型
	public String name;
	// 引用数据类型
	public A a;

	public C(String name, A a) {
		this.name = name;
		this.a = a;
	}

}

T：

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

public class T {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		A a1 = new A("this is A");
		C c1 = new C("this is C", a1);
		C c2 = (C) deepClone(c1);
		System.out.println(c2.a.sa);
		c1.a.sa = "this is c1's A";
		System.out.println(c2.a.sa);
	}

	public static Object deepClone(Object obj) throws IOException, ClassNotFoundException {
		// 将obj写出去（写到内存里）
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		ObjectOutputStream oout = new ObjectOutputStream(bout);
		oout.writeObject(obj);
		// 再将内存里的读回来
		ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
		ObjectInputStream oin = new ObjectInputStream(bin);
		return oin.readObject();
	}

}

python中的

基本数据类型、引用数据类型的原理是一样的，但实现方法当然是不一样的了

import copy

# 浅克隆1，只有基本数据类型
s1 = [i for i in range(3, 8)]
s2 = s1.copy()
print(id(s1) == id(s2)) # False
s1[0] = 484
print(s2) # [3, 4, 5, 6, 7] 未发生改变

s1.append(['hello', " ", "world"])
# 浅克隆2，包含引用数据类型
s3 = copy.copy(s1)
print(id(s1) == id(s3)) # False
s1[5][0] = 'hi'
print(s3) # [484, 4, 5, 6, 7, ['hi', ' ', 'world']] 发生改变

# 深克隆
s4 = copy.deepcopy(s1)
print(id(s1) == id(s4))
s1[5][0] = 'hello'
print(s4) # [484, 4, 5, 6, 7, ['hi', ' ', 'world']] 未发生改变