文章内容为转载，转载自公众号Hollis关于我要彻底给你讲清楚，Java就是值传递，不接受争辩的那种！

• 原文链接：我要彻底给你讲清楚，Java就是值传递，不接受争辩的那种！
• 知乎回答链接：Java 到底是值传递还是引用传递？
• 应届生/社招面试最爱问的几道Java基础问题
• 知乎回答链接：String str = “Hello”，到底有没有在堆中创建对象？
• 原文链接：请别再拿“String s = new String(“xyz”);创建了多少个String实例”来面试了吧

Java中的参数传递，到底是值传递还是引用传递？

结论：Java只有值传递，没有引用传递！

错误理解一：值传递和引用传递，区分的条件是传递的内容，如果是个值，就是值传递。如果是个引用，就是引用传递。

错误理解二：Java是引用传递。

错误理解三：传递的参数如果是普通类型，那就是值传递，如果是对象，那就是引用传递。

实参与形参

我们都知道，在Java中定义方法的时候是可以定义参数的。比如ava中的main方法，public static void main(String[] args)，这里面的args就是参数。参数在程序语言中分为形式参数和实际参数。

形式参数：是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。

实际参数：在调用有参函数时，主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时，函数名后面括号中的参数称为“实际参数”。

简单举个例子：

实际参数是调用有参方法的时候真正传递的内容，而形式参数是用于接收实参内容的参数。

基本类型与引用类型

int num = 10;
String str = "hello";

如图所示，num 是基本类型，值就直接保存在变量中。而 str是引用类型，变量中保存的只是实际对象的地址。一般称这种变量为 “引用”，引用指向实际对象，实际对象中保存着内容。

赋值运算符“=”的作用

num = 20;
str = "java";

对于基本类型 num，赋值运算符会直接改变变量的值，原来的值被覆盖掉。

对于引用类型 str，赋值运算符会改变引用中所保存的地址，原来的地址被覆盖掉。但是原来的对象不会被改变（重要）。

如上图所示，“hello” 字符串对象没有被改变。（没有被任何引用所指向的对象是垃圾，会被垃圾回收器GC回收）

值传递与引用传递

上面提到了，当我们调用一个有参函数的时候，会把实际参数传递给形式参数。但是，在程序语言中，这个传递过程中传递的两种情况，即值传递和引用传递。我们来看下程序语言中是如何定义和区分值传递和引用传递的

值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

• 值传递：将参数复制一份，修改形参不会对实参造成影响
• 引用传递：将实参的地址传递给形参，修改形参也就是在修改实参

我们来测试几段代码：

上面的代码中，我们在 pass 方法中修改了参数 j 的值，然后分别在 pass 方法和 main 方法中打印参数的值。输出结果如下：

print in pass , j is 20

print in main , i is 10

可见，pass 方法内部对 name 的值的修改并没有改变实际参数 i 的值。那么，按照上面的定义，有人得到结论：Java 的方法传递是值传递。

但是，很快就有人提出质疑了（哈哈，所以，不要轻易下结论咯。）。然后，他们会给出以下代码：

同样是一个 pass 方法，同样是在 pass 方法内修改参数的值。输出结果如下：

print in pass , User{name='Tom', sex='man'}
print in main , User{name='Tom', sex='man'}

经过 pass 方法执行后，实参的值竟然被改变了，那按照上面的引用传递的定义，实际参数的值被改变了，这不就是引用传递了么。于是，根据上面的两段代码，有人得出一个新的结论：Java 的方法中，在传递普通类型的时候是值传递，在传递对象类型的时候是引用传递。

但是，这种表述仍然是错误的。不信你看下面这个参数类型为引用类型的参数传递：

print in pass , Tom
print in main , Mr.Q

那么，问题来了。String是引用类型，new String("Mr.Q")在堆上创建了对象，name指向了Mr.Q的引用。那按照上面来说，应该是引用传递了，输出的结果应该pass和main是相同的，可是，为什么会不同呢？

这又作何解释呢？同样传递了一个对象，但是原始参数的值并没有被修改，难道传递对象又变成值传递了？

其实，是传递的地址值发生了改变

String类型在值传递和引用传递问题中比较特殊，为什么说特殊呢，因为对于一些常量字符串的创建，只要判断对象在堆中不存在，便会创建一个新的，如果是创建新对象，那么引用地址都会变。我们可以通过一个简单的例子来解释下：

a是：hello --- b是：你好

