一.为什么说Java中只有值传递？
对于java中的参数传递方式中是否有引用传递这个话题，很多的人都认为Java中有引用传递，但是我个人的看法是，Java中只有值传递，没有引用传递。
那么关于对象的传递怎么解释呢？难道对象不是一个引用传递吗?
对于这一点我的看法是，对象的传递只不过是将对象的地址值传递到方法里，只要你不改变这个地址值，那他就指向原来的引用不会改变，但是你一旦改变了这个地址值，那么你就改变了他的实际引用。那归根到底还不是值传递吗？只不过我普通类型传递的是copy后的普通类型的值，我引用传递的是一个copy的地址值而已。
当然我在举例子的时候还是将他们分开：
实际的例子如下：
1.值传递
package com.cjm.functionparameter; /**
* @author 程嘉明
* @version 创建时间：2018/8/9 10:18
* 函数得值传递
*/
public class Valuetransmit {
public static void main(String[] args) {
int num=0;//定义一个值
System.out.println("在main中定义的值为："+num);
fan(num);
System.out.println("在调用函数的值为："+num);
}
public static void fan(int num){
System.out.println("###########进入函数###########");
System.out.println("实参为："+num+"此时的值没有被改变！");
//修改函数的参数：
++num;
System.out.println("在函数中实参自增后的值为："+num);
System.out.println("###########退出函数###########");
}
}
可以看出值传递是不会改变他本身的值。
所以Java中你就无法使用一个函数将两个变量的值交换。
尝试如下：
package com.cjm.functionparameter; /**
* @author 程嘉明
* @version 创建时间：2018/8/9 10:35
*/
public class ChangeValue {
public static void main(String[] args) {
//定义两个变量
int num1=0;
int num2=1;
System.out.println("未经过函数的交换的值为："+"num1="+num1+"\tnum2="+num2);
change(num1,num2);
System.out.println("经过函数的交换后的值为："+"num1="+num1+"\tnum2="+num2);
}
//设置一个”交换函数“
public static void change(int num1,int num2){
int temp=num1;
num1=num2;
num2=temp;
}
}
失败了，Java不能替我们完成这一项任务，但这无伤大雅，因为我们并不想交换两个变量的值就去定义一个函数，这实在是小题大做了。
2.杠精们的"引用传递"
那么首先我需要一个对象，来检测一下在函数中的对象是否和外面的对象相同。
package com.cjm.functionparameter; /**
* @author 程嘉明
* @version 创建时间：2018/8/9 10:53
* 对象的判断函数实参对象，和传递对象是否相同
*/
public class ObjectJudge {
public static void main(String[] args) {
A a=new A(0);
System.out.println("main函数中的对象的哈希值为："+a.hashCode());
System.out.println();
fan(a);
}
public static void fan(A a){
System.out.println("函数中的对象的哈希值为："+a.hashCode());
}
}
class A{
int num;
public A(int num) {
this.num = num;
}
}
可以看出这两个引用指向的对象的哈希值是一样的，那么也就是说这两个引用指向的是同一个对象。
那么也是说我们在函数对对象a的操作也会影响外面的对象。
来看下面的操作：
package com.cjm.functionparameter;
/**
* @author 程嘉明
* @version 创建时间：2018/8/9 10:53
* 对象的判断函数实参对象，和传递对象是否相同
*/
public class ObjectJudge {
public static void main(String[] args) {
A a=new A(0);
System.out.println("main函数中的对象的哈希值为："+a.hashCode());
System.out.println("在main函数中的对象的num为："+a.num);
System.out.println("##########函数开始##########");
fan(a);
System.out.println("##########函数之后##########");
System.out.println("在main函数中的对象的num为："+a.num);
}
public static void fan(A a){
System.out.println("函数中的对象的哈希值为："+a.hashCode());
a.num=10;
System.out.println("在函数中的对象的num为："+a.num);
}
}
class A{
int num;
public A(int num) {
this.num = num;
}
}
那么我们现在再来修改一下，将函数中的对象修改为其他的引用会发生什么
package com.cjm.functionparameter;
/**
* @author 程嘉明
* @version 创建时间：2018/8/9 10:53
* 对象的判断函数实参对象，和传递对象是否相同
*/
public class ObjectJudge {
public static void main(String[] args) {
A a=new A(0);
System.out.println("main函数中的对象的哈希值为："+a.hashCode());
System.out.println("在main函数中的对象的num为："+a.num);
System.out.println("##########函数开始##########");
fan(a);
System.out.println("##########函数之后##########");
System.out.println("在main函数中的对象的num为："+a.num);
}
public static void fan(A a){
System.out.println("为做改变前，函数中的对象的哈希值为："+a.hashCode());
a=new A(0);
System.out.println("做了重新赋值后，函数中的对象的哈希值为："+a.hashCode());
a.num=10;
System.out.println("在函数中的对象的num为："+a.num);
}
}
class A{
int num;
public A(int num) {
this.num = num;
}
}
现在就是我们将 实参重新赋值了一个新的对象，那么我们可以发现a指向的对象已经改变，所以当我们对a进行操作时，main函数中的实参就不会改变了。
到这里我们可以总结出：Java中的参数传递就是值传递，只不过普通类型传递的是copy后的值，而对象传递的就是地址值，只要你不去改变地址值，那么你在函数中对对象的操作也会影响原来的对象。
那么现在又来了一个问题：
3.Java能不能交换两个对象呢？
直接上代码：
package com.cjm.functionparameter; /**
* @author 程嘉明
* @version 创建时间：2018/8/9 12:26
*/
public class ChangeObject {
public static void main(String[] args) {
A a1=new A(10);
A a2=new A(20);
System.out.println("在执行函数前：a1的值为："+a1.num+"a2的值为："+a2.num);
change(a1,a2);
System.out.println("在执行函数后：a1的值为："+a1.num+"a2的值为："+a2.num);
}
public static void change(A a1,A a2){
A temp=a1;
a1=a2;
a2=temp;
}
}
然而并没有交换。。。。。。
我们输出所有的哈希码：
package com.cjm.functionparameter; /**
* @author 程嘉明
* @version 创建时间：2018/8/9 12:26
*/
public class ChangeObject {
public static void main(String[] args) {
A a1=new A(10);
A a2=new A(20);
System.out.println("在执行函数前：a1的值为："+a1.num+"a2的值为："+a2.num);
System.out.println("main函数中的a1的哈希码为："+a1.hashCode()+"a2的哈希码为："+a2.hashCode());
System.out.println("############执行函数#############");
System.out.println();
change(a1,a2);
System.out.println("在执行函数后：a1的值为："+a1.num+"a2的值为："+a2.num);
System.out.println("############函数之后#############");
}
public static void change(A a1,A a2){
System.out.println("函数刚开始时的a1的哈希码为："+a1.hashCode()+"a2的哈希码为："+a2.hashCode());
A temp=a1;
a1=a2;
a2=temp;
System.out.println("函数中的a1的哈希码为："+a1.hashCode()+"a2的哈希码为："+a2.hashCode());
}
}
似乎没有问题：因为在函数中a1和a2的地址值是改变了，但是这是一个地址值，你修改了他有什么作用呢？
图解如下：
开始时：
在函数中进行交换：
那么此时main函数中的对象会交换吗？当然不会！所以还是那一句话：
到这里我们可以总结出：Java中的参数传递就是值传递，只不过普通类型传递的是copy后的值，而对象传递的就是地址值，只要你不去改变地址值，那么你在函数中对对象的操作也会影响原来的对象。
4.针对一个特殊类String类
为什么说这个String特殊呢？
因为：面试题里面都是拿他做例子所以他特殊（#手动滑稽）
当然不是了，主要是因为String是final类不能在对象上去修改，只能new一个新的对象。
所以看看下面的代码你就知道我的意思了：
当你的参数拼接后其实已经改变了你这个对象的引用。而你的形参的类型是final的这也就代表着你不能改变他的引用对像。
讲这个似乎对我们这个没有帮助，那么我们来看看下面的代码：
package com.cjm.functionparameter; /**
* @author 程嘉明
* @version 创建时间：2018/8/9 14:08
* String类型是否能够在拼接符的作用下不改变对象
*/
public class StringAdd {
public static void main(String[] args) {
String str="101010";
System.out.println("在没有进入函数之前String的对象的哈希码为："+str.hashCode());
stringChange(str);
System.out.println("str经过函数的值为：");
System.out.println(str);
}
public static void stringChange(String str){
System.out.println("进入函数后没有修改String之前的Str的哈希码为："+str.hashCode());
str+="aaaa";
System.out.println("进入函数后修改String之后的Str的哈希码为："+str.hashCode());
}
}
在修改时我们的值没有发生改变。
就是拼接后你的String对象已经改变，接下来你所做的就与main函数里的str变量没有关系了。