java 参数来带回方法运算结果

1. 简单类型是按值传递的

Java 方法的参数是简单类型的时候，是按值传递的 (pass by value)。这一点我们可以通过一个简单的例子来说明：

public class Test {   

public static void test(boolean test) {      

 test = ! test;      

 System.out.println("In test(boolean) : test = " + test);  

 }  

 public static void main(String[] args) {     

  boolean test = true;      

 System.out.println("Before test(boolean) : test = " + test);       test(test);       

System.out.println("After test(boolean) : test = " + test);   
}

}

　　运行结果：

Before test(boolean) : test = true
In test(boolean) : test = false
After test(boolean) : test = true

不难看出，虽然在 test(boolean) 方法中改变了传进来的参数的值，但对这个参数源变量本身并没有影响，即对 main(String[]) 方法里的 test 变量没有影响。那说明，参数类型是简单类型的时候，是按值传递的。以参数形式传递简单类型的变量时，实际上是将参数的值作了一个拷贝传进方法函数的，那么 在方法函数里再怎么改变其值，其结果都是只改变了拷贝的值，而不是源值。

2. 什么是引用

Java 是传值还是传引用，问题主要出在对象的传递上，因为 Java 中简单类型没有引用。既然争论中提到了引用这个东西，为了搞清楚这个问题，我们必须要知道引用是什么。

简单的说，引用其实就像是一个对象的名字或者别名 (alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象 在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。

如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间来保存。但是它们的值是相同的，都指示同一个对象在内存的中位置。比如：

String a = "Hello";
String b = a;

这里，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 "Hello"。也许你还觉得不够直观，因为 String 对象的值本身是不可更改的 (像 b = "World"; b = a; 这种情况不是改变了 "World" 这一对象的值，而是改变了它的引用b 的值使之指向了另一个 String 对象 a)。那么我们用 StringBuffer 来举一个例子：

public class Test { 

  public static void main(String[] args) {    

   StringBuffer a = new StringBuffer("Hello");    

   StringBuffer b = a;     

  b.append(", World");      

 System.out.println("a is " + a);    }

}

　　运行结果：

a is Hello, World

这个例子中 a 和 b 都是引用，当改变了 b 指示的对象的值的时候，从输出结果来看，a 所指示的对象的值也改变了。所以，a 和 b 都指向同一个对象即包含 "Hello" 的一个StringBuffer 对象。

这里我描述了两个要点：

1.引用是一种数据类型，保存了对象在内存中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)；

2.不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。

3. 对象是如何传递的呢

关于对象的传递，有两种说法，即“它是按值传递的”和“它是按引用传递的”。这两种说法各有各的道理，但是它们都没有从本质上去分析，即致于产生了争论。

既然现在我们已经知道了引用是什么东西，那么现在不妨来分析一下对象作是参数是如何传递的。还是先以一个程序为例：

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 是一个引用，这一点是勿庸置疑的。前面提到，引用是一种数据类型，而且不是对象，所以它不可能按引用传递，所以它是按值传递的，它么它的值究竟是什么呢？ 是对象的地址。

由此可见，对象作为参数的时候是按值传递的，对吗？错！为什么错，让我们看另一个例子：

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 方法的参数是按什么传递的问题，其答案就只能是：即是按值传递也是按引用传递，只是参照物不同，结果也就不同。

总结如下：

1.对于基本数据类型（不包括基本数据类型的数组），通过函数参数带回结果，那是做梦！Java语言不支持，甚至连C语言也不支持。

public class Test {   
public static void test(boolean test) {      
 test = ! test;      
 System.out.println("In test(boolean) : test = " + test);  
 }  
 public static void main(String[] args) {     
  boolean test = true;      
 System.out.println("Before test(boolean) : test = " + test);       test(test);       
System.out.println("After test(boolean) : test = " + test);   
}
}
　　运行结果：
Before test(boolean) : test = true
In test(boolean) : test = false
After test(boolean) : test = true

2.对函数传入数组，在函数中对传入的数组的元素做赋值，其结果可以带回。这里，可以将传入的数组，理解成那个数组的“真实肉身”的首元素的地址或引用，在其地址或引用上指定下标（即地址偏移），然后再赋值，实际上就是对偏移地址上的内存做赋值。退出函数后，对偏移地址上的内存做的赋值操作依然有效。

public class Test { 
  public static void swap(int[] data, int a, int b) {
       int t = data[a];
        data[a] = data[b];
        data[b] = t; 
  }   
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 = i; 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 1
1 31 38 50 69 78 84 94 95 97

3.对函数传入对象，在函数中，通过调用对象的方法改变对象的成员变量的值，该值可以带回。这里，可以将传入的对象，理解成该对象的“真实肉身”（即new出来的东西）的地址或引用，在其地址或引用上通过调用它自己的成员函数改变其成员变量的值，实际上就是对“真实肉身”在内存中的某一段（对应调用的成员函数修改的成员变量）做赋值。退出函数后，对该段内存的修改依然有效。

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!

4.对函数传入对象，在函数中，对传入的对象做“=”操作，让其“等于”另一个对象（的引用），或者对传入的对象做“= new”操作，让其指向新new出来的一个对象。这种情况下，对传入对象的修改不能带回。我们可以将传入的对象理解成该对象的“真实肉身”的地址或引用的一个副本，让该引用的副本“等于”另一个对象的引用，或者让该引用的副本“等于”新new出来的一个对象，都只是改变这个引用的副本自身，即，使得该引用的副本指向了一个新的地址而已，而丝毫不涉及到那个先前指向的“真实肉身”，于是，这里的修改不能带回。

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