用户名：yqsshr
文章数：55
评论数：30
访问量：285130
注册日期：
阅读量：1297
阅读量：3317
阅读量：582579
阅读量：467337
[匿名]51cto游客：
51CTO推荐博文
按值传递还是按引用传递
这个在Java里面是经常被提起的问题，也有一些争论，似乎最后还有一个所谓的结论：“在Java里面参数传递都是按值传递”。事实上，这很容易让人迷惑，下面先分别看看什么是按值传递，什么是按引用传递，只要能正确理解，至于称作按什么传递就不是个大问题了。
1：按值传递是什么指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下：public class TempTest {private void test1(int a){//做点事情}public static void main(String[] args) {TempTest t = new TempTest();int a = 3;t.test1(a);//这里传递的参数a就是按值传递}}按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。示例如下：public class TempTest {private void test1(int a){a = 5;System.out.println("test1方法中的a==="+a);}public static void main(String[] args) {TempTest t = new TempTest();int a = 3;t.test1(a);//传递后，test1方法对变量值的改变不影响这里的aSystem.out.println(”main方法中的a===”+a);}}运行结果是：test1方法中的a===5main方法中的a===3
2：按引用传递是什么指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。示例如下：public class TempTest {private void test1(A a){
}public static void main(String[] args) {TempTest t = new TempTest();A a = new A();t.test1(a); //这里传递的参数a就是按引用传递}}class A{public int age = 0;}
3：按引用传递的重要特点传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。示例如下：第1行 public class TempTest {第2行 private void test1(A a){第3行 a.age = 20;第4行 System.out.println("test1方法中的age="+a.age);第5行 }第6行 public static void main(String[] args) {第7行 TempTest t = new TempTest();第8行 A a = new A();第9行 a.age = 10;第10行 t.test1(a);第11行 System.out.println(”main方法中的age=”+a.age);第12行 }第13行 }第14行 class A{第15行 public int age = 0;第16行 }运行结果如下：test1方法中的age=20main方法中的age=20
4：理解按引用传递的过程――内存分配示意图要想正确理解按引用传递的过程，就必须学会理解内存分配的过程，内存分配示意图可以辅助我们去理解这个过程。用上面的例子来进行分析：（1）：运行开始，运行第8行，创建了一个A的实例，内存分配示意如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-1.jpg" />
（2）：运行第9行，是修改A实例里面的age的值，运行后内存分配示意如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-2.jpg" />
（3）：运行第10行，是把main方法中的变量a所引用的内存空间地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽。
内存分配示意如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-3.jpg" />
由于是按引用传递，也就是传递的是内存空间的地址，所以传递完成后形成的新的内存示意图如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-4.jpg" />也就是说：是两个变量都指向同一个空间。
（4）：运行第3行，为test1方法中的变量a指向的A实例的age进行赋值，完成后形成的新的内存示意图如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-5.jpg" />
此时A实例的age值的变化是由test1方法引起的
（5）：运行第4行，根据此时的内存示意图，输出test1方法中的age=20（6）：运行第11行，根据此时的内存示意图，输出main方法中的age=20
5：对上述例子的改变理解了上面的例子，可能有人会问，那么能不能让按照引用传递的值，相互不影响呢？就是test1方法里面的修改不影响到main方法里面呢？方法是在test1方法里面新new一个实例就可以了。改变成下面的例子，其中第3行为新加的：
第1行 public class TempTest {第2行 private void test1(A a){第3行 a = new A();//新加的一行第4行 a.age = 20;第5行 System.out.println("test1方法中的age="+a.age);第6行 }第7行 public static void main(String[] args) {第8行 TempTest t = new TempTest();第9行 A a = new A();第10行 a.age = 10;第11行 t.test1(a);第12行 System.out.println(”main方法中的age=”+a.age);第13行 }第14行}第15行class A{第16行 public int age = 0;第17行}
运行结果为：test1方法中的age=20main方法中的age=10
为什么这次的运行结果和前面的例子不一样呢，还是使用内存示意图来理解一下
6：再次理解按引用传递（1）：运行开始，运行第9行，创建了一个A的实例，内存分配示意如下：650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-1.jpg" />
（2）：运行第10行，是修改A实例里面的age的值，运行后内存分配示意如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-2.jpg" />
（3）：运行第11行，是把main方法中的变量a所引用的内存空间地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽。
内存分配示意如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-3.jpg" />
由于是按引用传递，也就是传递的是内存空间的地址，所以传递完成后形成的新的内存示意图如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-4.jpg" />
也就是说：是两个变量都指向同一个空间。
（4）：运行第3行，为test1方法中的变量a重新生成了新的A实例的，完成后形成的新的内存示意图如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-6.jpg" />
（5）：运行第4行，为test1方法中的变量a指向的新的A实例的age进行赋值，完成后形成的新的内存示意图如下：
650) this.width=650;" alt="" src="/images/img/2008/10/chenchen-7.jpg" />
注意：这个时候test1方法中的变量a的age被改变，而main方法中的是没有改变的。
（6）：运行第5行，根据此时的内存示意图，输出test1方法中的age=20（7）：运行第12行，根据此时的内存示意图，输出main方法中的age=10
7：说明（1）：“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。（2）：在Java里面只有基本类型和按照下面这种定义方式的String是按值传递，其它的都是按引用传递。就是直接使用双引号定义字符串方式：String str = “Java私塾”;
了这篇文章
类别：未分类┆阅读(0)┆评论(0)
11:47:02 15:01:45 15:01:46 11:46:51&nbsp&#8250&nbsp&nbsp&#8250&nbsp
string与参数引用传递
编者语：书上都说string是引用类型，但事实上我所看到的string和所谓的值类型没有什么区别，但通过看以下的文章，明白了：1、string a=&abc&;之后，如果a=&xy&，则是a并没有改变内存中已经存在的&abc&，而是又创建了另外一个实例。实际上相当于：string
a=new String(&abc&);a=new String(&xy&);但如果是StringBuffer，则：StringBuffer a=new
StringBuffer(&abc&); 这是如果再想改变a，则：a.append(&xy&);值变为&abcxy&，其中并没有new。2、以上中：string a=&abc&; b=a; a=&xy&; 则b还是&abc&。但如果是：StringBuffer a=new
StringBuffer(&abc&); StringBuffer b=a; a=a.append(&xy&);& 则b变为：&abcxy&。3、虽然string确实是引用类型，但我想我还是基本把他看成是值类型，因为他引用的内存中的值并不会改变，也应该不会说当另外一个应用改变了内存中的值，从而会导致这个值的改变，不会的。但stringBuffer却可以。还有数组等。4、数据分为2种，一种是值类型，一种是引用类型。但方法的传递方式却是三种，默认的一般书上不写，即值传递（val），另外2种是：ref 和 out。5、事实上，所有的值类型数据包括所谓的引用类型的string，在值参数时，其方法中都无法不从根本上改变其本质，因为任何常用的赋值都省略了new
.....。只有数组、StringBuffer以及其他类在改变其中的部分内容是可以不改变其本质，如stringbuffer.append()、intArray[2]=100等，要改变他们的本质好像只能用new的形式。这也是为何我们经常分不清string是否是引用类型，以及传递参数时的种种疑惑的根源。举个Array的例子：void aa(int() array,int x,string z)
&&array[2]=array[2]+100;
&&&array=new int[]{5,6,7}
void bb( ref int[] array ,int x,string z)
&&array[2]=array[2]+100;
&&array=new int[]{5,6,7}
int[] a=new int[]{1,2,3};
string zy="zy";&那么上面的结论中，如果是第一aa方法，只有数组会改变其值，而且只会执行第一行命令，结果为103，但不会new，而变为{5,6,7}。在ref方法中，数组会变为{5,6,7}，xx和zy也会变的。以上是我的心得。以下是在JAVA中的结论，应该也适用于C#吧。1.&声明是什么?String s = &Hello world!&;许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello
world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向&Hello
world!&这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：String string =我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。2.&String类的特殊性1)&String
s1 = “Hello”;& //产生一个String ”Hello”对象,并产生该对象的一个别名s1来引用该对象String s2 =
“Hello”;& //又产生一个别名s2来引用上面的”Hello”对象s1 == s2 =&&
//由于是同一个对象所以“==”返回为trues1 = “World”;& //产生一个String ”World”对象,
s1的引用不再指向“Hello”而是指向对象”World”s1 == s2 =&&
//由于不是同一个对象所以“==”返回为falses1 = “Hello”;& //同上面的String s2 = “Hello”;
现在s1又指向对象”Hello”, 因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。s1 == s2 =&&
//由于是同一个对象所以“==”又返回为true了s1 = s1 + “World”;&
//这时又产生一个对象”HelloWord”,s1不再指向”Hello”而是指向”HelloWord”s1 == s2 =&
//不是一个对象当然是false拉s1 = s1+ &a&+&b&+&c&+…;& //
String不停的创建对象,影响性能，这种易变的String用StringBuffer会得到更好的性能StringBuffer s3 = new
StringBuffer(“Hello”); s3.append(“a”); //没有生成新的对象，而是将s3引用的对象内容改为”Helloa”//说明:
String类用来表示那些创建后就不会再改变的字符串，它是immutable的。而StringBuffer类用来表示内容可变的字符串，并提供了修改底层字符串的方法。StingBuffer是一个可变的字符串，它可以被更改。同时StringBuffer是Thread
safe的， 你可以放心的使用.因为String被设计成一种安全的字符串， 避免了C/C++中的尴尬。因此在内部操作的时候会频繁的进行对象的交换，
因此它的效率不如StringBuffer。 如果需要频繁的进行字符串的增删操作的话最好用StringBuffer。 比如拼SQL文， 写共函。 另：
编绎器对String的+操作进行了一定的优化。 x = &a& + 4 + &c&会被编绎成x = new
StringBuffer().append(&a&).append(4).append(&c&).toString()但：x =
“a”;x = x + 4;x = x + “c”;则不会被优化。 可以看出如果在一个表达式里面进行String的多次+操作会被优化，
而多个表达式的+操作不会被优化。摘自：《Java API Using, Tips And Performance
Tuning》2)&Integer、Boolean等wrapper类以及BigInteger、BigDecimal是immutable的，所以也有与String类似的地方，不过没有IntegerBuffer之类的东西。不过Float,
Double,Boolean比较特殊。如T a1 = 10; //T代指Byte,Integer,Short,LongT a2 =
10;if (f1 ==
f2)&System.out.println(true);else&System.out.println(false);这时总是true,和String有点类似T a1 = (T)10.0; //T代指Float,DoubleT a2 = (T)10.0;if (f1 ==
f2)&System.out.println(true);else&System.out.println(false);这时总是falseBoolean a1 = Boolean a2 =if (f1 ==
f2)&System.out.println(true);else&System.out.println(false);这时总是false总之如果比较两个Wrapper类的值用equals，以免不必要的麻烦3)&再看String
s1 = new String(“Hello”);String s2 = new String(“Hello”);s1 == s2 =
//因为new的时候JVM不管heap中有没有”Hello”对象都会产生一个新的”Hello”对象String s3 =
“Hello”; //重新创建对象”Hello”, 并令s3指向对象”Hello”s3 == s1 =
//不同对象当然falseString s4 = “Hello”; s3 == s4 =&
//故伎重演，jvm清楚的知道哪些用了new，哪些没用new//Integer等整型wrapper类也有同样的特性3.&方法的参数传递中都是以reference传递，而primitive传递的是副本，但如果传递的是Integer、Boolean等wrapper类和String类的Object则是以immutable方式传递。示例：import java.awt.P
class HelloWorld
&&public static void modifyPoint(Point pt, String j, int k, Integer m, Boolean b)
&&&&pt.setLocation(5,5);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&j = "15";
&&&&k = 25;
&&&&m = 35;
&&&&System.out.println("During modifyPoint " + "pt = " + pt +
&&&&&&&&&&&&&&&&&&&&&&&" and j = " + j+ " and k = "+ k+
&&&&&&&&&&&&&&&&&&&&&&&" and m = "+ m+ " and b = "+ b);
&&public static void main(String args[])
&&&&Point p = new Point(0,0);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&String i = "10";
&&&&int k = 20;
&&&&Integer m = 30;
&&&&Boolean b =
&&&&System.out.println("Before modifyPoint " + "p = " + p +
&&&&&&&&&&&&&&&&&&&&&&&" and i = " + i+ " and k = "+ k+
&&&&&&&&&&&&&&&&&&&&&&&" and m = "+ m+ " and b = "+ b);
&&&&modifyPoint(p, i, k, m, b);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&System.out.println("After modifyPoint " + "p = " + p +
&&&&&&&&&&&&&&&&&&&&&&&" and i = " + i+ " and k = "+ k+
&&&&&&&&&&&&&&&&&&&&&&&" and m = "+ m+ " and b = "+ b);
}输出结果：Before modifyPoint p =
java.awt.Point[x=0,y=0] and i = 10 and k = 20 and m = 30 and b = falseDuring
modifyPoint pt = java.awt.Point[x=5,y=5] and j = 15 and k = 25 and m = 35 and b
= trueAfter modifyPoint p = java.awt.Point[x=5,y=5] and i = 10 and k = 20
and m = 30 and b = falseJava是传值还是传引用1. 简单类型是按值传递的　　Java 方法的参数是简单类型的时候，是按值传递的 (pass by value)。这一点我们可以通过一个简单的例子来说明：/* 例 1 */
&* @(#) Test.java
&* @author fancy
public class Test {
&&&&public static void test(boolean test) {
&&&&&&&&test = !
&&&&&&&&System.out.println("In test(boolean) : test = " + test);
&&&&public static void main(String[] args) {
&&&&&&&&boolean test =
&&&&&&&&System.out.println("Before test(boolean) : test = " + test);
&&&&&&&&test(test);
&&&&&&&&System.out.println("After test(boolean) : test = " + test);
}　　运行结果：Before test(boolean) : test = trueIn test(boolean) : test =
falseAfter test(boolean) : test = true　　不难看出，虽然在 test(boolean) 方法中改变了传进来的参数的值，但对这个参数源变量本身并没有影响，即对 main(String[])
方法里的 test
变量没有影响。那说明，参数类型是简单类型的时候，是按值传递的。以参数形式传递简单类型的变量时，实际上是将参数的值作了一个拷贝传进方法函数的，那么在方法函数里再怎么改变其值，其结果都是只改变了拷贝的值，而不是源值。　　2. 什么是引用　　Java 是传值还是传引用，问题主要出在对象的传递上，因为 Java
中简单类型没有引用。既然争论中提到了引用这个东西，为了搞清楚这个问题，我们必须要知道引用是什么。　　简单的说，引用其实就像是一个对象的名字或者别名
(alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似
C 语言中指针的东西，它指示了对象在内存中的地址――只不过我们不能够观察到这个地址究竟是什么。　　如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间来保存。但是它们的值是相同的，都指示同一个对象在内存的中位置。比如String a = &Hello&;String b =　　这里，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 &Hello&。也许你还觉得不够直观，因为
String 对象的值本身是不可更改的 (像 b = &World&; b = 这种情况不是改变了 &World& 这一对象的值，而是改变了它的引用 b
的值使之指向了另一个 String 对象 a)。那么我们用 StringBuffer 来举一个例子：/* 例 2 */
&* @(#) Test.java
&* @author fancy
public class Test {
&&&&public static void main(String[] args) {
&&&&&&&&StringBuffer a = new StringBuffer("Hello");
&&&&&&&&StringBuffer b =
&&&&&&&&b.append(", World");
&&&&&&&&System.out.println("a is " + a);
}　　运行结果：a is Hello, World　　这个例子中 a 和 b 都是引用，当改变了 b 指示的对象的值的时候，从输出结果来看，a 所指示的对象的值也改变了。所以，a 和 b
都指向同一个对象即包含 &Hello& 的一个 StringBuffer 对象。　　这里我描述了两个要点：
引用是一种数据类型，保存了对象在内存中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)； 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。 　　3. 对象是如何传递的呢　　关于对象的传递，有两种说法，即“它是按值传递的”和“它是按引用传递的”。这两种说法各有各的道理，但是它们都没有从本质上去分析，即致于产生了争论。　　既然现在我们已经知道了引用是什么东西，那么现在不妨来分析一下对象作是参数是如何传递的。还是先以一个程序为例：/* 例 3 */
&* @(#) Test.java
&* @author fancy
public class Test {
&&&&public static void test(StringBuffer str) {
&&&&&&&&str.append(", World!");
&&&&public static void main(String[] args) {
&&&&&&&&StringBuffer string = new StringBuffer("Hello");
&&&&&&&&test(string);
&&&&&&&&System.out.println(string);
}　　运行结果：　　Hello, World!
　　test(string) 调用了 test(StringBuffer) 方法，并将 string 作为参数传递了进去。这里 string
是一个引用，这一点是勿庸置疑的。前面提到，引用是一种数据类型，而且不是对象，所以它不可能按引用传递，所以它是按值传递的，它么它的值究竟是什么呢？是对象的地址。　　由此可见，对象作为参数的时候是按值传递的，对吗？错！为什么错，让我们看另一个例子：/* 例 4 */
&* @(#) Test.java
&* @author fancy
public class Test {
&&&&public static void test(String str) {
&&&&&&&&str = "World";
&&&&public static void main(String[] args) {
&&&&&&&&String string = "Hello";
&&&&&&&&test(string);
&&&&&&&&System.out.println(string);
}　　运行结果：Hello　　为什么会这样呢？因为参数 str 是一个引用，而且它与 string 是不同的引用，虽然它们都是同一个对象的引用。str = &World& 则改变了
str 的值，使之指向了另一个对象，然而 str 指向的对象改变了，但它并没有对 &Hello& 造成任何影响，而且由于 string 和 str
是不同的引用，str 的改变也没有对 string 造成任何影响，结果就如例中所示。　　其结果是推翻了参数按值传递的说法。那么，对象作为参数的时候是按引用传递的了？也错！因为上一个例子的确能够说明它是按值传递的。　　结果，就像光到底是波还是粒子的问题一样，Java
方法的参数是按什么传递的问题，其答案就只能是：即是按值传递也是按引用传递，只是参照物不同，结果也就不同。　　4. 正确看待传值还是传引用的问题　　要正确的看待这个问题必须要搞清楚为什么会有这样一个问题。　　实际上，问题来源于 C，而不是 Java。　　C
语言中有一种数据类型叫做指针，于是将一个数据作为参数传递给某个函数的时候，就有两种方式：传值，或是传指针，它们的区别，可以用一个简单的例子说明：/* 例 5 */
&* @(#) test.c
&* @author fancy
void SwapValue(int a, int b) {
&&&&int t =
void SwapPointer(int * a, int * b) {
&&&&int t = *
&&&&* a = *
void main() {
&&&&int a = 0, b = 1;
&&&&printf("1 : a = %d, b = %d/n", a, b);
&&&&SwapValue(a, b);
&&&&printf("2 : a = %d, b = %d/n", a, b);
&&&&SwapPointer(&a, &b);
&&&&printf("3 : a = %d, b = %d/n", a, b);
}　　运行结果：1 : a = 0, b = 12 : a = 0, b = 13 : a = 1, b =
0　　大家可以明显的看到，按指针传递参数可以方便的修改通过参数传递进来的值，而按值传递就不行。　　当 Java 成长起来的时候，许多的 C 程序员开始转向学习 Java，他们发现，使用类似 SwapValue
的方法仍然不能改变通过参数传递进来的简单数据类型的值，但是如果是一个对象，则可能将其成员随意更改。于是他们觉得这很像是 C 语言中传值/传指针的问题。但是
Java 中没有指针，那么这个问题就演变成了传值/传引用的问题。可惜将这个问题放在 Java 中进行讨论并不恰当。　　讨论这样一个问题的最终目的只是为了搞清楚何种情况才能在方法函数中方便的更改参数的值并使之长期有效。　　Java 中，改变参数的值有两种情况，第一种，使用赋值号“=”直接进行赋值使其改变，如例 1 和例
4；第二种，对于某些对象的引用，通过一定途径对其成员数据进行改变，如例
3。对于第一种情况，其改变不会影响到方法该方法以外的数据，或者直接说源数据。而第二种方法，则相反，会影响到源数据――因为引用指示的对象没有变，对其成员数据进行改变则实质上是改变的该对象。　　5. 如何实现类似 swap 的方法　　传值还是传引用的问题，到此已经算是解决了，但是我们仍然不能解决这样一个问题：如果我有两个 int 型的变量 a 和
b，我想写一个方法来交换它们的值，应该怎么办？　　结论很让人失望――没有办法！因此，我们只能具体情况具体讨论，以经常使用交换方法的排序为例：/** 例 6 */
&* @(#) Test.java
&* @author fancy
public class Test {
&&&&public static void swap(int[] data, int a, int b) {
&&&&&&&&int t = data[a];
&&&&&&&&data[a] = data[b];
&&&&&&&&data[b] =
&&&&public static void main(String[] args) {
&&&&&&&&int[] data = new int[10];
&&&&&&&&for (int i = 0; i & 10; i++) {
&&&&&&&&&&&&data[i] = (int) (Math.random() * 100);
&&&&&&&&&&&&System.out.print(" " + data[i]);
&&&&&&&&System.out.println();
&&&&&&&&for (int i = 0; i & 9; i++) {
&&&&&&&&&&&&for (int j = j & 10; j++) {
&&&&&&&&&&&&&&&&if (data[i] & data[j]) {
&&&&&&&&&&&&&&&&&&&&swap(data, i, j);
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&}
&&&&&&&&for (int i = 0; i & 10; i++) {
&&&&&&&&&&&&System.out.print(" " + data[i]);
&&&&&&&&System.out.println();
}　　运行结果(情况之一)：78 69 94 38 95 31 50 97 84 11 31 38 50 69 78 84 94 95
97　　swap(int[] data, int a, int b) 方法在内部实际上是改变了 data
所指示的对象的成员数据，即上述讨论的第二种改变参数值的方法。希望大家能够举一反三，使用类似的方法来解决相关问题。
上一篇： JAVA:它不是没有指针，而是对指针进行了伪装：使用上泛化、强化和简单化，概念上淡化和弱化。。。 C++中可以有对象类型的变量和对象指针类型，两者的区别如下： Object oo = Object(); Object * oop = new Object(); 也就是说当使用new方式时，是动态为对象
下一篇： Eclipse手动创建java项目的时候，往往找不到.class文件在哪里，这有可能是没有设置.class的输出路径。}