Java中只有传值调用（值传递），没有传址调用（址传递或者引用传递）。所以在java方法中改变参数的值是不会改变原变量的值的，但为什么改变引用变量的属性值却可以呢？请看下面的解答。
 
java中的数据类型
 
Java中数据类型分为两大类：基本类型和引用类型。相应的，变量也分这两种类型：基本类型和引用类型。
 
基本类型的变量保存原始值，即它代表的值就是数值本身；
 
而引用类型的变量保存的值是引用值，"引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
 
基本类型包括：byte,short,int,long,char,float,double,Boolean,returnAddress。
 
引用类型包括：类、接口类型和数组。
 
java中只有值传递
 
在日常编码中，会经常看到如下现象：
 
1、对于基本类型参数，在方法体内对参数进行重新赋值，不会改变原有变量的值。
 
2、对于引用类型参数，在方法体内对参数进行重新赋予引用，不会改变原有变量所持有的引用。
 
3、方法体内对参数进行运算，不会改变原有变量的值。
 
4、对于引用类型参数，方法体内对参数所指向对象的属性进行操作，将改变原有变量所指向对象的属性值。
 
举个例子：
 
public class Main {

    private static void getMiddleOne(boolean b, Boolean boo, Boolean[] arr){

        b = true;

        boo = new Boolean(true);

        arr[0] = true;

    }

       //测试

    public static void main(String[] args) {

        boolean b = false;

        Boolean boo = new Boolean(false);

        Boolean[] arr = new Boolean[]{false};

        getMiddleOne(b, boo, arr);

        System.out.println(b);

        System.out.println(boo.toString());

        System.out.println(arr[0]);

        /**

        * output:

        * false

        * false

        * true

        */

    }

}
 
我们只要了解了下面两点就可以解答上面的现象了：
 
1、基本数据类型的值就是数值本身，所以示例中的b的值就是false；包装类因为会自动装箱拆箱，所以可以和基本类型一样处理，所以示例中boo的值就是false；数组是引用类型，所以arr的值就是指向该Boolean[]的引用。
 
2、java中只有值传递没有引用传递，所以传入getMiddleOne方法的三个参数分别是b的值拷贝, boo的值拷贝, arr的值拷贝。
 
通过上面两点就可以清楚了，getMiddleOne方法中执行的 b=true 和 boo = new Boolean(true) 都是把新值赋给了他们的拷贝，所以不改变原变量的值；同样，arr[0] = true 是把true复制给了arr的拷贝所指向的数组的第一个元素，arr的值和arr的拷贝的值都是该数组的引用，所以arr的拷贝所指向的数组和arr所指向的数组是同一个，所以改变arr的拷贝的数组的元素会同样影响到原变量arr。
 
总结
 
java中只有值传递，基本类型传递的是值的副本，引用类型传递的是引用的副本。
 
 

首先要明确的是JAVA中没有引用传递, 全部是按值调用
 
令大家所费解的 当对象引用作为参数时  函数为什么能修改真实的对象呢?这不是引用传递的特征吗?
 
尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为,
 
用白话解释就是:
 
引用传递指针时, 连函数操作的指针都是原来的指针,比如C++传入对象时直接用传入的指针操作
 
而JAVA的引用传进函数时 , 会复制一个引用与实参指向同一对象的引用, 操作的不是同一个引用,
 
如果还不明白区别再换种方式解释一次:
 
JAVA只有按值调用, 参数是什么都会复制一份再操作, 就算是对象的引用也会复制一份新的引用,只不过指向的是同一个对象
 
这种传参方式叫做按值传递, 传递的东西可以是引用(类似C++的指针)
 
如果是引用传递像C++传入指针不会再复制一份了,直接拿来用
 
 
 
如果再不明白也没关系,看看下面的例子和解释分析
 
举个例子:
 
 
输出结果:
 
 
也就说我们用一个函数修改了 传入的一个int变量和一个对象内容,
 
