1．Java的clone()方法
- clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
- 对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
- 对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
- 如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。
2.Java中对象的克隆
- 为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
- 在派生类中覆盖基类的clone()方法，并声明为public。
- 在派生类的clone()方法中，调用super.clone()。
- 在派生类中实现Cloneable接口。
假如说你想复制一个简单变量。很简单：
int apples = 5;
int pears = apples;
不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。
但是如果你复制的是一个对象，情况就有些复杂了。
假设说我是一个beginner，我会这样写：
class Student {
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
public class Test {
public static void main(String args[]) {
Student stu1 = new Student();
stu1.setNumber(12345);
Student stu2 = stu1;
System.out.println("学生1:" + stu1.getNumber());
System.out.println("学生2:" + stu2.getNumber());
}
}
输出结果
学生1:12345
学生2:12345
这里我们自定义了一个学生类，该类只有一个number字段。
我们新建了一个学生实例，然后将该值赋值给stu2实例。(Student stu2 = stu1;)
再看看打印结果，作为一个新手，拍了拍胸腹，对象复制不过如此，
难道真的是这样吗？
我们试着改变stu2实例的number字段，再打印结果看看：
stu2.setNumber(54321);
System.out.println("学生1:" + stu1.getNumber());
System.out.println("学生2:" + stu2.getNumber());
结果：
学生1:54321
学生2:54321原因出在(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为本地方法)
下面对上面那个方法进行改造：
class Student implements Cloneable{
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
}
public class Test {
public static void main(String args[]) {
Student stu1 = new Student();
stu1.setNumber(12345);
Student stu2 = (Student)stu1.clone();
System.out.println("学生1:" + stu1.getNumber());
System.out.println("学生2:" + stu2.getNumber());
stu2.setNumber(54321);
System.out.println("学生1:" + stu1.getNumber());
System.out.println("学生2:" + stu2.getNumber());
}
}打印结果：
学生1:12345
学生2:12345
学生1:12345
学生2:54321上面的复制被称为浅复制(Shallow Copy)，还有一种稍微复杂的
深度复制(deep copy)：
我们在学生类里再加一个Address类。
class Address {
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
}
class Student implements Cloneable{
private int number;
private Address addr;
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
}
public class Test {
public static void main(String args[]) {
Address addr = new Address();
addr.setAdd("杭州市");
Student stu1 = new Student();
stu1.setNumber(123);
stu1.setAddr(addr);
Student stu2 = (Student)stu1.clone();
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
}
}打印结果：
学生1:123,地址:杭州市
学生2:123,地址:杭州市
乍一看没什么问题，真的是这样吗？我们在main方法中试着改变addr实例的地址。
addr.setAdd("西湖区");
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
打印结果：
学生1:123,地址:杭州市
学生2:123,地址:杭州市
学生1:123,地址:西湖区
学生2:123,地址:西湖区
这就奇怪了，怎么两个学生的地址都改变了？
原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。
所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：
package abc;
class Address implements Cloneable {
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
@Override
public Object clone() {
Address addr = null;
try{
addr = (Address)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
return addr;
}
}
class Student implements Cloneable{
private int number;
private Address addr;
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public Object clone() {
Student stu = null;
try{
stu = (Student)super.clone(); //浅复制
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
stu.addr = (Address)addr.clone(); //深度复制
return stu;
}
}
public class Test {
public static void main(String args[]) {
Address addr = new Address();
addr.setAdd("杭州市");
Student stu1 = new Student();
stu1.setNumber(123);
stu1.setAddr(addr);
Student stu2 = (Student)stu1.clone();
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
addr.setAdd("西湖区");
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
}
}
学生1:123,地址:杭州市
学生2:123,地址:杭州市
学生1:123,地址:西湖区
学生2:123,地址:杭州市
最后我们可以看看API里其中一个实现了clone方法的类：
Java.util.Date:
/**
* Return a copy of this object.
*/
public Object clone() {
Date d = null;
try {
d = (Date)super.clone();
if (cdate != null) {
d.cdate = (BaseCalendar.Date) cdate.clone();
}
} catch (CloneNotSupportedException e) {} // Won't happen
return d;
}
还有一种利用串行化来做深复制
把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做 “解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。
如下为深复制源代码。
实体类
package com.lin.test;
import java.io.Serializable;
/**
* @athor tianlin
*
* 2015年6月28日 下午1:56:18
*
**/
public class Dog implements Serializable{
private static final long serialVersionUID = 1L;
private String dogName;
public String getDogName() {
return dogName;
}
public void setDogName(String dogName) {
this.dogName = dogName;
}
}
package com.lin.test;
import java.io.Serializable;
/**
* @athor tianlin
*
* 2015年6月28日 下午1:43:24
*
**/
public class User implements Serializable{
private static final long serialVersionUID = 1L;
private String username;
private Dog dog;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
}
克隆执行类
package com.lin.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* @athor tianlin
*
* 2015年6月28日 下午1:44:08
*
**/
public class ObjCloner {
@SuppressWarnings("unchecked")
public static <T>T cloneObj(T obj){
T retVal = null;
try{
// 将对象写入流中
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
// 从流中读出对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
retVal = (T)ois.readObject();
}catch(Exception e){
e.printStackTrace();
}
return retVal;
}
}测试类
package com.lin.test;
/**
* @athor tianlin
*
* 2015年6月28日 下午1:42:47
*
**/
public class CloneTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("张三");
Dog dog = new Dog();
dog.setDogName("小狗1");
user.setDog(dog);
User user2 = ObjCloner.cloneObj(user);
System.out.println("user username : "+user.getUsername());
System.out.println("user dogname : " + user.getDog().getDogName());
System.out.println("user2 username : "+user2.getUsername());
System.out.println("user2 dogname : " + user2.getDog().getDogName());
System.out.println(" -------------------------------------");
user2.setUsername("李四");
user2.getDog().setDogName("小狗2");;
System.out.println("user username : "+user.getUsername());
System.out.println("user dogname : " + user.getDog().getDogName());
System.out.println("user2 username : "+user2.getUsername());
System.out.println("user2 dogname : " + user2.getDog().getDogName());
}
}
输出结果
user username : 张三
user dogname : 小狗1
user2 username : 张三
user2 dogname : 小狗1
-------------------------------------
user username : 张三
user dogname : 小狗1
user2 username : 李四
user2 dogname : 小狗2
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
