java--值传递和引用传递

java--值传递和引用传递 1

 

值传递：

class Str
{
    public static void main(String[] args) { 
      int i = 900;
      System.out.println(i);

      changeInt(i);
      System.out.println(i);
    }

    public static void changeInt(int s)
    {
      s = 34234;
    }
}

结果：
900
900

这就是所谓的值传递。i把自己的副本给了函数changeInt的形参，而在changeInt中虽然将s赋值34234.但是对原来的i值并没有影响，因为它所修改的只是i的copy品而已。

 

引用传递：

class Str
{
    public static void main(String[] args) { 
       Yinyong y = new Yinyong();
       System.out.println(y.age);

       changeObject(y);
       System.out.println(y.age);
    }

    public static void changeObject(Yinyong obj){
       obj.age = 34234;
    }
}

class Yinyong
{
  int age = 22;
}

声明了个简单的类Yinyong，当把Yinyong的对象y传递给函数changeObject后，看下前后结果：

22
34234

值被改变了，这就是引用调用。

 

下面再看看传递String对象会发生什么结果？

class Str
{
  public static void main(String[] args) {  
   String s = "java test";
   System.out.println(s);

   changeString(s);
   System.out.println(s);
  }

  public static void changeString(String str)
  {
   str = "3gg over right";
  }
}

看看结果吧：

java test
java test

 

你惊奇的发现s的值并没有改变！你会问了，String不也是引用类型的吗？怎么它的值没有改变呢？

 

因为是这样的：

String被设计为不可修改的类型，也就是对String对象的任何修改都将重新创建一个对象而放弃以前的内存空间的引用！

 

如上例：

比如 s指向0x2344， 当它赋值给str时str也同样指向了0x2344.而当 执行str＝"3gg over right"后，str指向了别的地方。也许是

0x2222或者其他，反正不是0x2344了。所以当你输出s的时候，它的值并没有被修改！

 

 

java-值传递和引用传递 2

Java语言明确说明取消了指针，因为指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常复杂难以理解，Java放弃指针的概念绝对是极其明智的。但这只是在Java语言中没有明确的指针定义，实质上每一个new语句返回的都是一个指针的引用，只不过在大多时候Java中不用关心如何操作这个"指针"，更不用象在操作C＋＋的指针那样胆战心惊。唯一要多多关心的是在给函数传递对象的时候。如下例程：

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);    }}/* RUN RESULTBefore call changeObj() method: init valueAfter call changeObj() method: changed value==================Print Primtive=================Before call changePri() method: 11After call changePri() method: 11**/

这段代码的主要部分调用了两个很相近的方法，changeObj()和changePri()。唯一不同的是它们一个把对象作为输入参数，另一个把Java中的基本类型int作为输入参数。并且在这两个函数体内部都对输入的参数进行了改动。看似一样的方法，程序输出的结果却不太一样。changeObj()方法真正的把输入的参数改变了，而changePri()方法对输入的参数没有任何的改变。

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

除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"。如：

package reference;class PassObj{    String str = "init value";}public class ObjPassValue {    public static void main(String[] args)     {        PassObj objA = new PassObj();        PassObj objB = objA;        objA.str = "changed in objA";        System.out.println("Print objB.str value: " + objB.str);    }}/* RUN RESULTPrint objB.str value: changed in objA*/

第一句是在内存中生成一个新的PassObj对象，然后把这个PassObj的引用赋给变量objA，第二句是把PassObj对象的引用又赋给了变量objB。此时objA和objB是两个完全一致的变量，以后任何对objA的改变都等同于对objB的改变。

即使明白了Java语言中的"指针"概念也许还会不经意间犯下面的错误。

二

Java代码

public class ParamTest {  

    // 初始值为0  

    protected int num = 0;  

    // 为方法参数重新赋值  

    public void change(int i) {  

        i = 5;  

    }  

    // 为方法参数重新赋值  

    public void change(ParamTest t) {  

        ParamTest tmp = new ParamTest();  

        tmp.num = 9;  

        t = tmp;  

    }  

    // 改变方法参数的值  

    public void add(int i) {  

        i += 10;  

    }  

    // 改变方法参数属性的值  

    public void add(ParamTest pt) {  

        pt.num += 20;  

    }  

    public static void main(String[] args) {  

        ParamTest t = new ParamTest();  

        System.out.println("参数--基本类型");  

        System.out.println("原有的值：" + t.num);  

        // 为基本类型参数重新赋值  

        t.change(t.num);  

        System.out.println("赋值之后：" + t.num);  

        // 为引用型参数重新赋值  

        t.change(t);  

        System.out.println("运算之后：" + t.num);  

        System.out.println();  

        t = new ParamTest();  

        System.out.println("参数--引用类型");  

        System.out.println("原有的值：" + t.num);  

        // 改变基本类型参数的值  

        t.add(t.num);  

        System.out.println("赋引用后：" + t.num);  

        // 改变引用类型参数所指向对象的属性值  

        t.add(t);  

        System.out.println("改属性后：" + t.num);  

    }  

}

这段代码的运行结果如下：

参数--基本类型

原有的值：0

赋值之后：0

运算之后：0

参数--引用类型

原有的值：0

赋引用后：0

改属性后：20

从上面这个直观的结果中我们很容易得出如下结论：

对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。

对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。

方法体内对参数进行运算，不影响原有变量的值。

方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。

上面总结出来的不过是我们所看到的表面现象。那么，为什么会出现这样的现象呢？这就要说到值传递和引用传递的概念了。这个问题向来是颇有争议的。

大家都知道，在JAVA中变量有以下两种：

基本类型变量，包括char、byte、short、int、long、float、double、boolean。

