java形参和实参的三种传递方式（值传递，地址传递，引用传递）

博客

博客

值传递：对形参的修改不会影响到实参

引用传递：对形参的修改会影响实参

一、值传递

在主函数中

#include 
using namespace std;

void main()
{
	int i=10;
	int j=i;
	j=20;
	cout<<"i="<<i<<endl;
	cout<<"j="<<j<<endl;
	system("pause");
}

输出结果为：

因为在int j=i 时，这是一个开辟一个新内存，然后将i中的值复制到j中的过程。所以，j中的值改变不会引起i中的值的改变。

二、地址传递

代码如下：

#include 
using namespace std;

void main()
{
	int i=10;
	int *j=&i;
	*j=20;
	cout<<"i="<<i<<endl;
	cout<<"j="<<*j<<endl;
	system("pause");
}

输出结果为：

因为在 int *j=&i 时，这是一个开辟一个新内存，然后将i的地址的值传入到j中的过程。所以，*j =20就是访问j中地址（就是i的地址），将20赋值于其中，改变值（等于i=20）。

#include 
using namespace std;

void test(int *j)
{
	*j=20;
	cout<<"j="<<*j<<endl;
}

void main()
{
	int i=10;
	test(&i);
	cout<<"i="<<i<<endl;
	system("pause");
}

三、引用传递

代码如下：

```c
#include 
using namespace std;

void main()
{
	int i=10;
	int &j=i;
	j=20;
	cout<<"i="<<i<<endl;
	cout<<"j="<<j<<endl;
	system("pause");
}

输出结果为：

因为在 int &j=i 时，这是将i 重命名为 j ，改变 j 的值等同改变 i 的值。

#include 
using namespace std;

void test(int &j)
{
	j=20;
	cout<<"j="<<j<<endl;
}

void main()
{
	int i=10;
	test(i);
	cout<<"i="<<i<<endl;
	system("pause");
}

总结
三种传递就是不一样的赋值结果，值传递，地址传递，引用传递分别为，j 复制 i 值，j 存入 i 的地址 ，i 重命名为 j 。

再次剖析值传递、引用传递

值传递、引用(地址)传递

public class MethodParamTest {
    public static void main(String[] args) {
        // 值传递
        int a = 10;
        change(a);
        System.out.println(a);// 10

        // 引用传递
        B b = new B();
        change(b);
        System.out.println(b.num);// 11
    }

    private static void change(int a) {
        ++a;
    }

    public static void change(B b){
        ++ b.num;
    }
}

class B{
    public int num = 10;
}

值传递分析

引用传递

再再次剖析值传递、引用传递

值传递：对形参的修改不会影响到实参

引用传递：对形参的修改会影响实参

public class A {
    public static void example(int a){//形参
        a=20;
        System.out.println("形参:"+a);
    }
    public static void main(String[] args) {
        int a=10;//实参
        System.out.println("实参:"+a);
        example(a);//调用带有形参的方法
        System.out.println("实参"+a);
    }
}

输出结果

在基本类型的参数传递中我们可以发现：

基本类型当中，虽然形参修改后相关方法的值改变了，但是并没有影响到后序实参打印出来的值。

由此我们可以判断，在Java中基本类型使用的是值传递

引用类型

public class Person {
    public String name;

    public Person(String name){
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    public static void main(String[] args) {
        Person p1=new Person("张三");
        System.out.println(p1.getName());
        p1.setName("李四");
        System.out.println(p1.getName());

        
    }
}

输出结果

在这里我们可以看到，在引用类型中将对象传递给方法中，在方法中改变形参的值，最后输出形参的值也会发生改变。

但是，这并不等于在引用类型中使用的是引用传递！

我们接着看

public class Person {
    public String name;

    public Person(String name){
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void change(){
        Person p1=new Person("李四");
        System.out.println(p1.getName());
    }

    public static void main(String[] args) {
        Person p1=new Person("张三");
        System.out.println(p1.getName());
        change();
        System.out.println(p1.getName());


    }

输出结果

这时需要了解JVM基本知识

在JVM中，栈存储对象，而堆存储基本数据类型和局部变量

基本类型的参数传递过程中

我们可以发现，在操作带有形参的方法时，实际上相当于实参复制一个副本传递给形参，这样在修改形参方法之后，是不会影响到实参的。

而引用类型中

我们可以看到，当形参方法适用对象时，实际上是实参复制的一个副本，这个副本和主体一样，都可以操作堆中的内容。

因此，当调用形参方法中对堆中内容进行修改时，main方法中所指向的值也会改变。

实际上修改的是堆中的内容而并非修改了实参

而我们对自定义方法中，重新对对象开堆，那么实际上副本就引用了另一个堆的内容。

也就变成了两个对象引用两个堆，对其中一个进行修改自然不会影响另一个

结论：

Java当中只有值传递，没有引用传递 在基本类型进行参数传递的过程中，是将值复制一份传递给形参 如果是引用类型，就将引用复制一份传递给形参
无论如何，都无法通过形参改变实参

哈哈最后一次补充

public class Test {
	public static void mian(String[] args){
		int i = 1;
		String str = "hello";
		Interger num = 2;
		int[] arr = {1,2,3,4,5};
		MyData my = new MyData();

		chang(i,str,num,arr,my);
		
		System.out.println("i = "+ i);
		System.out.println("str = "+ str);
		System.out.println("num = "+ num);
		System.out.println("arr = "+ arr.toString(arr));
		System.out.println("my.a = "+ my.a);
	}
	public static void change(int j,String s,Integer n,int[] a,MyData m){
		j += 1;
		s += "world";
		n += 1;
		a[0] += 1;
		m.a += 1;
	}
	class MyData{
		int a = 10;
	}
}

输出结果

i——基本数据类型——传递数据值——不变； str——引用数据类型（String）——传递地址值——不变；
num——引用数据类型（包装类）——传递地址值——不变； arr——引用数据类型（数组）——传递地址值——变；
my——引用数据类型（对象）——传递地址值——变；

方法的参数传递机制：

形参是基本数据类型 传递数据值

实参是引用数据类型 传递地址值 特殊的类型：String、包装类等对象不可变性

总结:

• 方法中的参数是形参，调用处传过来的参数是实参。
• java的基本数据类型是传值调用，对象引用类型是传引用。
• 当传值调用时，改变的是形参的值，并没有改变实参的值，实参的值可以传递给形参，但是，这个传递是单向的，形参不能传递回实参。
• 当引用调用时，如果参数是对象，无论对对象做了何种操作，都不会改变实参对象的引用，但是如果改变了对象的内容，就会改变实参对象的内容。