再输出int变量和对象内容时发现 ,int的没有改变,而 对象的内容改变了
 
 
 
这说明什么呢,说明像 int ,double等基本数据类型在参数传递时并没有传进变量本身,
 
而是创建了一个新的相同数值的变量, 函数修改这个新变量并没有影响原来变量的数值,这也是按值传递的特点
 
 
那为什么对象a的数据就改变了呢?
 
因为虽然也是按值传递, 复制了一份新的引用但是指向的对象是同一个,修改后会影响原对象
 
这种方式假如在函数内修改 a=null; 只是把复制的引用与对象的联系断开,不影响函数外与实际对象
 
 
 
 
这就是按值传递, 即使传的是引用也不是引用传递,
 
因为引用传递是不复制的,直接使用参数,如下图:
 
这时候函数把指针a=null就指针就置空了,函数外也无法再通过指针访问对象了
 
 
这样可以理解了吗,自我觉得足够明白了, 我如此深厚的画图功底都供出来了,再不明白就是在为难我胖虎!
 
水平有限, 可能有错误,敬请指出! 

C++与Java中的值传递和引用传递比较
 
开头先阐明一下我个人理解的值传递与引用传递。值传递，从字面上来说就是传递一个变量的值，其内在机制其实是在内存中复制一个全新的变量，内容与其一样而已，所以值传递前后往往涉及在两个不同语句块中的两个局部变量，这也是为什么对形参的操作无法对实参造成影响的根本原因。至于引用传递（更标准的叫法是传递引用），从字面来说传递的是一种引用。其内在机制就是形参作为一种引用值与实参共享内存地址空间。简单来说就是同一个内存地址有两个不同的名字。这也就是为什么在引用传递中，对形参的改变会对实参造成影响。（上述的影响不包括对变量重新赋予一个新的地址，这种情况下文会讨论）
 
下面进入正题。实际上，Java里并没有严格意义上的引用传递（或者可以说根本没有，一些书上明确写到只有值传递）。而C++中有值传递和引用传递两种模式。但是值得注意的是Java中值传递的概念与C++有很大的不同。
 
下面对数据类型进行分类讨论，浅析C++与Java中的值传递与引用传递的区别。
 
对于基本数据类型值，如int，double，float，char等：
 
在C++中，基本数据类型值有值传递和引用传递两种模式。值传递简单的将基本数据类型的值传递给函数的形式参数。例如某C++源代码中:
 
#include<iostream>
using namespace std;

void f(double a){a = 3.3}

int main(){
double b = 5.5;
f(b);
cout << b << endl;//5.5

return 0;
}
 
在主函数中调用函数f（b）时，先将返回地址压栈，然后函数f新创建了一个名为a的double类型的局部变量，并且将b的值复制给a。所以a，b具有不同的地址，但具有相同的内容（值）。正因为如此，在函数f中对a的任何赋值操作都影响不到主函数中b的值。
 
变量
内存地址
值
a
0x1234
5.5->3.3
b
0xabcd
5.5
而引用传递，如下C++源码：
 
#include<iostream>
using namespace std;

void f(double& a){a = 3.3}

int main(){
double b = 5.5;
f(b);
cout << b << endl;//3.3

return 0;
}
 
此时在主函数中调用函数f时，并不会为a创建新的内存地址空间，而是将a视为b的别名，共享内存地址，即a与b的指针指向同一内存地址。所以在函数f中对a的任何改变，都会对b产生相同的影响（因为涉及了同一内存地址上的操作）。
 
变量
内存地址
值
a
0x1234
5.5->3.3
b
0x1234
5.5->3.3
在Java中，基本类型值只有值传递。其机制与C++中基本数据类型值传递一致。
 
对于数组：
 
C++中，数组只有值传递一种模式（这里传递的是地址的值）。C++中的数组名实际上该数组的指针，指针指向该数组的第一个元素。例如在如下C++源码中：
 
