java函數的參數傳遞
『壹』 用java方法的參數怎麼傳遞
在 Java 應用程序中永遠不會傳遞對象，而只傳遞對象引用。因此是按引用傳遞對象。Java應用程序按引用傳遞對象這一事實並不意味著 Java 應用程序按引用傳遞參數。參數可以是對象引用，而 Java 應用程序是按值傳遞對象引用的。
『貳』 java的main()函數的參數是
在運行Java程序時，可以通過命令行向程序傳遞參數。這些參數在程序啟動時，作為main()方法的參數傳遞進來。例如，當你執行"java HelloWorld ceshi"時，"ceshi"作為參數傳遞給HelloWorld類的main方法。如果傳遞多個參數，需要用空格隔開，如"java HelloWorld ceshi ceshi1 ceshi2"，這樣"ceshi"、"ceshi1"和"ceshi2"都會作為參數傳遞給main方法。
在HelloWorld類中，main方法的定義如下：
public class HelloWorld{
public static void main(String[] args) {
System.out.println(args[0]);
}
}
編譯並運行此程序時，若執行"java HelloWorld hello"，程序將輸出"hello"。這里，"String"類型用於參數的原因在於，Java中所有數據類型都必須轉換為字元串形式才能在命令行中輸入。名字等參數可以根據需要隨意命名，只要遵守Java的命名規則即可。
參數在main()方法中的形式是一個字元串數組，即String[] args。每個參數都是一個字元串，存儲在數組中的相應位置。因此，可以通過索引訪問每個參數，如args[0]、args[1]等。這為程序提供了接收和處理命令行輸入的強大靈活性。
總之，main()方法的參數是命令行傳遞給程序的輸入，它以字元串數組的形式存在，允許程序從外部獲取信息並根據這些信息執行特定的操作。
『叄』 java 參數傳遞 規則
簡言之：Java都是值傳遞(pass-by-value)
在Java中，無非就是兩種類型，即基本類型和從Object繼承下來的對象類型，而對象類型又包括String這種一旦初始化就不可改變內容的類型和BufferString這種可以初始化後可
以改變內容的類型。
然後看一下代碼示例：
java 代碼
1.package test;
2.
3.public class Test {
1. public static void main(String args[]) {
2. Integer interger1, interger2;
3. int i, j;
4. interger1 = new Integer(10);
5. interger2 = new Integer(50);
6. i = 5;
7. j = 9;
8. System.out.println("Before Swap, Interger1 is " + interger1);
9. System.out.println("Before Swap, Interger2 is " + interger2);
10. swap(interger1, interger2);
11. System.out.println("After Swap Interger1 is " + interger1);
12. System.out.println("After Swap Interger2 is " + interger2);
13. System.out.println("Before Swap i is " + i);
14. System.out.println("Before Swap j is " + j);
15. swap(i, j);
16. System.out.println("After Swap i is " + i);
17. System.out.println("After Swap j is " + j);
18.
19. StringBuffer sb = new StringBuffer("I am StringBuffer");
20. System.out.println("Before change, sb is <" + sb + ">");
21. change(sb);
22. System.out.println("After change sb is <" + sb + ">");
23. }
24.
25. public static void swap(Integer ia, Integer ib) {
26. Integer temp = ia;
27. ia = ib;
28. ib = temp;
29. }
30.
31. public static void swap(int li, int lj) {
32. int temp = li;
33. li = lj;
34. lj = temp;
35. }
36.
37. public static void change(StringBuffer ia) {
38. ia.append(", but my content can be changed");
39. //ia = new StringBuffer(",but my content can be changed");
40. }
41.}
42.
輸出：
Before Swap, Interger1 is 10
Before Swap, Interger2 is 50
After Swap Interger1 is 10
After Swap Interger2 is 50
Before Swap i is 5
Before Swap j is 9
After Swap i is 5
After Swap j is 9
Before change, sb is <I am StringBuffer>
After change sb is <I am StringBuffer, but my content can be changed>
這很好解釋，對於基本類型諸如int，傳遞進去的是存放int值的「內存單元」的一個，所以函數swap裡面的int和外面的int根本就不是一個東西，當然不能反射出去影響外面
的int。而對於對象類型，我們同樣可以這樣認為，傳遞進去的是存放對象類型的指針的「內存單元」一個（雖然Java裡面沒有指針的概念，但這並不妨礙我們理解）。這樣，
在swap函數裡面，對其指針本身的值做任何操作當然不會影響外面的Integer，因為interger1和interger2的「內存單元」裡面的值是不變的，其指向的對象類型也是沒有變的。
然後這里需要說明一個問題，就是StringBuffer這種類型的對象了。因為其內容是可以改變的，所以change函數裡面的「指針」通過類似「*」的操作，改變了StringBuffer對象的
本身，就顯而易見了。(StringBuffer對象本身只有一個副本)