与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。 

现在说说数组：如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

例1：

1.public class Test{2.    3.    String str = new String("good");4.    char[] ch = {'a','b','c'};5.    int i = 10;6.    public void change(String str,char[] ch,int i){7.    8.        str = "test ok";9.        ch[0] = 'g';10.        i++;    11.    }12.    13.    public static void main(String[] args){14.    15.        Test tt = new Test();16.        tt.change(tt.str,tt.ch,tt.i);17.        System.out.println(tt.i);//1018.        System.out.print(tt.str+" and ");//good and19.        System.out.println(tt.ch); //gbc    20.    }21.}

str是String类型的引用，i是基本类型变量，ch是数组名，也是数组对象的引用

在chang()方法里，str="test ok"，是一个新的对象把首地址放在引用变量str上；

而ch[0]='g';因为传的是数组的引用，而此时ch[0]='g';是对数组元素的操作，能修改源数组的内容；

i是整型值，只是把值copy了一份给方法，在方法的变化是不改变的源i的。

例2：

1.public class Test{2.    3.    String str = new String("good");4.    char[] ch = {'a','b','c'};5.    int i = 10;6.    public void change(String str,char ch,int i){7.    8.        str = "test ok";9.        ch = 'g';10.        this.i = i+1;    11.    }12.    13.    public static void main(String[] args){14.    15.        Test tt = new Test();16.        tt.change(tt.str,tt.ch[0],tt.i);17.        System.out.println(tt.i);//1118.        System.out.print(tt.str+" and ");//good and19.        System.out.println(tt.ch);//abc     20.    }21.}

change()方法里的入参char[] ch变成----char ch;这次传递的是个char值的单个数组元素，按照上面的解析，此时ch='g';是不影响源数组元素的。

this.i = i+1;这里面等号左边的i是属性i，等号右边的i是局部变量（入参里的i）；此时i+1后赋值给属性的i，自然会改变属性i的值，同时17行，tt.i又是调用属性的i

例3：

1.public class Test{2.    3.    public void change(StringBuffer x,StringBuffer y){4.        5.        x.append(y);6.        y=x;    7.    }8.    public static void main(String[] args){9.    10.        StringBuffer buffA = new StringBuffer("a");11.        StringBuffer buffB = new StringBuffer("b");12.        new Test().change(buffA,buffB);13.        System.out.println(buffA+","+buffB);//ab,b 14.    }15.}

这次传递的是两个对象的引用的值，在方法change()里 的x.append(y),     其中引用x调用api方法append()修改了new StringBuffer("a");的内容。 y=x;是一个修改内容的对象把首地址赋值给引用变量y了，此时操作的是引用，而先前y是new StringBuffer("b");的引用变量。

例4：

1.public class Test{2.    3.    private String nn = new String("1");4.    private String[] mm = {"2","5"};5.    6.    void test(String nn,String[] mm){7.        8.        nn = new String("3");9.        this.nn = "9";10.        11.        mm[0] = "4";12.        System.out.println("in test(),mm[0]: "+mm[0]);//413.        mm = new String[]{"8","7"};14.        System.out.println("in test(),nn: "+nn);//315.        System.out.println("this.nn: "+this.nn);//916.        System.out.println("mm[0]: "+mm[0]);//817.    }18.    19.    public static void main(String[] args){20.        21.        Test s = new Test();22.        s.test(s.nn,s.mm);23.        System.out.println(s.nn+"  "+s.mm[0]);//9 424.    }25.}