原帖：http://topic.csdn.net/t/20060605/13/4801113.html
（UnAgain）
最近看了一个帖子，问“java到底是按值传递还是按引用传递？”。本来觉得很简单，为了能说的准确一点，我还专门就这个问题看了看langspec3.0。一看收获还真不小，就写了这篇文章。
我还不敢确定自己的观点对不对，所以贴在这里，希望大家一起讨论。
另外，贴在blog上了，在那里的效果比这里好。
http://blog.csdn.net/UnAgain/archive/2006/06/05/774039.aspx
1 数据类型
1.1 PrimitiveType(简单类型)
1.2 ReferenceType(引用类型)
2. 变量
2.1 简单类型变量
2.2 引用类型变量
3.赋值与传递
3.1 对象的赋值
3.2 传递
3.3 final变量能改变吗？
3.4 包装类的赋值与传递
1 数据类型
java的数据类型有两类：
PrimitiveType(简单类型)
ReferenceType(引用类型)
1.1 PrimitiveType(简单类型)
（参考：langspec-3.0/typesValues.html#4.2）
PrimitiveType的分类如下所示：
PrimitiveType:
NumericType
boolean
NumericType:
IntegralType
FloatingPointType
IntegralType: one of
byte short int long char
FloatingPointType: one of
float double
PrimitiveType是java预定义的类型，并且使用保留字命名。比如int、long、float等。由此看来其包装类不算PrimitiveType。
1.2 ReferenceType(引用类型)
（参考：langspec-3.0/typesValues.html#4.3）
ReferenceType有三种类型：类、接口、和数组。
2. 变量
（参考：langspec-3.0/typesValues.html#4.12）
A variable is a storage location and has an associated type, sometimes called its compile-time type, that is either a primitive type (§4.2) or a reference type (§4.3).
变量是关联于特定类型的存储单元，所关联的类型有时叫做变量的编译时类型，即，既可以是简单类型也可以是引用类型。
2.1 简单类型变量
A variable of a primitive type always holds a value of that exact primitive type.
简单类型的变量总是执持简单类型的值。
2.2 引用类型变量
A variable of a class type T can hold a null reference or a reference to an instance of class T or of any class that is a subclass of T. A variable of an interface type can hold a null reference or a reference to any instance of any class that implements the interface.
类型是T的类的变量可以执持null引用，或者类T及其子类的实例引用。接口类型的变量可以执持null引用，或者任何实现该接口的类的实例引用。
注：与langspec2.0不同的是，3.0引入了泛型的概念，其中有Type Variable的概念，上面的T就是一个Type Variable。
3.赋值与传递
如上所述，可以得出下面结论：
1) 对于简单类型变量的赋值是按值传递。就是说直接把数值存放到变量的存储单元里。
2) 对于引用类型的变量，赋值是把原对象的引用（可以理解为入口地址），存放在变量的存储单元里。
3.1 对象的赋值
简单类型的赋值很容易理解，这里仅讨论对象的赋值。所有引用类型的实例就是我们常说的对象。
可以这样说，除了null以外，任何变量的初始赋值都是分两步：
1) 创建对象实例
2) 把对象实例的引用赋值给变量。
比如：
Object o1 = new Object();
3.2 传递
传递是通过变量之间的赋值实现的。在以前的回贴中我说过这样一句话，单纯从变量的角度看，变量之间的赋值是值传递。现在我解释一下我的观点。
先举一个例子：
// java中所有的类的基类默认为Object，在此不赘述。
class Object1 {}
class Object2 {}
Object o1, o2;
o1 = new Object1();
o2 = o1;
o2 = new Object2();
这时候，o1的类型是什么？是Object1还是Object2？正确答案是Object1。
再举一个例子：
class Word {
String word;
public Word(String word){
this.word = word;
}
public void print(){
System.out.println(word);
}
}
Word o1, o2;
o1 = new Word( "Every Day ");
o2 = o1;
o2 = new Word( "Every Night! ");
w1.print();
会出现什么结果？ "Every Day " 还是 "Every Night! "？仍然是 "Every Day "。
这里面有一个很多人特别是初学者忽视了的观点 ―― 变量可以引用对象，但变量不是对象。什么是对象？对象初始化之后，会占用一块内存空间，严格意义上讲，这段内存空间才是对象。对象创建于数据段，而变量存在于代码段；对象的入口地址是不可预知的，所以程序只能通过变量来访问对象。
回到我们的问题上来，第一句
o1 = new Word( "Every Day ");
首先创建一个Word实例，即对象，然后把“引用”赋值给o1。
第二句
o2 = o1;
o1把对象的引用赋值给o2，注意赋的值是对象的引用而不是o1自身的引用。所以，在的三句
o2 = new Word( "Every Night! ");
就是又创建一个新对象，再把新对象的引用赋值给o2。
因为o1和 o2之间是值传，所以，对o2的改变丝毫不会影响到o1。
也有一种情况好像是影响到了o1，我们继续上面的例子，给Word增加一个方法
class Word {
String word;
public Word(String word){
this.word = word;
}
public void print(){
System.out.println(word);
}
public void setWord(String word){
this.word = word;
}
}
Word o1, o2;
o1 = new Word( "Every Day ");
o2 = o1;
o2.set Word( "Every Night! ");
o1.print();
这时的结果是 "Every Night! "。
那么，这是改变了o1吗？从严格意义上讲，不是。因为o1只是保存对象的引用，执行之后，o1还是持有该对象的引用。所以，o1没变，变的是o1所引用的对象。
3.3 final变量能改变吗？
好了，我再出道题目：
final Word o3 = new Word( "Every Day! ");
o3.setWord( "Every Night! ");
能通过编译吗？对于final的定义大家都知道，o3是相当于一个常量，既然是常量，怎么能再改变呢？
答案是肯定的，能。道理我想大家也明白，这里不罗嗦了。
3.4 包装类的赋值与传递
以前看过文章说，对于java基本类型及其包装类采用值传递，对于对象采用引用传递。从langspec看，首先包装类不是PrimitiveType，那就只能是ReferenceType，而ReferenceType的变量保存的是引用。既然保存的是引用，也就无从传递数值。那么，这两个观点矛盾吗？
首先，肯定是langspec正确。
其次，虽然前一观点在原理上有错误，但却不影响正常使用。
为什么会出现这种情况？这是因为这些包装类具有一个简单类型的特征，即，不可改变。以String为例，看一下API Specification，不会找到能够改变String对象的方法。任何输出上的改变都是重建新的String对象，而不是在原对象基础上改变。改变的是变量的内容，即，不同对象的引用。
------------------------------------------------------------------------
(::一骑绝尘::) ：
Java中总是使用传值调用。
在Java中，方法可以改变对象参数的状态，却无法改变这个对象引用（Object reference）本
身.也就是当一个对象的实例被创建的时候，like this： Apple a = new Apple(); a 存的就是这个对象实例的地址。而这个地址，也就是a的值作为参数传到某个函数中的时候，a本身是不会改变的。
电视机和遥控器可以很形象的描叙和解释这个问题。
可以把遥控器看作是电视机的一个引用拷贝，只要电视机存在，也就是用遥控器对准一台电视机，按遥控器上面的各种按扭（function）可以对电视机产生各种影响，但是你换一个遥控器对电视机来说是不会产生影响的，电视机并不会因为遥控器换了而变成别的电视机。同时遥控器也可以不对准原来的电视机，转去对准别的电视机，这对原来的电视机也是不会产生影响的。一台电视机可以有多个遥控器，并且只要某个遥控器对准了这台电视机，这个遥控器就可以通过它上面的按扭改变电视机的状态。
下面是正面只有按值传递的程度代码:
//Test.java
class Test {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//TestTransferParameter.java
public class TestTransferParameter{
public static void main(String[] args) {
Test a = new Test();
a.setName( "a ");
Test b = new Test();
b.setName( "b ");
System.out.println( "before swap: " + "a= " + a.getName() + "; b= " + b.getName());
swap(a,b);
System.out.println( "after swap: " + "a= " + a.getName() + "; b= " + b.getName());
}
private static void swap(Test a, Test b) {
Test temp;
temp = a;
a = b;
b = temp;
System.out.println( "swaping: " + "a= " + a.getName() + "; b= " + b.getName());
}
}
输出结果：
before swap: a=a; b=b
swaping: a=b; b=a
after swap: a=a; b=b