JAVA中的指针引用及对象的cloneWord格式.docx

1、 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）;After call changeObj（） method:=Print Primtive=）;Before call changePri（） method: + oRef.aInt）; oRef

2、.changePri（oRef.aInt）;After call changePri（） method:/* RUN RESULT init value changed value=Print Primtive= 11*/这段代码的主要部分调用了两个很相近的方法，changeObj（）和changePri（）。唯一不同的是它们一个把对象作为输入参数，另一个把Java中的基本类型int作为输入参数。并且在这两个函数体内部都对输入的参数进行了改动。看似一样的方法，程序输出的结果却不太一样。changeObj（）方法真正的把输入的参数改变了，而changePri（）方法对输入的参数没有任何的改变。从

3、这个例子知道Java对对象和基本的数据类型的处理是不一样的。和C语言一样，当把Java的基本数据类型（如int，char，double等）作为入口参数传给函数体的时候，传入的参数在函数体内部变成了局部变量，这个局部变量是输入参数的一个拷贝，所有的函数体内部的操作都是针对这个拷贝的操作，函数执行结束后，这个局部变量也就完成了它的使命，它影响不到作为输入参数的变量。这种方式的参数传递被称为值传递。而在Java中用对象的作为入口参数的传递则缺省为引用传递，也就是说仅仅传递了对象的一个引用，这个的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。除了在函

4、数传值的时候是，在任何用向对象变量赋值的时候都是如：class PassObjpublic class ObjPassValue PassObj objA = new PassObj（）; PassObj objB = objA; objA.str = changed in objAPrint objB.str value: + objB.str）; changed in objA第一句是在内存中生成一个新的PassObj对象，然后把这个PassObj的引用赋给变量objA，第二句是把PassObj对象的引用又赋给了变量objB。此时objA和objB是两个完全一致的变量，以后任何对objA的

5、改变都等同于对objB的改变。即使明白了Java语言中的概念也许还会不经意间犯下面的错误。Hashtable真的能存储对象吗？看一看下面的很简单的代码，先是声明了一个Hashtable和StringBuffer对象，然后分四次把StriingBuffer对象放入到Hashtable表中，在每次放入之前都对这个StringBuffer对象append（）了一些新的字符串：import java.util.*;public class HashtableAdd public static void main（String args） Hashtable ht = new Hashtable（）;

6、StringBuffer sb = new StringBuffer（）; sb.append（abc, ht.put（1,sb）;def,2mno,3xyz.4 int numObj=0; Enumeration it = ht.elements（）; while（it.hasMoreElements（） System.out.print（get StringBufffer +（+numObj）+ from Hashtable: System.out.println（it.nextElement（）;如果你认为输出的结果是：get StringBufffer 1 from Hashtable

7、: abc, get StringBufffer 2 from Hashtable: abc,def， get StringBufffer 3 from Hashtable: abc,def,mno, get StringBufffer 4 from Hashtable: abc,def,mno,xyz.那么你就要回过头再仔细看一看上一个问题了，把对象时作为入口参数传给函数，实质上是传递了对象的引用，向Hashtable传递StringBuffer对象也是只传递了这个StringBuffer对象的引用！每一次向Hashtable表中put一次StringBuffer，并没有生成新的String

8、Buffer对象，只是在Hashtable表中又放入了一个指向同一StringBuffer对象的引用而已。对Hashtable表存储的任何一个StringBuffer对象（更确切的说应该是对象的引用）的改动，实际上都是对同一个StringBuffer的改动。所以Hashtable并不能真正存储能对象，而只能存储对象的引用。也应该知道这条原则对与Hashtable相似的Vector, List, Map, Set等都是一样的。上面的例程的实际输出的结果是：回页首类，对象与引用Java最基本的概念就是类，类包括函数和变量。如果想要应用类，就要把类生成对象，这个过程被称作类的实例化有几种方法把类实例

9、化成对象，最常用的就是用new操作符。类实例化成对象后，就意味着要在内存中占据一块空间存放实例。想要对这块空间操作就要应用到对象的引用。引用在Java语言中的体现就是变量，而变量的类型就是这个引用的对象。虽然在语法上可以在生成一个对象后直接调用该对象的函数或变量，如：new String（Hello NDP）.substring（0,3）/RETURN RESULT: Hel但由于没有相应的引用，对这个对象的使用也只能局限这条语句中了。产生：引用总是在把对象作参数传递的过程中自动发生，不需要人为的产生，也不能人为的控制引用的产生。这个传递包括把对象作为函数的入口参数的情况，也包括用进行对象赋值

