java 反射 深拷贝_Java深拷贝和浅拷贝（深克隆和浅克隆）

Java中创建对象有两种方式：

通过new操作符创建一个对象

通过clone方法来复制一个对象

使用反序列化来创建一个对象

通过使用Class类的newInstance方法来创建一个对象

使用Constructor类的newInstance方法来创建一个对象

第一种方法，通过new操作符来创建一个对象，分配内存，调用构造函数来填充各个域，这是我们最熟悉的；第二种clone也是分配内存，分配的内存和被clone对象相同，然后再使用原对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部；第三种序列化和反序列化一个对象，jvm会给我们创建一个单独的对象。在反序列化时，jvm创建对象并不会调用任何构造函数。第四种和第五种都是通过反射机制来创建一个对象，这里就不细说了，接下来详细说一下前三种情况。

在说之前先说一下引用拷贝

引用拷贝

public class Test {

public static void main(String[] args) {

Person person = new Person();

Person person1 = person;

System.out.println(person.hashCode());//1426511082

System.out.println(person1.hashCode());//1426511082

}

}

class Person{

}

输出结果：

1426511082

1426511082

有上述代码打印哈希值可知，person和person1指向一个内存地址，所以它们是一个对象，这里只是拷贝了引用而已。

浅拷贝

要实现对象的拷贝，那么要拷贝的这个对象的类必须实现Cloneable接口，并且重写clone()方法，由于clone()方法在object类中被定义为protected，由于protected对本包和所有子类可以访问，所以这里无法调用到clone()方法，因而我们必须将覆写的clone()方法声明为public

public class Test {

public static void main(String[] args) throws CloneNotSupportedException {

Car car = new Car("red");

Person person = new Person("zhang",car);

Person person1 = (Person)person.clone();

System.out.println(person.hashCode() == person1.hashCode());//false

System.out.println(person.getCar().hashCode() == person1.getCar().hashCode());//true

System.out.println(person.getName().hashCode() == person1.getName().hashCode());//true

person1.getCar().setColor("blue");

person1.setName("liu");

System.out.println(person.getCar().getColor());//blue

System.out.println(person1.getCar().getColor());//blue

System.out.println(person.getName());//zhang

System.out.println(person1.getName());//liu

}

}

