Java 中的传值和传应用 .

 Java中在函数调用传递参数时,

 *   传递的若是基于基本类型的JAVA数据类型, 都是传值. 

             如 8 种基本数据类型 int, float, double, long, char, byte, short, boolean 分别对应 Integer, Float, Double, Long, String, Byte, Short, Boolean.

             此外，数组也是传值，和C/C++中不一样（验证了 byte 数组）

 *   传递的若是普通类的对象, 则是传引用.

测试代码：

[java] view plain copy print ?

1. package string;  
2.   
3. /** 
4.  * 测试Java中的函数参数传值. 
5.  * 传值、传引用. 
6.  * 函数参数是普通类型、对象等. 
7.  * 在函数调用传递参数时, 
8.  *    传递的若是基于基本类型的JAVA数据类型, 都是传值. 如 8 种基本数据类型 int, float, double, long, char, byte, short, boolean 分别对应 Integer, Float, Double, Long, String, Byte, Short, Boolean. 
9.  *    传递的若是普通类的对象, 则是传引用. 
10.  * @author zhankunlin 
11.  * 
12.  */  
13. public class TestTransfValueFunction {  
14.   
15.     /** 
16.      * 测试 String 类型. 
17.      * String 对应基本类型 char. 
18.      */  
19.     private void testString() {  
20.         System.out.println("测试 String");  
21.         String src = new String("world");    
22.         System.out.println(src);  
23.         procsString(src);  
24.         System.out.println(src);  
25.     }  
26.       
27.     /** 
28.      * 该方法中处理参数 src 
29.      * @param src 
30.      */  
31.     private void procsString(String src) {  
32.         src += "hello";  
33.     }  
34.       
35.     /** 
36.      * 测试 Integer 类型. 
37.      * Integer 对应基本类型 int. 
38.      */  
39.     private void testInteger() {  
40.         System.out.println("测试 Integer");  
41.         Integer src = new Integer(500);  
42.         //Integer src = 500;     
43.         System.out.println(src);  
44.         procsInteger(src);  
45.         System.out.println(src);  
46.     }  
47.       
48.     /** 
49.      * 该方法中处理参数 src 
50.      * @param src 
51.      */  
52.     private void procsInteger(Integer src) {  
53.         src += 500;  
54.     }  
55.       
56.     /** 
57.      * 测试 Float 类型. 
58.      * Float 对应基本类型 float. 
59.      */  
60.     private void testFloat() {  
61.         System.out.println("测试 Float");  
62.         Float src = new Float(123.45);    
63.         System.out.println(src);  
64.         procsFloat(src);  
65.         System.out.println(src);  
66.     }  
67.       
68.     /** 
69.      * 该方法中处理参数 src 
70.      * @param src 
71.      */  
72.     private void procsFloat(Float src) {  
73.         src += 500.00;  
74.     }  
75.       
76.     /** 
77.      * 测试参数是普通类的对象的情况. 
78.      * 此时是传递的是引用. 
79.      */  
80.     private void testT() {  
81.         System.out.println("测试 普通类对象");  
82.         T src = new T();    
83.         src.num = 100;  
84.         src.str = "hello";  
85.         System.out.println(src.str + ", " + src.num);  
86.         procsT(src);  
87.         System.out.println(src.str + ", " + src.num);  
88.     }  
89.       
90.     /** 
91.      * 该方法中处理参数 src 
92.      * @param src 
93.      */  
94.     private void procsT(T src) {  
95.         src.num = 500;  
96.         src.str = "hello world";  
97.     }  
98.       
99.     public static void main(String []argv) {  
100.         TestTransfValueFunction test = new TestTransfValueFunction();  
101.         test.testString();  
102.         test.testInteger();  
103.         test.testFloat();  
104.         test.testT();  
105.     }  
106. }  
107.   
108. class T {  
109.     public String str;  
110.     public Integer num;  
111.       
112.     public void setStr(String str) {  
113.         this.str = str;  
114.     }  
115.       
116.     public String getStr() {  
117.         return this.str;  
118.     }  
119.       
120.     public void setNum(Integer num) {  
121.         this.num = num;  
122.     }  
123.       
124.     public Integer getNum() {  
125.         return this.num;  
126.     }  
127. }  

package string; /** * 测试Java中的函数参数传值. * 传值、传引用. * 函数参数是普通类型、对象等. * 在函数调用传递参数时, * 传递的若是基于基本类型的JAVA数据类型, 都是传值. 如 8 种基本数据类型 int, float, double, long, char, byte, short, boolean 分别对应 Integer, Float, Double, Long, String, Byte, Short, Boolean. * 传递的若是普通类的对象, 则是传引用. * @author zhankunlin * */ public class TestTransfValueFunction { /** * 测试 String 类型. * String 对应基本类型 char. */ private void testString() { System.out.println("测试 String"); String src = new String("world"); System.out.println(src); procsString(src); System.out.println(src); } /** * 该方法中处理参数 src * @param src */ private void procsString(String src) { src += "hello"; } /** * 测试 Integer 类型. * Integer 对应基本类型 int. */ private void testInteger() { System.out.println("测试 Integer"); Integer src = new Integer(500); //Integer src = 500; System.out.println(src); procsInteger(src); System.out.println(src); } /** * 该方法中处理参数 src * @param src */ private void procsInteger(Integer src) { src += 500; } /** * 测试 Float 类型. * Float 对应基本类型 float. */ private void testFloat() { System.out.println("测试 Float"); Float src = new Float(123.45); System.out.println(src); procsFloat(src); System.out.println(src); } /** * 该方法中处理参数 src * @param src */ private void procsFloat(Float src) { src += 500.00; } /** * 测试参数是普通类的对象的情况. * 此时是传递的是引用. */ private void testT() { System.out.println("测试 普通类对象"); T src = new T(); src.num = 100; src.str = "hello"; System.out.println(src.str + ", " + src.num); procsT(src); System.out.println(src.str + ", " + src.num); } /** * 该方法中处理参数 src * @param src */ private void procsT(T src) { src.num = 500; src.str = "hello world"; } public static void main(String []argv) { TestTransfValueFunction test = new TestTransfValueFunction(); test.testString(); test.testInteger(); test.testFloat(); test.testT(); } } class T { public String str; public Integer num; public void setStr(String str) { this.str = str; } public String getStr() { return this.str; } public void setNum(Integer num) { this.num = num; } public Integer getNum() { return this.num; } }
运行结果：

[plain] view plain copy print ?

1. 测试 String  
2. world  
3. world  
4. 测试 Integer  
5. 500  
6. 500  
7. 测试 Float  
8. 123.45  
9. 123.45  
10. 测试 普通类对象  
11. hello, 100  
12. hello world, 500