什么是克隆
??克隆顾名思义，就是可以将一个对象的信息克隆一份出来，生成一个新的对象。那么肯定就有人问了，都有new了，为什么还要克隆？ 因为new出来的对象，属性都是初始化的值，而clone出来的对象，能保存对象的现有状态，当我们需要临时保存一个对象的现有状态时，就可以使用clone，如果用new，还需要重新赋值，当属性较多时，会比较繁琐。并且clone是native方法，是与底层操作系统交互的，会更加的快捷。
注意：
- Person p = new Person; Person p1 = p; 这样不是对象克隆，只是想Person对象的引用复制给了p2,两个引用指向同一个对象，实际上操作的还是同一个。而克隆出来的是一个新的对象。
- 被克隆的类一定要实现Cloneable接口，该接口没有任何方法，相当于一种能力，表示实现该接口的类可以被clone。然后再重写Object类中的clone()方法
克隆的分类
??克隆分为两类，浅克隆，深克隆。
浅克隆
??浅克隆(Shallow Clone)，如果对象的属性是基本数据类型或String类型，则复制一份给克隆对象；如果是引用类型，那么就将引用对象的地址复制给克隆对象。
public class Person implements Cloneable{
private int age;
private String name;
private Address address;
//setter、getter略
@Override
public Person clone() throws CloneNotSupportedException {
return (Person) super.clone(); // 直接是调用父类的clone()方法，不做任何处理
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
", address=" + address +
'}';
}
}
public class ShallowCloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person(); // person1对象
person1.setAge(22);
person1.setName("张三");
Address address = new Address("北京"); // 引用类型
person1.setAddress(address);
Person person2 = person1.clone();
person2.getAddress().setName("南京"); // 修改person2中的Address对象的name属性
System.out.println(person1); // person1中的Address对象的name属性也被一同修改
System.out.println(person2);
System.out.println(person1 == person2); // 判断clone出来的对象和原来对象是否为同一个
}
}
结果如下：
可以看到，当对象的属性为基本类型时，会直接复制一份给新对象，如果是引用类型，则将引用类型的地址复制给新对象，改变一个引用类型引所引用对象的值，相当于两个对象一起改变。
深克隆
??深克隆(Deep Clone),如果是基本数据类型，则直接复制一份给克隆对象，如果是引用类型，则将所引用的对象也克隆复制一份给克隆对象。
package clone.bean;
public class Person implements Cloneable{
private int age;
private String name;
private Address address;
//setter、gettter略
@Override
public Person clone() throws CloneNotSupportedException {
Person person = (Person) super.clone(); // 先clone对象
person.address = (Address) address.clone(); // 深克隆，将所引用的对象也克隆一份
return person;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
", address=" + address +
'}';
}
}
public class DeepCloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person(); // person1对象
person1.setAge(22);
person1.setName("张三");
Address address = new Address("北京"); // 引用类型
person1.setAddress(address);
Person person2 = person1.clone();
person2.getAddress().setName("南京"); // 修改person2中的Address对象的name属性
System.out.println(person1); // 北京
System.out.println(person2); // 南京
System.out.println(person1 == person2);
}
}
结果如下：
深克隆成功，但是如果当对象引用类型过多，则重写方法则变得麻烦起来，那么就可以使用序列化来实现深克隆，将对象保存在流中。
public class DeepCloneTest2 {
public static void main(String[] args) throws Exception {
Person p1 = new Person();
p1.setAge(22);
p1.setName("张三");
Address address = new Address("浙江");
p1.setAddress(address);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos); // 将对象读取到流中
oos.writeObject(p1); // 写对象
ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());//将输出流中的数据转换byte数组
ObjectInputStream ois = new ObjectInputStream(bais);// 读取
Person o = (Person) ois.readObject();
System.out.println(o);
Person p2 = p1.clone();
p2.getAddress().setName("陕西");
System.out.println(p2);
ois.close();
bos.close();
}
}