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的拷貝，他們都指向數組對象，在方法中能夠改變數組對象的內容。即:對複製的引用所調用的方法更改的是同一個對象。