#include<iostream>
using namespace std;

double c[2] = { 9.9,10.1 };

void f(double a[]) {
	a[1] = 3.3;  
	a = c;
}

int main() {
	double b[2] = {1.1,2.2};
	f(b);
	for (int i = 0; i < 2; i++) {
		cout << b[i] << " ";//1.1 3.3 
	}

	return 0;
}
 
当调用函数f（b）时，在函数f的栈帧中为形式参数a创建了一个内存地址（此地址与b不同）来存储实参b的值，这里b的值其实是数组第一个元素的地址，所以a中存储的内容是数组b第一个元素的地址。所以在函数f中对数组b的任何改变（除了改变b中存储的数组地址，下文解释），比如赋值等操作，都会对a产生相同的影响。然而改变b当中存储的数组地址却对a无影响，因为a与b本质上是两个不同的变量，在内存中有不同的地址，只不过他们存储的数组地址是相同的罢了。例如在函数f中：a = c ，这条语句将c赋给了形参a，但这对b是不产生影响的。
 
变量
内存地址
值
a
0x1234
0x1111->0x2222
b
0xabcd
0x1111
c
0x4321
0x2222
在Java中，数组只有值传递。其机制C++中数组值传递一致。
 
对于对象：
 
在C++中，对象有值传递和引用传递两种模式。
 
#include<iostream>
using namespace std;

class Circle {
public:
	int radius;
	Circle() {
		radius = 1;
	}

	Circle(int radius) {
		this->radius = radius;
	}
};

Circle a(5);

void f1(Circle c) {
	c.radius = 3;
	c = a;
}

void f2(Circle& c) {
	c.radius = 3;
}

void f3(Circle& c) {
	c = a;
}

int main() {
	Circle b;
	f1(b);
	cout << b.radius << endl;//1
	f2(b);
	cout << b.radius << endl;//3
	f3(b);
	cout << b.radius << endl;//5

	return 0;
}
 
调用函数f1（b）时，系统为对象c开了一块内存（b与c地址不同），并把b的内容复制给c。b和c是两个不同的对象，地址不同，但具有相同的内容。所以在函数f1中对c的任何操作都对b无影响。引用传递则创建一个变量别名c来与b共享内存地址，所以操作同步。
 
而在Java中，对象只有值传递。但与C++中值传递的机制有些不同。
 
class Circle{
	public int radius;
	public Circle() {
		radius = 1;
	}
}

public class Test {
	public static void main(String[] args) {
		Circle a = new Circle();
		f(a);
		System.out.println(a.radius);//5
	}
	
	public static void f(Circle b) {
		b.radius = 5;
		b = new Circle();
	}
}

 
当调用函数f（a）时，传入引用变量b的是a的地址（在Java中Circle a 只声明了引用变量a，并不为a分配内存空间）。所以在函数f中任何对b的赋值操作（除改变对象本身）都会同步到a上。但是在函数f中不能改变对象a本身。例如b = new Circle()，对a是没有任何影响的。因为引用变量a与b是有不同的内存地址的，只不过他们存储的是相同的对象的地址，所以改变函数中形参本身不会对实参造成任何影响。
 
以上仅为个人理解，如有表述错误望指正

值传递
 
将对象的只传递给目标对象 相当于copy 
 
系统将目标对象重新开辟一个完全相同的内存空间
 

 
 
引用传递
 
将对象在内存中的地址传递给目标对象 是目标对象和原始对象对应同一个内存存储空间
 
如果对目标对象进行修改 内存中的数据也会改变
 

 
 
浅层复制(copy)
 
 
只复制指向对象的指针 不复制引用对象的本身
 
通过对象的指针来访问这个对象(只复制地址)   两者指向同一个内存资源
 

 
 
深层复制(mutableCopy)
 
复制引用对象的本身 再创建一个对象
 
内存中存在两份独立对象本身