String a = “hello”; 在 String 池中检查并创建一个常量：“hello”，给 a 分配一个栈内存，在此存储常量 hello 的地址。

String b= a; 给 b 分配一个栈内存，在此存储常量 hello 的地址。相当于 a 把自己持有的地址，复制给了 b。

b = “你好”; 在 String 池中检查是否有 “你好” 的常量。

• 如果有，将 b 的地址指向 “你好” 的地址。
• 如果 String 池中没有 “你好” 常量，在堆内存中创建 “你好” 常量，并将 b 地址指向 “你好”。

我们再来看一个反例，来验证 “Java中参数传递 没有引用传递”

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student s1 = new Student("小张");
        Student s2 = new Student("小李");
        Test.swap(s1, s2);
        System.out.println("s1:" + s1.getName());
        System.out.println("s2:" + s2.getName());
    }

    public static void swap(Student x, Student y) {
        Student temp = x;
        x = y;
        y = temp;
        System.out.println("x:" + x.getName());
        System.out.println("y:" + y.getName());
    }
}

结果：

x：小李
y：小张
s1：小张
s2：小李

方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap 方法的参数 x 和 y 被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝。

---

Java中的值传递

值传递和引用传递之前的区别到底是什么？

两者的最主要区别就是是直接传递的，还是传递的是一个副本

这里我们来举一个形象的例子。再来深入理解一下传值调用和传引用调用：

---

• 你有一把钥匙，当你的朋友想要去你家的时候，如果你直接把你的钥匙给他了，这就是引用传递。
• 这种情况下，如果他对这把钥匙做了什么事情，比如他在钥匙上刻下了自己名字，那么这把钥匙还给你的时候，你自己的钥匙上也会多出他刻的名字。

---

• 你有一把钥匙，当你的朋友想要去你家的时候，你复刻了一把新钥匙给他，自己的还在自己手里，这就是值传递。
• 这种情况下，他对这把钥匙做什么都不会影响你手里的这把钥匙。

---

那我们再说回到这段代码中：

print in pass , User{name='Tom', sex='man'}
print in main , User{name='Tom', sex='man'}

看看在调用中，到底发生了什么？

在参数传递的过程中，实际参数的地址0x666被拷贝给了形参。这个过程其实就是值传递(这个值，理解为引用的地址)，只不过传递的值得内容是对象的应用。

那为什么我们改了user中的属性的值，却对原来的user产生了影响呢？

其实，这个过程就好像是：你复制了一把你家里的钥匙给到你的朋友，他拿到钥匙以后，并没有在这把钥匙上做任何改动，而是通过钥匙打开了你家里的房门，进到屋里，把你家的电视给砸了。

这个过程，对你手里的钥匙来说，是没有影响的，但是你的钥匙对应的房子里面的内容却是被人改动了。

也就是说，Java对象的传递，是通过复制的方式把引用关系传递了，如果我们没有改引用关系，而是找到引用的地址，把里面的内容改了，是会对调用方有影响的，因为大家指向的是同一个共享对象。

那么，如果我们改动一下pass方法的内容：

上面的代码中，我们在pass方法中，重新new了一个user对象，并改变了他的值，输出结果如下：

print in pass , User{name='Tom'}
print in main , User{name='Mr.Q'}

也就是说，我把我的钥匙复制给了我的朋友，但是我立马换了我家的锁。因为一new就会在堆上开辟新空间，地址就发生了改变，此时的user不再指向0x666了，理解为我换锁了，朋友当然进不了我家，砸不了电视了。所以此时在pass方法中修改name，不会对我家造成任何影响。

上面这种传递是什么传递？肯定不是引用传递，如果是引用传递的话，在user = new User()的时候，实际参数的引用也应该改为指向0x999，但是实际上并没有。

通过概念我们也能知道，这里是把实际参数的引用的地址复制了一份，传递给了形式参数。所以，上面的参数其实是值传递，把实参对象引用的地址当做值传递给了形式参数。

---

所以，值传递和引用传递的区别并不是传递的内容，而是实参到底有没有被复制一份给形参。

在判断实参内容有没有受影响的时候，要看传的的是什么，如果你传递的是个地址，那么就看这个地址的变化会不会有影响，而不是看地址指向的对象的变化。

所以说，Java 中其实还是值传递，只不过对于对象参数，值的内容是对象的引用。

---

总结

