以下测试主要为了说明：对传递对象或传递引用进行修改，对最终值的影响情况

1. public class PassTest {
2.     @Before
3.     public void setUp() throws Exception {
4.     }
5.     /**
6.      * 测试对象已经指向具体的值
7.      */
8.     @Test
9.     public void testPass1() {
10.         // 对象的引用已经指向了具体的对象
11.         Human human = new Someone();
12.         Map<String, String> map = new HashMap<>();
13.         getPerson1(human, map);
14.         System.out.println("human1:" + human + ", map1:" + map.toString());
15.         assertEquals("fish", map.get("food"));
16.         assertEquals("大哥", human.getName());
17.     }
18.     /**
19.      * 测试对象的引用尚未指向了具体的对象
20.      */
21.     @Test
22.     public void testPass2() {
23.         // 对象的引用尚未指向了具体的对象
24.         Human human = null;
25.         Map<String, String> map = null;
26.         getPerson2(human, map);
27.         System.out.println("human2:" + human + ", map2:" + map);
28.         assertEquals(null, map);
29.         assertEquals(null, human);
30.     }
31.     /**
32.      * 测试对象的引用已经指向了具体的对象,在调用方法中重新指向另一个对象
33.      */
34.     @Test
35.     public void testPass3() {
36.         // 对象的引用已经指向了具体的对象,在调用方法中重新指向另一个对象
37.         Human human = new Someone();
38.         Map<String, String> map = new HashMap<>();
39.         getPerson3(human, map);
40.         System.out.println("human3:" + human + ", map3:" + map.toString());
41.         assertEquals(0, map.size());
42.         assertEquals(null, human.getName());
43.     }
44.     /**
45.      * 测试对象的引用尚未指向了具体的对象,调用方法中创建对象、赋值，并返回对象的情况
46.      */
47.     @Test
48.     public void testPass4() {
49.         Human human = null;
50.         human = getPerson4();
51.         System.out.println("human4:" + human);
52.         assertEquals("大哥", human.getName());
53.     }
54.     interface Human {
55.         public String getName();
56.         public void setName(String name);
57.         public void eat(Map<String, String> map);
58.     }
59.     class Someone implements Human {
60.         public String name;
61.         public String getName() {
62.             return name;
63.         }
64.         public void setName(String name) {
65.             this.name = name;
66.         }
67.         @Override
68.         public void eat(Map<String, String> map) {
69.             map.put("food", "fish");
70.         }
71.         @Override
72.         public String toString() {
73.             return "Someone [name=" + name + "]";
74.         }
75.     }
76.     public void getPerson1(Human human, Map<String, String> map) {
77.         human.setName("大哥");
78.         human.eat(map);
79.     }
80.     public void getPerson2(Human human, Map<String, String> map) {
81.         human = new Someone();
82.         map = new HashMap<>();
83.         human.setName("大哥");
84.         human.eat(map);
85.     }
86.     private void getPerson3(Human human3, Map<String, String> map3) {
87.         Human human = new Someone();
88.         Map<String, String> map = new HashMap<>();
89.         human.setName("大哥");
90.         human.eat(map);
91.         human3 = human;
92.         map3 = map;
93.     }
94.     private Human getPerson4() {
95.         Human human = new Someone();
96.         human.setName("大哥");
97.         return human;
98.     }
99. }

测试结果：

 

---