假如说你想复制一个简单变量。很简单&＃xff1a;
int apples &＃61; 5;int pears &＃61; apples;
不仅仅是int类型&＃xff0c;其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。
但是如果你复制的是一个对象&＃xff0c;情况就有些复杂了。假设说我是一个beginner&＃xff0c;我会这样写&＃xff1a;
class Student {private int number;public int getNumber() {return number;}public void setNumber(int number) {this.number &＃61; number;}}
public class Test {public static void main(String args[]) {Student stu1 &＃61; new Student();stu1.setNumber(12345);Student stu2 &＃61; stu1;System.out.println("学生1:" &＃43; stu1.getNumber());System.out.println("学生2:" &＃43; stu2.getNumber());}
}
打印结果&＃xff1a;
学生1:12345
学生2:12345
这里我们自定义了一个学生类&＃xff0c;该类只有一个number字段。
我们新建了一个学生实例&＃xff0c;然后将该值赋值给stu2实例。(Student stu2 &＃61; stu1;)
再看看打印结果&＃xff0c;作为一个新手&＃xff0c;拍了拍胸腹&＃xff0c;对象复制不过如此&＃xff0c;
难道真的是这样吗&＃xff1f;我们试着改变stu2实例的number字段&＃xff0c;再打印结果看看&＃xff1a;
stu2.setNumber(54321);System.out.println("学生1:" &＃43; stu1.getNumber());System.out.println("学生2:" &＃43; stu2.getNumber());
打印结果:
学生1:54321
学生2:54321
这就怪了&＃xff0c;为什么改变学生2的学号&＃xff0c;学生1的学号也发生了变化呢&＃xff1f;
原因出在(stu2 &＃61; stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2&＃xff0c;
这样&＃xff0c;stu1和stu2指向内存堆中同一个对象。如图&＃xff1a;
那么&＃xff0c;怎样才能达到复制一个对象呢&＃xff1f;
是否记得万类之王Object。它有11个方法&＃xff0c;有两个protected的方法&＃xff0c;其中一个为clone方法。
该方法的签名是&＃xff1a;protected native Object clone() throws CloneNotSupportedException;
因为每个类直接或间接的父类都是Object&＃xff0c;因此它们都含有clone()方法&＃xff0c;但是因为该方法是protected&＃xff0c;所以都不能在类外进行访问。
要想对一个对象进行复制&＃xff0c;就需要对clone方法覆盖。
一般步骤是&＃xff08;浅复制&＃xff09;&＃xff1a;
1. 被复制的类需要实现Clonenable接口&＃xff08;不实现的话在调用clone方法会抛出CloneNotSupportedException异常) 该接口为标记接口(不含任何方法)
2. 覆盖clone()方法&＃xff0c;访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象&＃xff08;native为本地方法)。
我们先看看Object的clone()源代码是咋个说的。
Object的clone()源代码简介
/*** Creates and returns a copy of this {&＃64;code Object}. The default* implementation returns a so-called "shallow" copy: It creates a new* instance of the same class and then copies the field values (including* object references) from this instance to the new instance. A "deep" copy,* in contrast, would also recursively clone nested objects. A subclass that* needs to implement this kind of cloning should call {&＃64;code super.clone()}* to create the new instance and then create deep copies of the nested,* mutable objects.** &＃64;return a copy of this object.* &＃64;throws CloneNotSupportedException* if this object&＃39;s class does not implement the {&＃64;code* Cloneable} interface.*/protected Object clone() throws CloneNotSupportedException {if (!(this instanceof Cloneable)) {throw new CloneNotSupportedException("Class doesn&＃39;t implement Cloneable");}return internalClone((Cloneable) this);}/** Native helper method for cloning.*/private native Object internalClone(Cloneable o);
从上面的介绍看出&＃xff0c; clone方法首先会判对象是否实现了Cloneable接口&＃xff0c;若无则抛出CloneNotSupportedException, 最后会调用internalClone. intervalClone是一个native方法&＃xff0c;一般来说native方法的执行效率高于非native方法。
当某个类要复写clone方法时&＃xff0c;要继承Cloneable接口。通常的克隆对象都是通过super.clone()方法来克隆对象。正如这个介绍所说的一样&＃xff0c;如果要deep copy&＃xff0c;则要递归低调用每个嵌套的属性对象的clone()方法。
下面对上面那个方法进行改造&＃xff1a;
class Student implements Cloneable{private int number;public int getNumber() {return number;}public void setNumber(int number) {this.number &＃61; number;}&＃64;Overridepublic Object clone() {Student stu &＃61; null;try{stu &＃61; (Student)super.clone();}catch(CloneNotSupportedException e) {e.printStackTrace();}return stu;}
}
public class Test {public static void main(String args[]) {Student stu1 &＃61; new Student();stu1.setNumber(12345);Student stu2 &＃61; (Student)stu1.clone();System.out.println("学生1:" &＃43; stu1.getNumber());System.out.println("学生2:" &＃43; stu2.getNumber());stu2.setNumber(54321);System.out.println("学生1:" &＃43; stu1.getNumber());System.out.println("学生2:" &＃43; stu2.getNumber());}
}
打印结果&＃xff1a;
学生1:12345
学生2:12345
学生1:12345
学生2:54321
如果你还不相信这两个对象不是同一个对象&＃xff0c;那么你可以看看这一句&＃xff1a;
System.out.println(stu1 &＃61;&＃61; stu2); // false
上面的复制被称为浅复制(Shallow Copy&＃xff0c;因为它对嵌套的属性对象也是直接把另外一个对象中的嵌套属性对象的引用拿过来赋值)。
我们在学生类里再加一个Address类。
class Address {private String add;public String getAdd() {return add;}public void setAdd(String add) {this.add &＃61; add;}}class Student implements Cloneable{private int number;private Address addr;public Address getAddr() {return addr;}public void setAddr(Address addr) {this.addr &＃61; addr;}public int getNumber() {return number;}public void setNumber(int number) {this.number &＃61; number;}&＃64;Overridepublic Object clone() {Student stu &＃61; null;try{stu &＃61; (Student)super.clone();}catch(CloneNotSupportedException e) {e.printStackTrace();}return stu;}
}
public class Test {public static void main(String args[]) {Address addr &＃61; new Address();addr.setAdd("杭州市");Student stu1 &＃61; new Student();stu1.setNumber(123);stu1.setAddr(addr);Student stu2 &＃61; (Student)stu1.clone();System.out.println("学生1:" &＃43; stu1.getNumber() &＃43; ",地址:" &＃43; stu1.getAddr().getAdd());System.out.println("学生2:" &＃43; stu2.getNumber() &＃43; ",地址:" &＃43; stu2.getAddr().getAdd());}
}
打印结果&＃xff1a;
学生1:123,地址:杭州市
学生2:123,地址:杭州市
乍一看没什么问题&＃xff0c;真的是这样吗&＃xff1f;
我们在main方法中试着改变addr实例的地址。
addr.setAdd("西湖区");System.out.println("学生1:" &＃43; stu1.getNumber() &＃43; ",地址:" &＃43; stu1.getAddr().getAdd());System.out.println("学生2:" &＃43; stu2.getNumber() &＃43; ",地址:" &＃43; stu2.getAddr().getAdd());
打印结果&＃xff1a;
学生1:123,地址:杭州市
学生2:123,地址:杭州市
学生1:123,地址:西湖区
学生2:123,地址:西湖区
这就奇怪了&＃xff0c;怎么两个学生的地址都改变了&＃xff1f;原因是浅复制只是复制了addr变量的引用&＃xff0c;并没有真正的开辟另一块空间&＃xff0c;将值复制后再将引用返回给新对象。
所以&＃xff0c;为了达到真正的复制对象&＃xff0c;而不是纯粹引用复制。我们需要深度复制(deep copy)。
我们需要将Address类可复制化&＃xff0c;并且修改clone方法&＃xff0c;完整代码如下&＃xff1a;
package abc;class Address implements Cloneable {private String add;public String getAdd() {return add;}public void setAdd(String add) {this.add &＃61; add;}&＃64;Overridepublic Object clone() {Address addr &＃61; null;try{addr &＃61; (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 &＃61; addr;}public int getNumber() {return number;}public void setNumber(int number) {this.number &＃61; number;}&＃64;Overridepublic Object clone() {Student stu &＃61; null;try{stu &＃61; (Student)super.clone(); //浅复制}catch(CloneNotSupportedException e) {e.printStackTrace();}stu.addr &＃61; (Address)addr.clone(); //深度复制return stu;}
}
public class Test {public static void main(String args[]) {Address addr &＃61; new Address();addr.setAdd("杭州市");Student stu1 &＃61; new Student();stu1.setNumber(123);stu1.setAddr(addr);Student stu2 &＃61; (Student)stu1.clone();System.out.println("学生1:" &＃43; stu1.getNumber() &＃43; ",地址:" &＃43; stu1.getAddr().getAdd());System.out.println("学生2:" &＃43; stu2.getNumber() &＃43; ",地址:" &＃43; stu2.getAddr().getAdd());addr.setAdd("西湖区");System.out.println("学生1:" &＃43; stu1.getNumber() &＃43; ",地址:" &＃43; stu1.getAddr().getAdd());System.out.println("学生2:" &＃43; stu2.getNumber() &＃43; ",地址:" &＃43; stu2.getAddr().getAdd());}
}
打印结果&＃xff1a;
学生1:123,地址:杭州市
学生2:123,地址:杭州市
学生1:123,地址:西湖区
学生2:123,地址:杭州市
这样结果就符合我们的想法了。最后我们可以看看API里其中一个实现了clone方法的类&＃xff1a;
java.util.Date:
/*** Return a copy of this object.*/public Object clone() {Date d &＃61; null;try {d &＃61; (Date)super.clone();if (cdate !&＃61; null) {d.cdate &＃61; (BaseCalendar.Date) cdate.clone();}} catch (CloneNotSupportedException e) {} // Won&＃39;t happenreturn d;}
该类其实也属于深度复制。
京公网安备 11010802041100号