无论是值传递还是引用传递，其实都是一种求值策略 (Evaluation strategy)。在求值策略中，还有一种叫做按共享传递 (call by sharing)。其实 Java 中的参数传递严格意义上说应该是按共享传递。

按共享传递，是指在调用函数时，传递给函数的是实参的地址的拷贝（如果实参在栈中，则直接拷贝该值）。

在函数内部对参数进行操作时，需要先拷贝的地址寻找到具体的值，再进行操作。

如果该值在栈中，那么因为是直接拷贝的值，所以函数内部对参数进行操作不会对外部变量产生影响。

如果原来拷贝的是原值在堆中的地址，那么需要先根据该地址找到堆中对应的位置，再进行操作。因为传递的是地址的拷贝，所以函数内对值的操作对外部变量是可见的。

简单点说，Java 中的传递，是值传递，而这个值，实际上是对象的引用。

• 传递的值在栈中，直接拷贝一份值传递，改变的形参不会对实参造成影响
• 传递的值在栈中存放的是地址（引用），先根据栈中的地址找到在堆上的值，然后把地址拷贝一份（拷贝的地址是一个值），此时形参和实参指向堆上同一个地址，形参的修改导致了实参的改变。

Java中的参数传递，是值传递!

Java只有值传递!

Java只有值传递!

Java只有值传递!

本人是刚开始学写博文，很多东西都是第一次接触嘛，哪里有写的不好的希望大家指出来，然后一起学习、一起进步，我也会坚持更新的！

如何用函数实现模块化设计？

问题一：为什么要用函数呢？

答：因为有时候程序需要多次实现某一个功能，就得重复编写实现此功能的代码，若利用函数实现某一特定的功能，就能减少重复编写程序段的工作量。

一、几点说明

1、一个C程序由多个程序模块组成，每一个程序模块作为一个源程序文件。这样便于分别编写和编译，提高效率。
2、源程序文件就是一个编译单位，在编译时以此为单位进行编译，而不是以函数为单位进行编译的。
3、从main函数开始，如遇函数调用，调用完后，返回main函数。
4、所有函数都是平行的，函数间可以相互调用，但不能调用main函数。

二、函数

（一）函数的分类

从形式上看，函数分为有参数函数和无参数函数两类。

（二）函数的定义

在C语言要求中，所有的函数必须“先定义，后使用”，定义时，应指定函数的 名字、类型 、功能和参数的名字及类型 （有参数函数才需要）

无参数函数

类型名 函数名（）
  {
  函数体
  }
如下：
int p_word（）//p_word()为自定义的函数
 {
 printf("word");
}//函数体

或者

类型名 函数名（void）
   函数体

有参数函数

类型名 函数名（形式参数）
{
函数体
} 
如下：
int max（int a,int b）
{
int c;
c=a>b ? a:b;//条件语句
return (c);
}

空函数的定义

空函数函数体是空的，调用时什么也不做，没有实际作用，但是可以先用空函数占一个位置，等以后扩充程序时再添加相应功能的函数。

定义如下：
void add（）
{}

三、函数调用

函数调用，简单的说，就是暂时跳转到另一个位置执行，并且在适当的位置的时候返回到原来的位置在往后执行。

1、调用无参数函数
2、调用有参数函数:函数名（实参）

如：
word（）；//调用无参数函数,直接写函数名（）
c=max(a,b);//调用有参数函数

（一）函数调用时数据的传递（虚实结合）

形式参数：定义函数时，括号中的变量名称
实际参数：函数调用时，括号中的参数（实际参数可以是常量、变量、表达式）

数据的传递过程：形参从实参得到一个值（或者说实参的值传递给形参），该值只在函数的调用期间有效,可参与运算。

（二）简单的总结一下变量的存储方式，后面会详细的总结知识点

有的变量在程序运行的整个过程中都是存在的，有的变量则是在调用时才临时分配存储单元，而调用结束后该存储单元就马上释放了，变量不存在了，例如函数的形参就是如此。

变量的存储方式分为 静态存储方式和动态存储方式

动态存储方式：由系统动态的分配存储空间（函数的形参）

静态存储方式：由系统静态的分配存储空间

（三）函数调用代码示例

题目：输入两个整数，求最大值，要求用函数来找到最大数