class Person implements Cloneable{

private String name;

private Car car;

public Person(String name,Car car) {

this.car = car;

this.name = name;

}

public Object clone() throws CloneNotSupportedException {

// TODO Auto-generated method stub

return super.clone();

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Car getCar() {

return car;

}

public void setCar(Car car) {

this.car = car;

}

}

class Car{

private String color;

public Car(String color) {

this.color = color;

}

public String getColor() {

return color;

}

public void setColor(String color) {

this.color = color;

}

}

上述运行结果为:

false

true

true

blue

blue

zhang

liu

第一个true表明person这个对象我们已经复制成功了，person和person1不是指向一个内存，perosn.name与person.name这是因为在Car类中我们并没有覆写clone()方法，这就是浅拷贝。

第二个true说明了person.car与person1.car指向同一个地址，再将person1的car的属性值为blue后，person的也随之改变，这个也验证了我们所说的person.car与person1.car指向同一个地址

第三个true说明了perosn.name与person.name指向同一个地址，但是这时我们发现，person.name与person1.name不是一个值了，说明我们拷贝成功了，这是为什么，这不和car属性前后矛盾了？这是因为String类不是基本数据类型，而且直接被定义为final,而且没有Cloneable接口，所以我们无法对它像其他pojo类一样进行深拷贝，但这并不影响，因为String类是final,每次修改它都是重新创建新对象。

假设person还有一个基本数据类型属性，例如int类型的age属性的话，覆写了clone()方法后，直接拷贝是拷贝值，和String一样，当值发生变化的时候会重新创建。

我们总结一下，浅拷贝又称为浅复制，浅克隆，浅拷贝是指拷贝时只拷贝对象本身(包括对象中的基本变量)，而不拷贝对象包含的引用所指向的对象，拷贝出来的对象的所有变量的值都含有与原来对象相同的值，而所有对其他对象的引用都指向原来的对象，简单地说，浅拷贝只是拷贝了对象本身，但是对象所引用的所有对象并没有复制，只是复制了这个对象的引用，比如这儿的Car。

深拷贝

我们现在将Car类进行clone覆写，并且将Person中的clone()进行改动，让Person可以实现对Car属性的深克隆

public class Test {

public static void main(String[] args) throws CloneNotSupportedException {

Car car = new Car("red");

Person person = new Person("zhang",car);

Person person1 = (Person)person.clone();

System.out.println(person.hashCode() == person1.hashCode());//false

System.out.println(person.getCar().hashCode() == person1.getCar().hashCode());//false

System.out.println(person.getName().hashCode() == person1.getName().hashCode());//true

person1.getCar().setColor("blue");

person1.setName("liu");

System.out.println(person.getCar().getColor());//red

System.out.println(person1.getCar().getColor());//blue

System.out.println(person.getName());//zhang

System.out.println(person1.getName());//liu

}

}

class Person implements Cloneable{

private String name;

private Car car;

public Person(String name,Car car) {

this.car = car;

this.name = name;

}

public Object clone() throws CloneNotSupportedException {

// TODO Auto-generated method stub

Person person = (Person)super.clone();

person.car = (Car)car.clone();

return person;

}

public void setName(String name) {

this.name = name;

}

public void setCar(Car car) {

this.car = car;

}

public String getName() {

return name;

}

public Car getCar() {

return car;

}

}

class Car implements Cloneable{

private String color;

public Car(String color) {

this.color = color;

}

public String getColor() {

return color;

}

@Override

protected Object clone() throws CloneNotSupportedException {

return super.clone();

}

public void setColor(String color) {

this.color = color;

}

}

输出结果：

false

false

true

red

blue

zhang

liu

上述运行结果发生了改变，这次person和person.car的属性按照我们的预期都深拷贝过来了，现在思考一下，如果是Car类中还有其他pojo类的时候怎么办？我们难道只能层层实现clone()方法吗？那么接下来我们可以使用反序列化的方法来clone()一个方法。

反序列化

序列化机制提供了一种克隆对象的简便途径，只要对应的类是可序列化的就可以，做法是直接将对象序列化到输出流中，然后将其读回，这样产生的新的对象是对现有对象的一个深拷贝。在此过程中，我们不必将对象写到文件中，因为可以用ByteArrayOutputStream将数据保存到字节数组中。经过测试，已经完成深拷贝

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

public class Test {

public static void main(String[] args) throws Exception {

Car car = new Car("red");

Person person = new Person("zhang",car, 0);

Person person1 = (Person)person.deepClone();

System.out.println(person1);

System.out.println(person.hashCode() == person1.hashCode());//false

System.out.println(person.getCar().hashCode() == person1.getCar().hashCode());//false

System.out.println(person.getName().hashCode() == person1.getName().hashCode());//true

person1.getCar().setColor("blue");

person1.setName("liu");

person1.setAge(11);

System.out.println(person.getCar().getColor());//red

System.out.println(person1.getCar().getColor());//blue

System.out.println(person.getName());//zhang

System.out.println(person1.getName());//liu

}

}

class Person implements Serializable{

private static final long serialVersionUID = 1L;

private int age;

private String name;

private Car car;

public Person(String name,Car car ,int age) {

this.car = car;

this.name = name;

this.age = age;

}

public Object deepClone() throws Exception

{

//将对象写到流里

ByteArrayOutputStream bo=new ByteArrayOutputStream();

ObjectOutputStream oo=new ObjectOutputStream(bo);

oo.writeObject(this);

//从流里读出来

ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());

ObjectInputStream oi=new ObjectInputStream(bi);

return(oi.readObject());

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public void setName(String name) {

this.name = name;

}

public void setCar(Car car) {

this.car = car;

}

public String getName() {

return name;

}

public Car getCar() {

return car;

}

}

class Car implements Serializable{

private static final long serialVersionUID = 1L;

private String color;

public Car(String color) {

this.color = color;

}

public String getColor() {

return color;

}

public void setColor(String color) {

this.color = color;

}

}

运行结果：

CloneTest.Person@60e7a94c

false

false

true

red

blue

zhang

liu

如有错误欢迎您指出来，谢谢