一、参数传递
class obj{
string str = "init value";
public string tostring(){
return str;
}
}
public class objref{
obj aobj = new obj();
int aint = 11;
public void changeobj(obj inobj){
inobj.str = "changed value";
}
public void changepri(int inint){
inint = 22;
}
public static void main(string[] args)
{
objref oref = new objref();
system.out.println("before call changeobj() method: " + oref.aobj);
oref.changeobj(oref.aobj);
system.out.println("after call changeobj() method: " + oref.aobj);
system.out.println("==================print primtive=================");
system.out.println("before call changepri() method: " + oref.aint);
oref.changepri(oref.aint);
system.out.println("after call changepri() method: " + oref.aint);
}
}
|
上述代码中changeobj(obj inobj)方法传入的参数是对象的引用 ，changepri(int inint)方法传入对参数是一个int值。输出结果如下：
before call changeobj() method: init value
after call changeobj() method: changed value
==================print primtive=================
before call changepri() method: 11
after call changepri() method: 11
显然前者对输入的参数做了修改，后者对输入参数没有任何影响。也就是说当方法参数是基本数据类型时，传入的变量变成了方法的局部变量，这个局部变量是输入参数的一个拷贝，所有的函数体内部的操作都是针对这个拷贝的操作。因此方法执行完成后对输入参数没有任何影响。这种参数传递方式就是值传递! 而当方法参数是对象时，传递的仅仅是对象的引用 ，方法内对对象的改变直接影响到输入对象参数。这种方式就是引用传递!
因此得出结论：当输入参数是基本数据类型时，采用的是值传递；当输入参数是对象时，采用的是引用传递。
二、对象clone
java中如果需要与一个对象完全相同的副本对象，采取直接赋值的方式是不对的，因为赋值操作传递的是对象的引用，而采用clone方法是最高效的、最方便的。
要实现对象 的clone功能，该对象所属的类必须实现clonable接口，并实现clone()方法。clone分为两种：影子clone和深度clone。
调用object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。 这对于基本数据类型是没有任何问题的，但对于非基本类型的变量 ，因为它们保存的仅仅是对象的引用，这样clone后的对象中的非基本类型变量和clone前的对象中的非基本类型变量指向的是同一个对象，这类似于前面讲到的对象之间直接赋值。这种clone称为“影子clone”。
显然我们希望clone前后的对象(a，clonea)中的非基本类型变量指向的是不同的对象(c)，这就需要“深度clone”。要实现“深度clone”需要实现非基本类型变量 所指向的对象(c)的clone()方法，并且在clone对象(a)的clone()方法中调用c的clone()方法。如
class c implements clonable{
private int cint;
public c(int ii) { cint = ii; }
public void doublevalue(int ii) { cint *= 2; }
public string tostring(){ return integer.tostring(cint); }
public object clone(){
c o = null;
try{
o = (c)super.clone();
}catch(clonenotsupportedexception e){
e.printstacktrace();
}
return o;
}
}
class a implements clonable{
private int aint;
c cc = new c(123);
public object clone(){
a o = null;
try{
o = (a)super.clone();
}catch(clonenotsupportedexception e){
e.printstacktrace();
}
o.cc = (c)cc.clone();
return o;
}
调用时：
a aa = new a();
a bb = (a) aa.clone();
此时aa和bb对象中的内容就完全相同了!
}
|
闽公网安备 35060202000074号