java两种参数传递方式

 

目录

一、按值传递

二、按址传递

总结： 

java的参数传递方式有两种：

1. 按值传递
2. 按址传递（引用传递）

一、按值传递

方法操作的是参数变量（也就是原型变量的一个值的拷贝），改变的也只是原型变量的一个拷贝而已，而非变量本身，所以变量原型并不会随之改变。

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

举例：

package addr;

public class test1 { 

    public static void main(String[] args) { 
    	test1 test1 = new test1(); 
    	test1.A(); 
    } 


    private void A() { 
         String originalStr = "original"; 
         Change(originalStr); 
         System.out.println("调用方法后的字符串 ：" + originalStr); //拷贝，不变
    } 
    

    public void Change(String string) { 
         string = string + " is changed!"; 
         System.out.println("改变后的字符串: " + string); //方法内部，变

    } 
} 

运行结果：

结果解释：

方法调用的是String类型的对象，按值传递，即Change调用的是originalStr的一个拷贝，故在方法内部此拷贝值改变了，而不影响原始的originalStr值。

再举个栗子：

package addr;

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 main(String[] args){
    	//对于按值传递的参数，如果需要在方法调用以后修改参数的值，可以利用返回值来实现
        int m = 5;
        m = t1(m);//重新赋值，变
        System.out.println(m);
        String s1 = "abc";
        s1 = t2(s1);//重新赋值，变
        System.out.println(s1);
    }   
}

运行结果：

由上段代码可知：

处理按值传递的参数经过方法调用后值不变的问题，可以通过返回值来改变值。

二、按址传递

方法操作参数变量时是拷贝了变量的引用，而后通过引用找到变量（在这里是对象）的真正地址，并对其进行操作。因此方法改变参数变量的同时变量原型也会随之改变。

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

举个栗子： 

package zl;

public class test3{

    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);//string不变
        System.out.println(s1);
        int[] arr = {1,2,3,4};
        t3(arr);//数组变
        System.out.println(arr[0]);
    }   
   }

运行结果：

再举个栗子： 

package zl;

public class test4{
    public static int[] t3(int[] array){
        int[] newArray = new int[array.length];//创建新的数组
        System.arraycopy(array,0,newArray,0,array.length);//数据拷贝
        newArray[0] = 2;//newArray：{2,2,3,4}
        return newArray;
    }
    public static void main(String[] args){
        int[] arr = {1,2,3,4};
        for(int i=0;i<arr.length;i++)
        {
        	System.out.println(t3(arr)[i]);
        }
        System.out.println(arr[0]);//arr不变
    }   
}

运行结果：

结果解释：

 System.arraycopy(原数组,从元数据的起始位置开始,目标数组,目标数组的开始起始位置,要copy的数组的长度)：通过原数组的数据拷贝构造目标数组。

按理来说，数组按址传递应该会改变变量原型的值；但由于调用的方法中int[] newArray = new int[array.length];语句创建了新的数组对象，故调用方法时改变的是新创建数组的值，原始arr值不变。

再举个栗子：

package zl;

public class test5{

	//如果需要返回多个参数时，使用按址传递是一种不错的主意。
    public static void initArray(int[] array){
	      for(int i = 0;i < array.length;i++){
                array[i] = i;
        }
    }

    public static void main(String[] args){
          int[] arr = new int[10];
          initArray(arr);//数组，变
          for(int i = 0;i < a.length;i++){
        	  System.out.println(a[i]);
        }
    }
}

运行结果：

再举个栗子：

package addr;

public class test6 {
	
	public static void main(String[] args) {
        int i = 10;
        int j = 5;
        test6 t1 = new test6();
        System.out.println("i:" + i + " j:" + j);
        t1.swap1(i, j);
        System.out.println("i:" + i + " j:" + j);
        }

    public void swap1(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
        System.out.println("a:" + a + " b:" + b);    
     }
}

运行结果：

结果分析：

swap1交换方法并未起到作用，i和j的值并没有交换。 因为整型值是按值传递。

要想交换方法起作用，可通过以下方式：

package zl;

public class test7 {
	
	public static void main(String[] args) {
        int[] array = {10,5};
        test6 t2 = new test6();
        System.out.println("i:" + array[0] + " j:" + array[1]);
        t2.swap2(array);
        System.out.println("i:" + array[0] + " j:" + array[1]);
    }

    public void swap2(int[] arr) {
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
        System.out.println("a:" + arr[0] + " b:" + arr[1]);    
     }
}

运行结果：

• 总结： 

按值传递：

1. 方法操作的参数变量是原型变量的一个值的拷贝，调用方法后改变的是拷贝值，不会改变原型变量的值。
2. 适用范围：8种基本数据类型、String对象
3. 若想让方法起作用，可用返回值（如test2中）方式 或 将按值传递的对象变为按址传递的对象（如test7中）。

按址传递：

1. 方法操作的参数变量是拷贝了变量的引用，而后通过引用找到变量（在这里是对象）的真正地址，并对其进行操作。因此方法改变参数变量的同时变量原型也会随之改变。

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

3. 当方法中new了一个新对象，变量原型的值不会改变（如test4中）；当需要返回多个参数时，按址传递是很好的方式（如test5中）。

参考链接：https://www.cnblogs.com/King-boy/p/10776544.html，https://blog.csdn.net/qq_32405269/article/details/78374035

推荐文章：java方法参数的两种传递方式