public static void testBase(int i)   {i = 2;}

測试：

int i = 10;
System.out.println(i);//10
testBase(i);
System.out.println(i);  //10

结果当然非常显然都是10。由于基本数据类型传递的是值的一份拷贝（副本），对副本操作不影响原始值。

public static void testObj(Object o)
{o = new Object();
}

測试：

Object o = new Object();
System.out.println(o);// java.lang.Object@1ff61bcf
testObj(o);
System.out.println(o);//java.lang.Object@1ff61bcf

方法中的參数仅仅是原始对象的一份拷贝，更准确的讲是地址的一份拷贝，故而对其进行又一次赋值并不会影响原始对象。

public class S
{private Object o = new Object();private int i = 2;public Object getO(){return o;}public void setO(Object o){this.o = o;}public int getI(){return i;}public void setI(int i){this.i = i;}
}

測试方法：

public static void testA(S s)
{s.setI(100);s.setO(new Object());
}

測试：

S s = new S();
System.out.println(s.getI()+","+s.getO());// 2,java.lang.Object@11b75be2
testA(s);
System.out.println(s.getI()+","+s.getO());//100,java.lang.Object@1cf15b84

由于对象作为參数传递的是对象的引用地址（注意，这是值传递）。故參数所指的对象和原始引用所指的对象都是堆中的同一个对象，故在測试方法中改动对象内容会改变对象的数据。

package test;
public class A
{int t = 6;Object obj = new Object();public static void main(String[] args){A a = new A();  a.func(a.t,a.obj);//问t和obj的值是否变化。答案：不变化}public void func(int t,Object obj){t = 7;obj = null;}
}

  public static void testArr(int[] arr){arr = null;}

測试：

int[] arr = {1,2};
System.out.println(arr[0]);//1
testArr(arr);
System.out.println(arr[0]);  //1

 public static void testArr(int[] arr){arr[0] = 100;}

測试：

int[] arr = {1,2};
System.out.println(arr[0]);//1
testArr(arr);
System.out.println(arr[0]);//100

public static void testWrapper(Float f)
{f = 100.0f;
}

測试：

Float f = 12.0f;
System.out.println(f);//12.0
testWrapper(f);
System.out.println(f);//12.0

public static void testStr1(String str)
{str = "testOK";
}

測试：

 String str = "test";       System.out.println(str);//testtestStr1(str);System.out.println(str);//test

依据前面的思路，字符串也是对象，參数拷贝的是对象的地址。在方法内部将參数指向还有一个堆对象并不影响原始对象引用的指向。

 public static void testStr2(String str)   {str = str.concat("OK");str = str.toUpperCase();}

測试：

String str = "test";
System.out.println(str);//test
testStr2(str);
System.out.println(str);//test

public static void testStr3(String str){str += "OK";}

測试：

String str = "test";
System.out.println(str);//test
testStr3(str);
System.out.println(str);//test

假设你以为第二次输出testOK。那就错啦，String类的’+‘是经过重载的。编译时会还原成StringBuilder的append操作，而且new了一个StringBuilder对象：

str += "OK";
str = new StringBuilder(str).append("OK").toString();//编译时会还原成这样

public static void testStringBuilder(StringBuilder sb)
{sb = new StringBuilder("testOK");
}

測试：

StringBuilder sb = new StringBuilder("test");
System.out.println(sb.toString());//test
testStringBuilder(sb);
System.out.println(sb.toString());//test

6.2在方法内部调用StringBuffer或StringBuilder的append方法：

public static void testStringBuilder(StringBuilder sb)
{sb.append("OK");
}

測试：

StringBuilder sb = new StringBuilder("test");
System.out.println(sb.toString());//test
testStringBuilder(sb);
System.out.println(sb.toString());//testOK

public static void swap(Integer a, Integer b)
{Integer temp = a;a = b;b = temp;
}

这根本不能交换两个数.

总结：