#include<stdio.h>
int main()
{
	int max(int x,int y);//先声明，后使用
	int a,b,c;
	printf("请输入两个整数：");
	scanf("%d,%d",&a,&b);
	c=max(a,b);//调用函数max
	printf("最大值是%d\n",c);
	return 0;
}
int max(int x, int y)
{
	int z;
	z=x>y?x:y;//把x,y中的最大值赋值给z
	return z; //z作为返回值带回给main()主函数; main()主函数;
}  

运行结果：

注意：
1、函数类型决定了返回值的类型，形参的类型，决定了值传递的类型（若实参的类型是浮点型，而在定义的时候 形参的类型是整型，那么实参的值传递给形参时要先转化成整型才传递给形参）。

例：

#include<stdio.h>
int main()
{
	int max(float x,float y);//先声明，后使用
	float a,b;
	int c;
	printf("请输入两个数：");
	scanf("%f %f",&a,&b);
	c=max(a,b);//调用函数max
	printf("最大值是%d\n",c);
	return 0;
}
int max(float x, float y)
{
	float z;
	z=x>y?x:y;//把x,y中的最大值赋值给z
	return z; //z作为返回值带回给main()主函数; main()主函数;
}

运行结果：

2、return语句中表达式的类型要和在定义函数时指定的函数类型一致。

3、函数调用的过程是单向的“值传递”，即实参的值传递给形参，形参的值改变不会影响实参的值改变。

四、函数的嵌套调用

题目: 输入4个整数,要求输出最大数,用函数嵌套来处理

#include <stdio.h>
int main ()
{
	int max_1(int x,int y,int z,int w); //max_1函数的声明 
	int a,b,c,d,max;
	printf("请输入4个整数：\n");
	scanf("%d %d %d %d",&a,&b,&c,&d);
	max=max_1(a,b,c,d); //调用函数max_1,实参a,b,c,d传递给max_1函数的形参x,y,z,w 
	printf("最大的数是：%d\n",max);
	return 0;
}


int max_1(int x,int y,int z,int w)//定义max_1函数 
{
int max_2(int x,int y);//max_2函数的声明 
int m;
m=max_2(x,y);//调用函数max_2;此时max_1的形参x=a,y=b,值a,b再传递给函数max_2的形参x,y 
m=max_2(m,z);//第二次调用max_2,实参m,z的值为，m=（a,b中的最大者） ，z=c 
m=max_2(m,w);//第三次调用max_2,实参m,w的值为，m=(a,b,c中的最大者)，w=d 
return m;//返回a,b,c,d,中的最大者 
}


int max_2(int x,int y)//函数max_2的声明 
{int z;
z=x>y?x:y;
return z;
}

在max_1函数中,三次调用max_2函数的语句可以用下面一行代替

int max_1(int x,int y,int z,int w)//定义max_1函数 
{
int max_2(int x,int y);
int m;
m=max_2(max_2(max_2(x,y),z),w);//用一行代替三次函数max_2的调用
return m;
}

下一篇:继续复习 函数的递归调用…

一、概念

1、形式参数：

就是在定义函数或过程的时候命名的参数。
通俗讲就是一个记号。

2、实际参数：

就是在执行时，调用函数或过程时，传递给函数或过程的参数。
通俗讲就是实际值。

3、参数：

就是一个变量，它随着使用者的不同而发生变化。
举个例子，在中学的时候学过sin(x)函数，这里的x就是形式参数，当你需要求1的正弦值时，你会使用sin(1)，这里的1就是实际参数。

4、形参和实参间的关系：

两者是在调用的时候进行结合的，通常实参会将取值传递给形参，形参去之后进行函数过程运算，然后可能将某些值经过参数或函数符号返回给调用者。

二、案例

/**
 * 形式参数和实际参数
 */
@Test
public static void main(String[] args) {
    /**
         * 形式参数
         *      a和b为变量，需要赋值才能计算，
         *      a、b没赋值之前没有值，
         *      这种情况，a、b叫做形式参数
         */
    int a,b;
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入参数a:");
    a = scanner.nextInt();
    System.out.println("请输入参数b:");
    b = scanner.nextInt();
    int c=a+b;
    System.out.println("a+b="+c);

    System.out.println("----------------------");

    /**
         * 实际参数
         *      x、y有值，
         *      计算z时，用的是x的值2、y的值3，
         *      这种有具体值的参数叫做实际参数
         */
    int x = 2;
    int y = 3;
    int z = x + y;
    System.out.println("x+y="+z);
}

控制台：

请输入参数a:
1
请输入参数b:
2
a+b=3
----------------------
x+y=5