java方法中的参数传值

refer to :

http://xiaolu123456.iteye.com/blog/768520

今天看了一下别人到blog关于java方法中到参数传值到问题，突然仔细想了一下，原来自己一直也没弄懂。看下面到例子：

Java代码  

1. public class cl{  
2.      private  int a=3,b=4;  
3.        
4.      public  void swap(int a,int b){  
5.        int c=9;  
6.        a=c;   
7.        System.out.println("=====inner a======="+a);  
8.        }  
9.          
10.          
11.      public static void main(String args[]){  
12.         cl c=new cl();  
13.         c.swap(c.a,c.b);    //形参，与实参。  
14.          System.out.println(c.a);  
15.           }  
16.         
17.       
18. }  

程序运行到结果是：
=====inner a=======9；
3；
这个是参数直接传递基本类型的例子。
还有一个例子是参数传递对象的：

Java代码  

1. public void call(Test t) {   
2.           Test t2 = new Test();   
3.           t2.setName("cba');   
4.           t.setName("abc");   
5.           t = t2 ;   
6.        }   
7.   
8.        public static void main(String[] arg) {   
9.           Test obj = new Test();   
10.           call (obj) ;   
11.           System.out.println("obj"+obj.getName());   
12.        }   

程序运行到结果是：
abc
两个传参一个是基本类型，一个对象，总结网上很多说法，但是还是没有清楚到给出它们的
底层内存分配运行是的状况。但是有如下共识：
对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。
方法体内对参数进行运算，不影响原有变量的值。
方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。

再例子：
public class MyMap extends HashMap{
   public static void main(String[] arg) {  

        MyTest obj = new MyTest();
        System.out.println("obj hash code:"+obj.hashCode());
        call (obj) ;   
               System.out.println("obj"+obj.getName());
    }
    
    static public MyTest call(MyTest t){   
        MyTest t2 = new MyTest();   
        t2.setName("cba");
        t.setName("abc");   t 的值改变
        System.out.println("t2 hash code:"+t2.hashCode());
        System.out.println("t hash code:"+t.hashCode());
        t = t2 ;          //局部起作用
        return t2;
     }   

     


}

    class MyTest{
    String    name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
        }
    输出：
obj hash code:8567361
t2 hash code:9584176    函数内的局部对象
t hash code:8567361  函数内接收到的形参对象，和外面（第一行）一样
obj   abc




对jvm的具体分配目前还不懂，但是目前我们可以这样理解，对传递基本类型的时候，我们把形参当成一个局部变量，传递基本类型的时候，就是传递值的拷贝，对形参进行赋值，只影响到局部变量，离开作用域，该局部变量失效。对传递引用类型的时候，一样形参是个局部变量，传递引用类型，传递是引用的一个拷贝。对形参进行赋值，也同样改变了该局部变量的引用地址。离开作用域，局部变量失效，原来的变量没有任何变化，对下面的这中情况，可能有疑问。例如：

Java代码  

1. public static void swap(int a[])  
2.  {  
3.   
4.    a[0]=9999;  
5.  }  
6.    
7.  public static void main(String args[])  
8.  {  
9.        
10.     int c[]={3};  
11.     swap(c);  
12.     System.out.println(c[0]);  
13.  }  

运行的结果是，9999，对此解释是，数组是对象，我们在方法中改变的是引用所指向的对象的值，所以局部变量即使失效后，它堆上的内容发生改变了，所以到后来就变了，所以我们对对象传递参数时，必须很清楚的知道自己改变了的是对象的引用改变了，还是在堆上的引用所指向的对象的值改变了，这个很重要，因为这样才能达到我们的目的了！

分享到：