What is parameter passing? What is his use?

1 Overview

1. What is parameter passing?

The process of passing data to formal parameters when calling a method is called parameter passing. There are two modes of transfer in programming languages: transfer by value and transfer by reference. It must be emphasized that the two delivery methods mentioned here are not limited to the delivery methods used in java, but are the delivery methods that appear in many programming languages ​​​​including java.

2. Variable type

In java, we call variables pointing to basic type data primitive variables, and variables pointing to objects called reference variables.

2. Value passing

1. What is value passing?

Pass a copy of the variable into the method. Operations inside and outside the method are isolated. Operations on variables within the method will not be reflected in variables outside the method.

2. Original variable

    public void change(int b) {
        b = 7;
    }

    @Testpublic void testBasic() {int a = 9;
        change(a);
        System.out.println(a);
    }

Actual output: 9

When passing parameters, according to the rules of value passing, variable b receives a copy of a, which also points to the literal value "9":

##Next, inside the method, assign a value of 7 to b, so that b points to 7. Since a and b are two independent variables, there is no reference and reference relationship between them, and a still points to 9. ：

##3.String

    public void change(String str01) {
        str01 = "baidu";
    }

    @Testpublic void testString() {
        String str = new String("www.baidu.com");
        change(str);
        System.out.println(str);
    }

Actual output: www.baidu.com

When passing parameters, str passes a copy of itself to str01, so that str01 also points to the heap storing "www.baidu.com" Object:

Assign a value to str01 inside the method, so that str01 points to "baidu" in the string constant pool in the method area ", str still points to "www.baidu.com" in the heap, str and str01 point to different objects, and do not affect each other:

One thing to note here: Java designs String as an immutable object, that is, once the literal value contained in the String object changes, Java will create a new object and point the variable to the new object.

4.StringBuilder

    public void change(StringBuilder builder01) {
        builder01.append(" World!");
    }

    @Testpublic void testStringBuilder() {
        StringBuilder builder = new StringBuilder("Hello");
        change(builder);
        System.out.println(builder);
    }

Actual output: Hello World!

After the parameter transfer is completed, the builder01 variable obtains a copy of the builder variable. The copy and the original variable point to the same object in the heap:

Inside the method, the variable builder does not point to a new object, but still points to the same object as builder, so when builder accesses the same object in the heap, the data changes:

5. Custom type

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

Actual output: 1

The execution process is the same as that of StringBuilder, so I won’t go into details here. Let’s make some changes to the above code, as follows:

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01=new MyInner();//使in01指向一个新的对象in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

实际输出：9

参数传递完成时，in01与in指向同一个对象，in01对对象的操作等同于in对对象的操作，接着在方法内部执行"in01=new MyInner();"，这样in01就指向了一个新的对象，in01所有的操作都与in无关了：

综合以上的运行结果与分析，可知java参数传递方式符合值传递。

 三 引用传递

1.什么是引用传递？

将变量自身的内存地址传入方法中，方法中的变量指向方法外的变量，在方法中对变量的操作就是对方法外变量的操作。

2.自定义类型

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01=new MyInner();//使in01指向一个新的对象in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

实际输出：9

如果采用引用传递，传递完成以后，in01指向in，对in01的操作就是对in的操作，in01指向对象2，那么in也指向对象2，输出1，与实际不符，所以不是采用引用传递。

不再一一分析其他变量类型，分析后可以发现，java在传递参数时采用的不是引用传递，而是值传递。

简单讲，值传递时方法内外是两个拥有同一指向的变量，引用传递时方法内外是同一个变量。

The above is the detailed content of What is parameter passing? What is his use?. For more information, please follow other related articles on the PHP Chinese website!