java中参数传递实例

//在函数中传递基本数据类型，     
       2. public class Test {  
       4.     public static void change(int i, int j) {     
       5.         int temp = i;     
       6.         i = j;     
       7.         j = temp;     
       8.     }    
      10.     public static void main(String[] args) {     
      11.         int a = 3;    
      12.         int b = 4;    
      13.         change(a, b);     
      15.         System.out.println("a=" + a);     
      16.         System.out.println("b=" + b);     
      17.     }    
      18. }     
      19.     
      20. 结果为:    
      21. a=3      
      22. b=4    
      23. 缘由就是 参数中传递的是 基本类型 a 和 b 的拷贝,在函数中交换的也是那份拷贝的值 而不是数据自己;    

=====================================================

 例4: 
    String 不改变，数组改变  
    Java代码 复制代码  
       1.     
       2. public class Example {     
       3.     String str = new String("good");     
       4.     
       5.     char[] ch = { 'a', 'b', 'c' };     
       6.   
       7.     public static void main(String args[]) {  
       8.         Example ex = new Example();    
       9.         ex.change(ex.str, ex.ch);     
      10.         System.out.print(ex.str + " and ");    
      11.         System.out.println(ex.ch);     
      12.     }     
      13.     
      14.     public void change(String str, char ch[]) {    
      15.         str = "test ok";    
      16.         ch[0] = 'g';     
      17.     }     
      18. }      
      19. 程序3输出的是 good and gbc.

=============================================================

传值---传递基本数据类型参数 
Java代码
    public    class           PassValue{ 
        static void exchange(int a, int b){//静态方法，交换a,b的值 
            int temp;
            temp = a;  
            a = b;  
            b = temp;  
        } 
        public static void main(String[] args){  
           int i = 10; 
           int j = 100;  
           System.out.println("before call: " + "i=" + i + "\t" + "j = " + j);//调用前  
            exchange(i, j);                                                                    //值传递，main方法只能调用静态方法 
            System.out.println("after call: " + "i=" + i + "\t" + "j = " + j);//调用后 
        }  
    }  
    运行结果：
            before call: i = 10        j = 100  
            after    call: i = 10        j = 100  

说明：调用exchange(i, j)时，实际参数i，j分别把值传递给相应的形式参数a，b,在执行方法exchange()时，形式参数a，b的值的改变不影响实际参数i和j的值，i和j的值在调用先后并没改变。

======================================================

引用传递---对象做为参数
若是在方法中把对象（或数组）做为参数，方法调用时，参数传递的是对象的引用（地址），即在方法调用时，实际参数把对对象的引用（地址）传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象（数组），方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。 
Java代码  
    class Book{ 
        String name;  
        private float price;  
        Book(String n,    float p ){                //构造方法 
            name = n;
            price = p; 
        }  
        static  void  change(Book a_book,    String n,    float p){    //静态方法，对象做为参数  
                a_book.name = n;  
                a_book.price = p;  
        }  
        public void output(){        //实例方法，输出对象信息 
            System.out.println("name: " + name + "\t" + "price: " + price);
        }  
    }  
     public class PassAddr{  
        public static void main(String [] args){ 
            Book b = new Book("java2",    32.5f); 
            System.out.print("before call:\t");        //调用前  
            b.output(); 
            b.change(b,    "c++",    45.5f);            //引用传递，传递对象b的引用，修改对象b的值  
            System.out.print("after call:\t");            //调用后  
            b.output(); 
        } 
    }  
    运行结果：  
            before    call:    name:java2        price:32.5  
            after       call:    name:c++          price:45.5 

说明：调用change(b,"c++",45.5f)时，对象b做为实际参数，把引用传递给相应的形式参数a_book,实际上a_book也指向同一个对象，即该对象有两个引用名：b和a_book。在执行方法change()时，对形式参数a_book操做就是对实际参数b的操做。

=====================================================

//对象的引用(不是引用的副本)是永远不会改变的
       2. class A {    
       3.     int i = 0;     
       4. }   
       5.     
       6.     
       7. public class Test {    
       8.     
       9.     public static void add(A a) {     
      10.         a = new A();     
      11.         a.i++;     
      12.     }   
      13.          
      14.     public static void main(String args[]) {     
      15.         A a = new A();    
      16.         add(a);    
      17.         System.out.println(a.i);  
      18.     }    
      19. }     
      20. 
      21. 输出结果是0    
      22. 在该程序中，对象的引用指向的是A ,而在change方法中，传递的引用的一份副本则指向了一个新的OBJECT，并对其进行操做。     
      23. 而原来的A对象并无发生任何变化。 引用指向的是仍是原来的A对象。 

====================================================

 //传的是引用数据类型     
       2. public class Test {    
       4.     public static void change(int[] counts) {   
       5.         counts[0] = 6;     
       6.         System.out.println(counts[0]);     
       7.     }     
       9.     public static void main(String[] args) {   
      10.         int[] count = { 1, 2, 3, 4, 5 };  
      11.         change(count);    
      12.     }     
      13. }     
      14.     运行结果是：6
      15. 在方法中 传递引用数据类型int数组，实际上传递的是其引用count的拷贝，他们都指向数组对象，在方法中能够改变数组对象的内容。即:对复制的引用所调用的方法更改的是同一个对象。