引用类型变量，包括类、接口、数组（基本类型数组和对象数组）。

当基本类型的变量被当作参数传递给方法时，JAVA虚拟机所做的工作是把这个值拷贝了一份，然后把拷贝后的值传递到了方法的内部。因此在上面的例子中，我们回头来看看这个方法：

Java代码

// 为方法参数重新赋值   

public   void change( int i) {  

    i = 5 ;  

}  

Java代码

// 为方法参数重新赋值  

public void change(int i) {  

    i = 5;  

}

// 为方法参数重新赋值

public void change(int i) {

   i = 5;

}

在这个方法被调用时，变量i和ParamTest型对象t的属性num具有相同的值，却是两个不同变量。变量i是由JAVA虚拟机创建的作用域在 change(int i)方法内的局部变量，在这个方法执行完毕后，它的生命周期就结束了。在JAVA虚拟机中，它们是以类似如下的方式存储的：

很明显，在基本类型被作为参数传递给方式时，是值传递，在整个过程中根本没有牵扯到引用这个概念。这也是大家所公认的。对于布尔型变量当然也是如此，请看下面的例子：

Java代码

public   class BooleanTest {  

    // 布尔型值   

    boolean bool = true ;  

 

    // 为布尔型参数重新赋值   

    public   void change( boolean b) {  

        b = false ;  

    }  

 

    // 对布尔型参数进行运算   

    public   void calculate( boolean b) {  

        b = b && false ;  

        // 为了方便对比，将运算结果输出   

        System.out.println("b运算后的值：" + b);  

    }  

 

    public   static   void main(String[] args) {  

        BooleanTest t = new BooleanTest();  

 

        System.out.println("参数--布尔型" );  

        System.out.println("原有的值：" + t.bool);  

        // 为布尔型参数重新赋值   

        t.change(t.bool);  

        System.out.println("赋值之后：" + t.bool);  

 

        // 改变布尔型参数的值   

        t.calculate(t.bool);  

        System.out.println("运算之后：" + t.bool);  

    }  

}  

Java代码

public class BooleanTest {  

    // 布尔型值  

    boolean bool = true;  

    // 为布尔型参数重新赋值  

    public void change(boolean b) {  

        b = false;  

    }  

    // 对布尔型参数进行运算  

    public void calculate(boolean b) {  

        b = b && false;  

        // 为了方便对比，将运算结果输出  

        System.out.println("b运算后的值：" + b);  

    }  

    public static void main(String[] args) {  

        BooleanTest t = new BooleanTest();  

        System.out.println("参数--布尔型");  

        System.out.println("原有的值：" + t.bool);  

        // 为布尔型参数重新赋值  

        t.change(t.bool);  

        System.out.println("赋值之后：" + t.bool);  

        // 改变布尔型参数的值  

        t.calculate(t.bool);  

        System.out.println("运算之后：" + t.bool);  

    }  

}

public class BooleanTest {

// 布尔型值

boolean bool = true;

// 为布尔型参数重新赋值

public void change(boolean b) {

   b = false;

}

// 对布尔型参数进行运算

public void calculate(boolean b) {

   b = b && false;

   // 为了方便对比，将运算结果输出

   System.out.println("b运算后的值：" + b);

}

public static void main(String[] args) {

   BooleanTest t = new BooleanTest();

   System.out.println("参数--布尔型");

   System.out.println("原有的值：" + t.bool);

   // 为布尔型参数重新赋值

   t.change(t.bool);

   System.out.println("赋值之后：" + t.bool);

   // 改变布尔型参数的值

   t.calculate(t.bool);

   System.out.println("运算之后：" + t.bool);

}

}

输出结果如下：

参数--布尔型

原有的值：true

赋值之后：true

b运算后的值：false

运算之后：true

那么当引用型变量被当作参数传递给方法时JAVA虚拟机又是怎样处理的呢？同样，它会拷贝一份这个变量所持有的引用，然后把它传递给JAVA虚拟机为方法创建的局部变量，从而这两个变量指向了同一个对象。在篇首所举的示例中，ParamTest类型变量t和局部变量pt在JAVA虚拟机中是以如下的方式存储的：

有一种说法是当一个对象或引用类型变量被当作参数传递时，也是值传递，这个值就是对象的引用，因此JAVA中只有值传递，没有引用传递。还有一种说法是引用可以看作是对象的别名，当对象被当作参数传递给方法时，传递的是对象的引用，因此是引用传递。这两种观点各有支持者，但是前一种观点被绝大多数人所接受，其中有《Core Java》一书的作者，以及JAVA的创造者James Gosling，而《Thinking in Java》一书的作者Bruce Eckel则站在了中立的立场上。

我个人认为值传递中的值指的是基本类型的数值，即使对于布尔型，虽然它的表现形式为true和false，但是在栈中，它仍然是以数值形式保存的，即0表示false，其它数值表示true。而引用是我们用来操作对象的工具，它包含了对象在堆中保存地址的信息。即使在被作为参数传递给方法时，实际上传递的是它的拷贝，但那仍是引用。因此，用引用传递来区别与值传递，概念上更加清晰。

最后我们得出如下的结论：

基本类型和基本类型变量被当作参数传递给方法时，是值传递。在方法实体中，无法给原变量重新赋值，也无法改变它的值。

对象和引用型变量被当作参数传递给方法时，在方法实体中，无法给原变量重新赋值，但是可以改变它所指向对象的属性。至于到底它是值传递还是引用传递，这并不重要，重要的是我们要清楚当一个引用被作为参数传递给一个方法时，在这个方法体内会发生什么。

注意：这里引用传递只是一种借用c的说法，其实java中只有值传递。