【转载】Java语言中的参数传递

   在实际的开发过程中，方法调用是一种很常见的操作，在方法调用中，关于参数的处理可能很多进行实际开发的程序员都不一定理解的很清楚，下面系统的介绍一下Java语言中参数传递的规则，以及和参数传递相关的一些问题。

         和其它程序设计语言类似，Java语言的参数传递也分为两种：

1、 按值传递(by value)

适用范围：8种基本数据类型、String对象

特点：在内存中复制一份数据，把复制后的数据传递到方法内部

作用：在方法内部改变参数的值，外部数据不会跟着发生改变

2、 按址传递(by address)

适用范围：数组、除String以外的其他所有类型的对象

特点：将对象的地址传递到方法内部

作用：在方法内部修改对象的内容，外部数据也会跟着发生改变

基础示例代码：

   

Java代码

1. public class Test1{   
2.     public static void t1(int n){   
3.         n = 10;   
4.     }   
5.     public static void t2(String s){   
6.                s = "123";   
7.     }   
8.     public static void t3(int[] array){   
9.         array[0] = 2;   
10.     }   
11.     public static void main(String[] args){   
12.            int m = 5;   
13.         t1(m);   
14.         System.out.println(m);   
15.         String s1 = "abc";   
16.         t2(s1);   
17.         System.out.println(s1);   
18.            int[] arr = {1,2,3,4};   
19.         t3(arr);   
20.         System.out.println(arr[0]);   
21.     }       
22.    }  

public class Test1{
    public static void t1(int n){
        n = 10;
    }
    public static void t2(String s){
               s = "123";
    }
    public static void t3(int[] array){
        array[0] = 2;
    }
    public static void main(String[] args){
           int m = 5;
        t1(m);
        System.out.println(m);
        String s1 = "abc";
        t2(s1);
        System.out.println(s1);
           int[] arr = {1,2,3,4};
        t3(arr);
        System.out.println(arr[0]);
    }    
   }

 

         按照上面的参数传递规则，该代码的输出结果应该是：5 abc 2。因为int类型是按值传递，所以把参数m传递到方法t1时，相当于又复制了一份m的值，在方法t 1内部修改的是复制后的值，所以m的值不变，s1的输出和m类似。而arr是数组，属于按址传递，也就是把arr的地址传递到了方法t3内部，在方法t3内部修改数组中的值时，原来的内容也发生改变。

         以上特性是Java语言中的规定，在语法上无法指定参数传递是按值传递还是按址传递，但是可以通过下面的变换实现：

1、 对于按值传递的参数，如果需要在方法调用以后修改参数的值，可以利用返回值来实现。

2、 对于按值传递的参数，如果需要在方法内部修改时原来的参数不改变，则可以在方法内部重新创建该对象实现。

示例代码如下：

Java代码

1. public class Test2{   
2.     public static int t1(int n){   
3.         n = 10;   
4.         return n;   
5.     }   
6.     public static String t2(String s){   
7.                   s = "123";   
8.                   return  s;   
9.     }   
10.     public static void t3(int[] array){   
11.         //创建新的数组并赋值   
12.         int[] newArray = new int[array.length];   
13.         //数据拷贝   
14.        System.arraycopy(array,0,newArray,0,array.length);   
15.         newArray[0] = 2;   
16.     }   
17.     public static void main(String[] args){   
18.                   int m = 5;   
19.         //重新赋值   
20.         m = t1(m);   
21.         System.out.println(m);   
22.         String s1 = "abc";   
23.         //重新赋值   
24.         s1 = t2(s1);   
25.         System.out.println(s1);   
26.                   int[] arr = {1,2,3,4};   
27.         t3(arr);   
28.         System.out.println(arr[0]);   
29.     }       
30. }  

public class Test2{
    public static int t1(int n){
        n = 10;
        return n;
    }
    public static String t2(String s){
                  s = "123";
                  return  s;
    }
    public static void t3(int[] array){
        //创建新的数组并赋值
        int[] newArray = new int[array.length];
        //数据拷贝
       System.arraycopy(array,0,newArray,0,array.length);
        newArray[0] = 2;
    }
    public static void main(String[] args){
                  int m = 5;
        //重新赋值
        m = t1(m);
        System.out.println(m);
        String s1 = "abc";
        //重新赋值
        s1 = t2(s1);
        System.out.println(s1);
                  int[] arr = {1,2,3,4};
        t3(arr);
        System.out.println(arr[0]);
    }    
}

 

这样，程序的输出结果就将是：10 123    1。

在实际的程序开发中，可以根据需要使用类似的结构来进行实现。

         下面再介绍一个参数传递的常见应用，利用参数传递实现返回值，这样的功能在IO类设计的read方法中大量使用。示例代码如下：

Java代码

1. public class Test3{   
2.     public static void initArray(int[] array){   
3.                   for(int i = 0;i < array.length;i++){   
4.                             array[i] = i;   
5.         }   
6.     }   
7.     public static void main(String[] args){   
8.                   int[] a = new int[10];   
9.         initArray(a);   
10.         for(int i = 0;i < a.length;i++){   
11.                             System.out.println(a[i]);   
12.         }   
13.     }   
14. }  

public class Test3{
    public static void initArray(int[] array){
                  for(int i = 0;i < array.length;i++){
                            array[i] = i;
        }
    }
    public static void main(String[] args){
                  int[] a = new int[10];
        initArray(a);
        for(int i = 0;i < a.length;i++){
                            System.out.println(a[i]);
        }
    }
}

 

         在该示例代码中，在initArray方法内部修改了数组的值以后，外部数组a的值也会发生改变，间接实现了返回值的效果。当然，在该示例代码中，因为只返回一个参数，所以作用体现的不明显，如果需要返回多个参数时，使用按址传递是一种不错的主意。

    因时间仓促，疏漏之处难免，请大家积极补充和指正。