Java中除了基本类型int,char,double等的赋值是按照值传递之外，其余的类型和对象都是按照引用进行传递的。
下面来看一个关于引用的例子。
package referenceCopy;
// 一个文件中允许有多个类，但是public类型的类只能有一个
class Basic {
private int aInt = 0;
public int getAInt() {
return aInt;
}
public void setAInt(int int1) {
aInt =int1;
}
public void changeInt() {
this.aInt = 1;
}
}
public class Children {
// int char double 等基本类型都是按照值传递的，
// 除此之外的其他类型都是按照引用进行传递的。
public static void main(String[] args) {
// TODO Auto-generated method stub
Basic b = new Basic();
Basic a = b;
b.changeInt();
System.out.println(b.getAInt());
System.out.println(a.getAInt());
}
}
输出的结果为1,1
究其原因是a和b的指向同一个引用。
那么如何变成两个引用呢，我们提出了浅复制和深复制。
首先我们来看浅复制
package referenceCopy;
import java.util.Date;
// 一个文件中允许有多个类，但是public类型的类只能有一个
class BasicA implements Cloneable{
private int aInt = 0;
private Date birth = new Date();
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
public void changeBirth() {
this.birth.setMonth(1);
}
public int getAInt() {
return aInt;
}
public void setAInt(int int1) {
aInt =int1;
}
public void changeInt() {
this.aInt = 1;
}
// 改写clone方法
public Object clone() {
Object o = null;
try {
o = (BasicA)super.clone();
} catch (Exception e) {
e.printStackTrace();
}
return o;
}
}
public class WeakChildrenReferneceCopy {
// int char double 等基本类型都是按照值传递的，
// 除此之外的其他类型都是按照引用进行传递的。
// 相对于Children类，该类采用了浅复制的方法来进行复制。
// 基本的数据类型变量已经全部复制了进来，但是具体对象的改变并未改变
public static void main(String[] args) {
BasicA b = new BasicA();
BasicA a = (BasicA)b.clone();
b.changeInt();
b.changeBirth();
// 由此可见，浅复制只复制了简单的数据类型，
// 对于复杂的数据类型并未进行复制
System.out.println(a.getAInt());
System.out.println(b.getAInt());
System.out.println(b.getBirth());
System.out.println(a.getBirth());
}
}
输出的结果如下所示：
0
1
Mon Feb 06 14:45:47 CST 2017
Mon Feb 06 14:45:47 CST 2017
由结果可以看出，浅复制并未改变其他对象的引用。
由此，我们提出了深复制
package referenceCopy;
import java.util.Date;
//一个文件中允许有多个类，但是public类型的类只能有一个
class BasicB implements Cloneable{
private int aInt = 0;
private Date birth = new Date();
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
public void changeBirth() {
this.birth.setMonth(1);
}
public int getAInt() {
return aInt;
}
public void setAInt(int int1) {
aInt =int1;
}
public void changeInt() {
this.aInt = 1;
}
// 改写clone方法
public Object clone() {
// 强复制需要将返回的复制对象改变为自己需要的对象
BasicB o = null;
try {
o = (BasicB)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
o.birth = (Date)this.getBirth().clone();
return o;
}
}
public class StrongChildrenReferenceCopy {
public static void main(String[] args) {
BasicB a = new BasicB();
BasicB b = (BasicB) a.clone();
b.changeInt();
b.changeBirth();
System.out.println(a.getAInt());
System.out.println(b.getAInt());
System.out.println(a.getBirth());
System.out.println(b.getBirth());
}
}
运行结果如下：
0
1
Thu Jul 06 14:55:13 CST 2017
Mon Feb 06 14:55:13 CST 2017
由上处进行了标红的地方可以看出两者在进行复制时的不同之处。
浅复制：被复制的对象的所有 变量都含有与原来对象相同的值，而所有对其他对象的引用仍然指向原来对象相同的值。换言之，浅复制只复制自己考虑的对象，未复制它所引用的对象。
深复制：被复制对象的所有变量都含有与原来对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制的新对象，而不是原有的那些被引用的对象，换言之，深复制把复制对象 所引用的对象都复制了一遍。