???其實可以把Reference理解為一種邏輯上的原子類型的數(shù)據(jù)對象,他的值是對象在內存中的地址,例如,對一個Test類new出了兩個對象object1,object2,那么object1==object2的值就是false的,為什么呢,因為是new了兩次,就是在內存中生成了兩個Test的對象,那么這兩個對象的地址肯定是不一樣的,所以object1==object2就是false了,但是如果只new了一個對象object,而object1和object2都是都是指向obect的reference,那么object1==object2肯定就是true了,因為object1和object2的值是同一個值,是同一個內存地址(一個對象當然只有一個內存地址,要不就是兩個對象了)
??對于Java的參數(shù)傳遞,其實Java的參數(shù)傳遞都是傳值的,也就是說在方法中,行參是對實參的一個復制,對于傳遞對象,其實傳的是這個對象的引用(對象在內存中的地址),在方法體內,行參是這個地址的值(值傳遞),當在方法內修改對象屬性時,就根據(jù)這個內存地址修改在該地址的對象的屬性,這樣實參所指的對象的屬性就被改變了。根據(jù)上邊的講解是很容易理解這一點的,下邊的例子可以更好的說明:
?1
public?class?Test
{
?2
?int?t;
?3
?String?s="hello";
?4
?
?5
?public?static?void?main(String[]?args)
{
?6
??Test?test?=?new?Test();
?7
??System.out.println(test.t);
?8
?9
??test.change1(test);
10
??System.out.println(test.t);
11
?
12
??test.t=0;
13
??test.change2(test);
14
??System.out.println(test.t);
15
???
16
??System.out.println(test.s);
17
?
18
??test.change3(test.s);
19
??System.out.println(test.s);
20
??
21
??test.change4(test);
22
??System.out.println(test.s);
23
????????}
24
?
25
?public?void?change1(Test?test)
{
26
??test.t=5;
27
?}
28
?public?void?change2(Test?test)
{
29
??test?=?new?Test();
30
??test.t=5;
31
?}
32
?
33
??
34
?public?void?change3(String?string)
{
35
??string="hi";
36
?}
37
?
38
?public?void?change4(Test?test)
{
39
??test.s="hi";
40
?}
41
}
42
?
43
?
44
輸出:
45
0
46
5
47
0
48
hello
49
hello
50
hi



?2

?3

?4

?5



?6

?7

?8

?9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25



26

27

28



29

30

31

32

33

34



35

36

37

38



39

40

41

42

43

44

45

46

47

48

49

50