10、的时候。范围：只有局部的引用，没有局部的对象。引用在Java语言的体现就是变量，而变量在Java语言中是有范围的，可以是局部的，也可以是全局的。生存期：程序只能控制引用的生存周期。对象的生存期是由Java控制。用new Object（）语句生成一个新的对象，是在计算机的内存中声明一块区域存储对象，只有Java的垃圾收集器才能决定在适当的时候回收对象占用的内存。没有办法阻止对引用的改动。什么是clone？在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两

11、个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone（）。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。怎样应用clone（）方法？一个很典型的调用

12、clone（）代码如下：class CloneClass implements Cloneable public int aInt; public Object clone（） CloneClass o = null; try o = （CloneClass）super.clone（）; catch（CloneNotSupportedException e） e.printStackTrace（）; return o;有三个值得注意的地方，一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang包，java.lang包已经被缺省的导入类中

13、，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone（）方法。最后在clone（）方法中调用了super.clone（），这也意味着无论clone类的继承结构是什么样的，super.clone（）直接或间接调用了java.lang.Object类的clone（）方法。下面再详细的解释一下这几点。应该说第三点是最重要的，仔细观察一下Object类的clone（）一个native方法，native方法的效率一般来说都是远高于java中的非native方法。这也解释了为什么要用Object中clone（）方法而不是先new一个类，然后把原始对象中的信息赋到新对

14、象中，虽然这也实现了clone功能。对于第二点，也要观察Object类中的clone（）还是一个protected属性的方法。这也意味着如果要应用clone（）方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone（）方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone（）方法，重载之后要把clone（）方法的属性设置为public。那么clone类为什么还要实现Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对Object类中cl

15、one（）方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone（）方法（也就是调用了super.Clone（）方法），那么Object的clone（）方法就会抛出CloneNotSupportedException异常。以上是clone的最基本的步骤，想要完成一个成功的clone，还要了解什么是影子clone和深度clone什么是影子clone？下面的例子包含三个类UnCloneA，CloneB，CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量，并且重载clone（）方法。CloneMain类初始化UnCloneA类的一

16、个实例b1，然后调用clone（）方法生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：package clone;class UnCloneA private int i; public UnCloneA（int ii） i = ii; public void doubleValue（） i *= 2; public String toString（） return Integer.toString（i）;class CloneB implements Cloneable public UnCloneA unCA = new UnCloneA（111）; CloneB o = null

17、; o = （CloneB）super.clone（）;public class CloneMain public static void main（String a） CloneB b1 = new CloneB（）; b1.aInt = 11;before clone,b1.aInt = + b1.aInt）;before clone,b1.unCA = + b1.unCA）; CloneB b2 = （CloneB）b1.clone（）; b2.aInt = 22; b2.unCA.doubleValue（）;=after clone,b1.aInt = after clone,b1.u

18、nCA = after clone,b2.aInt = + b2.aInt）;after clone,b2.unCA = + b2.unCA）;/* RUN RESULT:before clone,b1.aInt = 11before clone,b1.unCA = 111=after clone,b1.aInt = 11after clone,b1.unCA = 222after clone,b2.aInt = 22after clone,b2.unCA = 222输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致，int类型是真正的被clone

19、了，因为改变了b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA，很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！从中可以看出，调用Object类中clone（）方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是

20、同一个对象。大多时候，这种clone的结果往往不是我们所希望的结果，这种clone也被称为要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。怎么进行深度clone？把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone（）方法）。二是在CloneB的clone（）方法中加入一句o.unCA = （UnCloneA）unCA.clone（）;程序如下：package clone.ext;class UnCloneA implements Cloneable UnCloneA o = null; o = （UnCloneA）super.clone（）; o.unCA = （UnCloneA）unCA.clone（）;after clone,b1.unCA = 111可以看出，现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例，而且在CloneB b2 = （CloneB）b1.clone（）;调用的那一刻b1和b2拥有相同的值，在这里，b1.i = b2.i = 11。要知道不是所有的类