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对象本身只有一个副本)