本文目录
1. 创建对象的5种方式：
（1）通过new关键字
Object obj = new Object（）
（2）通过Class类的newInstance方法
这种方式默认时调用类的无参构造函数，如Person p = Class.forName(“com.oymn.test.Person”).newInstance()
（3）通过Constructor类的newInstance方法
这种方式和第二种类似，都是通过反射来实现。通过java.lang.relect.Constructor类的newInstance方法来指定某个构造器来创建对象。如Person p = Person.class.getConstructors()[0].newInstance()
实际上第二种方式利用Class类的newInstance方法创建对象， 其内部调用还是Contstructor的newInstance方法。
（4）利用clone方法
clone是Object类中的一个方法，通过对象.clone方法可以克隆一个内容和对象A一模一样的对象B，该方法创建的对象是浅拷贝，具体关于浅拷贝和深拷贝详情见以下。
Person p2 = p1.clone()
（5）反序列化
序列化：将堆内存中的Java对象数据，通过某种方式把对象存储到磁盘中或者传递到其他网络结点（在网络上传输）。
反序列化：将磁盘中的数据或者网络节点上的数据，恢复成Java对象。
2. clone方法
clone方法是Object类的一个方法，实现浅拷贝。
使用clone需要实现Cloneable接口。
protected native Object clone() throws CloneNotSupportedException;
先看一个例子：
public class Address {
private String province;
private String city;
public Address(String province, String city) {
this.province = province;
this.city = city;
}
}
//实现Cloneable接口
public class Person implements Cloneable {
private String name;
private Integer age;
//引用数据类型
private Address address;
public Person(String name, Integer age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public static void main(String[] args) {
Person p1 = new Person("hh",10,new Address("广东","广州"));
try {
Person p2 = (Person) p1.clone();
System.out.println(p1 == p2); //false
System.out.println(p1.getAddress() == p2.getAddress()); //true
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
可以发现，使用clone方法克隆一个新的Person对象，两个Person对象的引用是不同的，说明确实是创建了新的Person对象，但是里面的Address成员变量却是指向了同一个内存地址，这便是浅拷贝。
3. 浅拷贝
浅拷贝：克隆一个新的对象，如果成员变量是值类型的，则复制一份到新的对象， 如果成员变量是引用类型，则也仅仅是复制引用值而不是复制引用的对象。
上面的clone方法只能实现浅拷贝。
4. 深拷贝
学习了浅拷贝，深拷贝自然也知道是什么了。
深拷贝：克隆一个对象，无论其成员变量是值类型还是引用类型，都是会单独复制一份，当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。
既然Object自带的clone方法只能实现浅拷贝，那我们就只能自己来实现深拷贝了。
实现深拷贝的两种方式：
（1）让每个引用类型属性都重写clone方法
就上面的例子来说，我们让Address类也实现Cloneable接口，重写clone方法：
//实现Cloneable接口
public class Address implements Cloneable {
private String province;
private String city;
public Address(String province, String city) {
this.province = province;
this.city = city;
}
//重写clone方法
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
而在Person的clone方法中，手动帮address进行克隆。
@Override
protected Object clone() throws CloneNotSupportedException {
Person person = (Person) super.clone();
//手动克隆address
person.address = (Address) person.address.clone();
return person;
}
这样就能实现深拷贝。
但是这样有很严重的弊端，当Address类中也有引用数据类型的成员变量，也需要实现Cloneable接口，实现clone方法，每一个都需要手动修改，代码量会很大，很不方便。
于是推荐使用序列化方式
（2）利用序列化
序列化是将对象写到流中进行传输，而反序列化是把对象从流中读取出来。
这里写到流中的对象是原始对象的一个拷贝，因为原始对象还在JVM中，所以可以通过对象的序列化产生克隆对象，然后通过反序列化获取这个对象。
注意：每个需要序列化的类都要实现Serializable接口，如果有哪个属性不需要序列化，可以将其声明为transient，即将其排除在克隆之外。
在Person类中通过序列化方式实现深拷贝：
public Object deepClone(){
//输出
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
//输入
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);
//反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
return ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}