Java引用和C++引用的區(qū)別

c++ 與java引用具體比較：

讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領域值得信任、有價值的長期合作伙伴，公司提供的服務項目有：申請域名、網(wǎng)頁空間、營銷軟件、網(wǎng)站建設、福山網(wǎng)站維護、網(wǎng)站推廣。

c++中一個引用指向的地址不會改變，改變的是指向地址的內(nèi)容，然而java中引用指向的地址在變?。?/p>

如果非要對比著看，那么Java中的“引用”倒是和C/C++的指針更像一些，和C++的“引用”很不一樣。

java去除指針概念，就用引用羅...?

你看 java:?

A a = new A(1);?

A b = new A(2);?

b = a;?

沒有問題，a 和 b引用同一個對象A(2)，原來的A(1)成為沒有被引用的對象。 垃圾回收機制會在之后的某個時刻把A(1)干掉。?

而C++則不然。C++的引用就語義上說是“別名”【本質(zhì)是個const指針，又叫指針常量】，而并不是指針的另一種用法：?

A a = A(1);?

A b = A(2);?

A c = b; //c 是 b的別名?

c = a; //并不是 c 引用 a，而是拷貝操作 c.operator= ( a )?

就語言機制來說，java的引用是用來管理和命名對象；?

而，C++的引用機制是很純粹的，就是別名而已。?

每種語言的特性都是整體的有機部分。?

我們知道， java的引用機制是一個很復雜的機制。他必須區(qū)分“基本對象”和“復合對象”，你可以想象一下，如果其中沒有基本對象，那么我們?nèi)绾瓮瓿蓪ο蟮膹椭疲?唯一的解決方案是提供兩個等于號，或者一律用構造函數(shù).... 但是綜合來看，他和垃圾回收形成了相當完美的組合方案。

而C++ 的引用機制為運算符重載提供了大幅度的支持。C++ 的引用是用類“模擬”基本對象的根本要求。 如果C++使用java那種引用，那么原本漂亮的 operator[]、 proxy class 等就很難實現(xiàn)了。 更進一步， C++ 的運算符重載對 C++ 的模版機制提供了強力的支持

在c＋＋中，引用只是對于一個變量起的別名，一旦定義就無法修改，即無法再指向其他變量，如程序中，對于a的引用的任何操作都等同于對于a的操作。?

java定義的引用并不是這樣。在java中，引用相當與指針，它與c中的指針主要有兩個區(qū)別：一是引用不能進行地址操作，如數(shù)組的加一 操作，相當于引用只是只是指向數(shù)據(jù)的一個副本，而不是數(shù)據(jù)本身，這樣就避免了由于對于地址的誤操作而改變其他變量的值，甚至危害到系統(tǒng)的安全。二是 java中的引用只能指向對象，他的引用是在實例化對象時系統(tǒng)直接生成的，因此對于普通數(shù)據(jù)類型是不能進行引用定義的，如果要對普通數(shù)據(jù)類型進行函數(shù)調(diào)用 時的地址傳遞（即java中的引用傳遞），必須把數(shù)據(jù)封裝到類中。

java的這種特性使得在java的函數(shù)或類的參數(shù)傳遞時可以實現(xiàn)與c中指針相同的功能。?

具體應用：

指針和引用在C++中很常用，但是對于它們之間的區(qū)別很多初學者都不是太熟悉，下面來談談他們2者之間的區(qū)別和用法。

1.指針和引用的定義和性質(zhì)區(qū)別：

(1)指針：指針是一個變量，只不過這個變量存儲的是一個地址，指向內(nèi)存的一個存儲單元；而引用跟原來的變量實質(zhì)上是同一個東西，只不過是原變量的一個別名而已。如：

int a=1;int *p=a;

int a=1;int b=a;

上面定義了一個整形變量和一個指針變量p，該指針變量指向a的存儲單元，即p的值是a存儲單元的地址。

而下面2句定義了一個整形變量a和這個整形a的引用b，事實上a和b是同一個東西，在內(nèi)存占有同一個存儲單元。

(2)可以有const指針，但是沒有const引用；

(3)指針可以有多級，但是引用只能是一級（int **p；合法 而 int a是不合法的）

(4)指針的值可以為空，但是引用的值不能為NULL，并且引用在定義的時候必須初始化；

(5)指針的值在初始化后可以改變，即指向其它的存儲單元，而引用在進行初始化后就不會再改變了。

(6)"sizeof引用"得到的是所指向的變量(對象)的大小，而"sizeof指針"得到的是指針本身的大小；

(7)指針和引用的自增(++)運算意義不一樣；

2.指針和引用作為函數(shù)參數(shù)進行傳遞時的區(qū)別。

(1)指針作為參數(shù)進行傳遞：

#includeiostreamusing namespace std;void swap(int *a,int *b)

{

int temp=*a;

*a=*b;

*b=temp;

}int main(void)

{

int a=1,b=2;

swap(a,b);

couta" "bendl;

system("pause");

return 0;

}

結果為2 1；

用指針傳遞參數(shù)，可以實現(xiàn)對實參進行改變的目的，是因為傳遞過來的是實參的地址，因此使用*a實際上是取存儲實參的內(nèi)存單元里的數(shù)據(jù)，即是對實參進行改變，因此可以達到目的。

再看一個程序;

#includeiostreamusing namespace std;void test(int *p)

{

int a=1;

p=a;

coutp" "*pendl;

}int main(void)

{ ? ?int *p=NULL;

test(p); ? ?if(p==NULL)

cout"指針p為NULL"endl;

system("pause"); ? ?return 0;

}

運行結果為：

0x22ff44 1

指針p為NULL

大家可能會感到奇怪，怎么回事，不是傳遞的是地址么，怎么p回事NULL？事實上，在main函數(shù)中聲明了一個指針p，并賦值為NULL，當調(diào)用test函數(shù)時，事實上傳遞的也是地址，只不過傳遞的是指地址。也就是說將指針作為參數(shù)進行傳遞時，事實上也是值傳遞，只不過傳遞的是地址。當把指針作為參數(shù)進行傳遞時，也是將實參的一個拷貝傳遞給形參，即上面程序main函數(shù)中的p何test函數(shù)中使用的p不是同一個變量，存儲2個變量p的單元也不相同（只是2個p指向同一個存儲單元），那么在test函數(shù)中對p進行修改，并不會影響到main函數(shù)中的p的值。

如果要想達到也同時修改的目的的話，就得使用引用了。

2.將引用作為函數(shù)的參數(shù)進行傳遞。

在講引用作為函數(shù)參數(shù)進行傳遞時，實質(zhì)上傳遞的是實參本身，即傳遞進來的不是實參的一個拷貝，因此對形參的修改其實是對實參的修改，所以在用引用進行參數(shù)傳遞時，不僅節(jié)約時間，而且可以節(jié)約空間。

看下面這個程序：

#includeiostreamusing namespace std;void test(int a)

{

couta" "aendl;

}int main(void)

{ ? ?int a=1;

couta" "aendl;

test(a);

system("pause"); ? ?return 0;

}

輸出結果為： 0x22ff44 1

0x22ff44 1

再看下這個程序：

這足以說明用引用進行參數(shù)傳遞時，事實上傳遞的是實參本身，而不是拷貝。

所以在上述要達到同時修改指針的目的的話，就得使用引用了。

#includeiostreamusing namespace std;void test(int *p)

{

int a=1;

p=a;

coutp" "*pendl;

}int main(void)

{ ? ?int *p=NULL;

test(p); ? ?if(p!=NULL)

cout"指針p不為NULL"endl;

system("pause"); ? ?return 0;

}

輸出結果為：0x22ff44 1

指針p不為NULL

C++ 引用的本質(zhì)？深入分析C++引用：

引言

我選擇寫?C++?中的引用是因為我感覺大多數(shù)人誤解了引用。而我之所以有這個感受是因為我主持過很多?C++?的面試，并且我很少從面試者中得到關于?C++?引用的正確答案。

那么?c++?中引用到底意味這什么呢？通常一個引用讓人想到是一個引用的變量的別名，而我討厭將?c++?中引用定義為變量的別名。這篇文章中，我將盡量解釋清楚，?c++?中根本就沒有什么叫做別名的東東。

背景

在?c/c++?中，訪問一個變量只能通過兩種方式被訪問，傳遞，或者查詢。這兩種方式是：

1.?通過值?訪問?/?傳遞變量

2.?通過地址?訪問?/?傳遞變量?–?這種方法就是指針

除此之外沒有第三種訪問和傳遞變量值的方法。引用變量也就是個指針變量，它也擁有內(nèi)存空間。最關鍵的是引用是一種會被編譯器自動解引用的指針。很難相信么？讓我們來看看吧。。。

下面是一段使用引用的簡單?c++?代碼

[cpp]?view plain?copy?print?

#include?iostream.h

int?main()

{

int?i?=?10;???//?A?simple?integer?variable

int?j?=?i;???//?A?Reference?to?the?variable?i

j++;???//?Incrementing?j?will?increment?both?i?and?j.

//?check?by?printing?values?of?i?and?j

cout??i????j??endl;?//?should?print?11?11

//?Now?try?to?print?the?address?of?both?variables?i?and?j

cout??i????j??endl;

//?surprisingly?both?print?the?same?address?and?make?us?feel?that?they?are

//?alias?to?the?same?memory?location.

//?In?example?below?we?will?see?what?is?the?reality

return?0;

}

引用其實就是?c++?中的指針常量。表達式???int i = j;?將會被編譯器轉化成?int *const i = j;?而引用之所以要初始化是因為?const?類型變量必須初始化，這個指針也必須有所指。下面我們再次聚焦到上面這段代碼，并使用編譯器的那套語法將引用替換掉。

[cpp]?view plain?copy?print?

#include?iostream.h

int?main()

{

int?i?=?10;????????????//?A?simple?integer?variable

int?*const?j?=?i;?????//?A?Reference?to?the?variable?i

(*j)++;????????????????//?Incrementing?j.?Since?reference?variables?are

//?automatically?dereferenced?by?compiler

//?check?by?printing?values?of?i?and?j

cout??i????*j??endl;?//?should?print?11?11

//?A?*?is?appended?before?j?because?it?used?to?be?reference?variable

//?and?it?should?get?automatically?dereferenced.

return?0;

}

讀者一定很奇怪為什么我上面這段代碼會跳過打印地址這步。這里需要一些解釋。因為引用變量時（使用變量時）會被編譯器自動解引用的，那么一個諸如???cout j endl;?的語句，編譯器就會將其轉化成語句???cout *j endl;???現(xiàn)在?*?會相互抵消，這句話變的毫無意義，而?cout?打印的?j?值就是?i?的地址，因為其定義語句為?int *const j = i;

所以語句?cout i j endl;?變成了?cout i *j endl;?這兩種情況都是打印輸出?i?的地址。這就是當我們打印普通變量和引用變量的時候會輸出相同地址的原因。

下面給出一段復雜一些的代碼，來看看引用在級聯(lián)?(cascading)?中是如何運作的。

[cpp]?view plain?copy?print?

#include?iostream.h

int?main()

{

int?i?=?10;?//?A?Simple?Integer?variable

int?j?=?i;?//?A?Reference?to?the?variable

//?Now?we?can?also?create?a?reference?to?reference?variable.

int?k?=?j;?//?A?reference?to?a?reference?variable

//?Similarly?we?can?also?create?another?reference?to?the?reference?variable?k

int?l?=?k;?//?A?reference?to?a?reference?to?a?reference?variable.

//?Now?if?we?increment?any?one?of?them?the?effect?will?be?visible?on?all?the

//?variables.

//?First?print?original?values

//?The?print?should?be?10,10,10,10

cout??i????","????j????","????k????","????l??endl;

//?increment?variable?j

j++;

//?The?print?should?be?11,11,11,11

cout??i????","????j????","????k????","????l??endl;

//?increment?variable?k

k++;

//?The?print?should?be?12,12,12,12

cout??i????","????j????","????k????","????l??endl;

//?increment?variable?l

l++;

//?The?print?should?be?13,13,13,13

cout??i????","????j????","????k????","????l??endl;

return?0;

}

下面這段代碼是將上面代碼中的引用替換之后代碼，也就是說明我們不依賴編譯器的自動替換功能，手動進行替換也能達到相同的目標。

[cpp]?view plain?copy?print?

#include?iostream.h

int?main()

{

int?i?=?10;?????????//?A?Simple?Integer?variable

int?*const?j?=?i;?????//?A?Reference?to?the?variable

//?The?variable?j?will?hold?the?address?of?i

//?Now?we?can?also?create?a?reference?to?reference?variable.

int?*const?k?=?*j;?????//?A?reference?to?a?reference?variable

//?The?variable?k?will?also?hold?the?address?of?i?because?j

//?is?a?reference?variable?and

//?it?gets?auto?dereferenced.?After??and?*?cancels?each?other

//?k?will?hold?the?value?of

//?j?which?it?nothing?but?address?of?i

//?Similarly?we?can?also?create?another?reference?to?the?reference?variable?k

int?*const?l?=?*k;?????//?A?reference?to?a?reference?to?a?reference?variable.

//?The?variable?l?will?also?hold?address?of?i?because?k?holds?address?of?i?after

//??and?*?cancels?each?other.

//?so?we?have?seen?that?all?the?reference?variable?will?actually?holds?the?same

//?variable?address.

//?Now?if?we?increment?any?one?of?them?the?effect?will?be?visible?on?all?the

//?variables.

//?First?print?original?values.?The?reference?variables?will?have?*?prefixed?because

//?these?variables?gets?automatically?dereferenced.

//?The?print?should?be?10,10,10,10

cout??i????","????*j????","????*k????","????*l??endl;

//?increment?variable?j

(*j)++;

//?The?print?should?be?11,11,11,11

cout??i????","????*j????","????*k????","????*l??endl;

//?increment?variable?k

(*k)++;

//?The?print?should?be?12,12,12,12

cout??i????","????*j????","????*k????","????*l??endl;

//?increment?variable?l

(*l)++;

//?The?print?should?be?13,13,13,13

cout????i????","????*j????","????*k????","????*l??endl;

return?0;

}

我們通過下面代碼可以證明?c++?的引用不是神馬別名，它也會占用內(nèi)存空間的。

[cpp]?view plain?copy?print?

#include?iostream.h

class?Test

{

int?i;???//?int?*const?i;

int?j;???//?int?*const?j;

int?k;???//?int?*const?k;

};

int?main()

{

//?This?will?print?12?i.e.?size?of?3?pointers

cout??"size?of?class?Test?=?"?????sizeof(class?Test)??endl;

return?0;

}

結論

我希望這篇文章能把?c++?引用的所有東東都解釋清楚，然而我要指出的是?c++?標準并沒有解釋編譯器如何實現(xiàn)引用的行為。所以實現(xiàn)取決于編譯器，而大多數(shù)情況下就是將其實現(xiàn)為一個?const?指針。

引用支持?c++?虛函數(shù)機制的代碼

[cpp]?view plain?copy?print?

#include?iostream.h

class?A

{

public:

virtual?void?print()?{?cout"A.."endl;?}

};

class?B?:?public?A

{

public:

virtual?void?print()?{?cout"B.."endl;?}

};

class?C?:?public?B

{

public:

virtual?void?print()?{?cout"C.."endl;?}

};

int?main()

{

C?c1;

A?a1?=?c1;

a1.print();?//?prints?C

A?a2?=?c1;

a2.print();?//?prints?A

return?0;

}

上述代碼使用引用支持虛函數(shù)機制。如果引用僅僅是一個別名，那如何實現(xiàn)虛函數(shù)機制，而虛函數(shù)機制所需要的動態(tài)信息只能通過指針才能實現(xiàn)，所以更加說明引用其實就是一個?const?指針。

補充：const 指針（指針常量）與指向const的指針（常量指針）

當使用帶有const的指針時其實有兩種意思。一種指的是你不能修改指針本身的內(nèi)容，另一種指的是你不能修改指針指向的內(nèi)容。聽起來有點混淆一會放個例子上來就明白了。

先說指向const的指針，它的意思是指針指向的內(nèi)容是不能被修改的。它有兩種寫法。

const?int* p; （推薦）

int?const* p;

第一種可以理解為，p是一個指針，它指向的內(nèi)容是const?int?類型。p本身不用初始化它可以指向任何標示符，但它指向的內(nèi)容是不能被改變的。

第二種很容易被理解成是p是一個指向int的const指針（指針本身不能被修改），但這樣理解是錯誤的，它也是表示的是指向const的指針（指針指向的內(nèi)容是不能被修改的），它跟第一種表達的是一個意思。為了避免混淆推薦大家用第一種。

再說const指針，它的意思是指針本身的值是不能被修改的。它只有一種寫法

int* const p=一個地址; (因為指針本身的值是不能被修改的所以它必須被初始化）

這種形式可以被理解為，p是一個指針，這個指針是指向int?的const指針。它指向的值是可以被改變的如*p=3;

還有一種情況是這個指針本身和它指向的內(nèi)容都是不能被改變的，請往下看。

const?int* const p=一個地址;

int?const* const p=一個地址;

看了上面的內(nèi)容是不是有點暈，沒關系，你不用去背它，用的多了就知道了，還有個技巧，通過上面的觀察我們不難總結出一點規(guī)律，是什么呢？也許你已經(jīng)看出來了，什么！竟然沒看也來，那只好還得聽我嘮叨了。這個規(guī)律就是： 指向const的指針（指針指向的內(nèi)容不能被修改）const關健字總是出現(xiàn)在*的左邊而const指針（指針本身不能被修改）const關健字總是出現(xiàn)在*的右邊，那不用說兩個const中間加個*肯定是指針本身和它指向的內(nèi)容都是不能被改變的。有了這個規(guī)則是不是就好記多了。

什么還是暈，那就看下面的程序，你把它編譯一下看看錯誤提示就明白了。

1?#include?iostream

2

3?using?namespace?std;

4

5?int?main(int?argc,?char?*argv[])

6?{

7?????int?a=3;

8?????int?b;

9?????

10?????/*定義指向const的指針（指針指向的內(nèi)容不能被修改）*/?

11?????const?int*?p1;?

12?????int?const*?p2;?

13?????

14?????/*定義const指針(由于指針本身的值不能改變所以必須得初始化）*/?

15?????int*?const?p3=a;?

16?????

17?????/*指針本身和它指向的內(nèi)容都是不能被改變的所以也得初始化*/

18?????const?int*?const?p4=a;

19?????int?const*?const?p5=b;?

20?????

21??????p1=p2=a;?//正確

22??????*p1=*p2=8;?//不正確（指針指向的內(nèi)容不能被修改）

23?????

24??????*p3=5;?//正確

25??????p3=p1;?//不正確（指針本身的值不能改變）?

26?????

27??????p4=p5;//不正確?（指針本身和它指向的內(nèi)容都是不能被改變）?

28??????*p4=*p5=4;?//不正確（指針本身和它指向的內(nèi)容都是不能被改變）?

29??????

30?????return?0;?

31?}

Java和c語言的區(qū)別

C語言是經(jīng)典的面向過程的編程語言，編程入門一般都學C語言以了解編程以及鍛煉邏輯思維能力，在一些跟硬件比較緊密的編程中也經(jīng)常用到。\x0d\x0a\x0d\x0aC++是在C語言的基礎上加入了面向對象的概念，成為混合型面向對象語言，功能強大，但難度也大。\x0d\x0a\x0d\x0aJava是在C++的基礎上進行改進的，摒棄了一些C++的不足之處，語法跟C++很像，它是運行在Java虛擬機上，所以可以跨平臺，一處編譯，到處執(zhí)行。\x0d\x0a\x0d\x0a編程都是易學難精，哪個都好學，哪個又都不好學。都有很好的發(fā)展前景，就看是什么方向了。底層的C、桌面應用程序、游戲等等C++、嵌入式，網(wǎng)頁，Java。

java比較兩字符串是否相等。。。

String?string1?=?"i?love?you";

String?string2?=?"i?love?you";

在棧中分配兩個空間，

其名為string1和string2

其值為兩個相同的同時指向"i?love?you"的地址，"i?love?you"存放在data?segment中只有一個。

String?string3?=?new?String("i?love?you");

String?string4?=?new?String("i?love?you");

在棧中分配兩個空間，

其名為string3和string4

string3指向堆中為new?String("i?love?you");（對象一）

新分配的空間，其值為指向這里的地址

string4指向堆中為new?String("i?love?you")（對象二）

分配的空間；這是另一片空間，其值為指向這里的地址。

C# 和 Java的區(qū)別

Java和C#都是編程的語言，它們是兩個不同方向的兩種語言

相同點:

他們都是面向對象的語言,也就是說,它們都能實現(xiàn)面向對象的思想(封裝,繼承,多態(tài))

區(qū)別：

1.c#中的命名空間是namespace類似于Java中的package（包），在Java中導入包用import而c#中用using。

2.c#和Java都是從main函數(shù)入口的，但是c#中的main函數(shù)的首字母必須大寫，它有四種寫法如下：

static void Main(string args[]){}

static int Main(string args[]){}

static void Main(){}

static void Main(){}

而Java中只有一種形式：static void main(String [] args){}

3．數(shù)據(jù)類型：Java跟c#基本都差不多，但是Java的String類型的首字母必須大寫，而c#中可以小寫也可以大寫，還有布爾型，Java中是boolean，c#中是bool。

4．變量的命名：Java中可以用$符號，而c#中不可以使用。

5．注釋：Java比c#少一種"http:///"的文檔注釋。

6．輸出：c#有三種方式輸出：Cosole.WriteLine(); Cosole.WriteLine(要輸出的值); Cosole.WriteLine("格式字符串"，變量列表); 前兩種的用法與Java中的ystem.out.println()方法的用法相同，第三種方式是根據(jù)占位符輸出的，比Java更方便了。

7．控制流語句：c#跟Java類似,還有c#中的switch如果case后面有內(nèi)容必須要有break;Java可以沒有break；

8．數(shù)組：兩種語言的聲明都是用new關鍵字的。都可以在創(chuàng)建數(shù)組的同時初始化如：int a[]={1,2,3,5,5};但是c#比Java多兩種初始化如：int a[]=new int[3]{1,2,3}; int a[]=new int[]{1,2,3};

9．方法中傳遞的參數(shù)：兩種語言都使用值傳遞與引用傳遞。

C#的引用傳遞的關鍵字是ref與out，ref側重于修改，out側重于輸出。而Java中都以傳值方式;

10．訪問修飾符：C#中的訪問修飾符與Java中的基本對應，但多出了一個internal。簡而言之，C#有5種類型的可訪問性，如下所示：

public：成員可以從任何代碼訪問。 protected：成員只能從派生類訪問。

internal：成員只能從同一程序集的內(nèi)部訪問。

protected：成員只能從同一程序集內(nèi)的派生類訪問。

private：成員只能在當前類的內(nèi)部訪問。

11．由于C#中不存在final關鍵詞，如果想要某個類不再被派生，你可以使用sealed關鍵詞密封。

12．集合：兩種語言都有集合ArrayList，還有通過鍵訪問值的Java中是HashMap而c#中是HashTable。c#比Java多泛型集合ListT與DictionaryK,V更容易了，無需拆箱裝箱了，更安全了。

13．繼承：Java中用關鍵字extends，c#只用"："就行了.調(diào)用父類的構造方法Java用super關鍵字，而c#用base關鍵字。

14．多態(tài)：抽象類和抽象方法兩種語言都用abstract關鍵字。Java中另外一個類如果繼承了它，實現(xiàn)直接重寫此方法就可以了；而c#必須加上關鍵字override實現(xiàn)。C#還比Java多一種虛方法來實現(xiàn)多態(tài)。

15．接口：都用關鍵字interface定義，Java實現(xiàn)用關鍵字implements；c#用"："實現(xiàn)。在C#中，接口內(nèi)的所有方法默認都是公用方法。在Java中，方法聲明可以帶有public修飾符（即使這并非必要），但在C#中，顯式為接口的方法指定public修飾符是非法的。

16．C#中的is操作符與Java中的instanceof操作符一樣，兩者都可以用來測試某個對象的實例是否屬于特定的類型。在Java中沒有與C#中的as操作符等價的操作符。as操作符與is操作符非常相似，但它更富有"進取心"：如果類型正確的話，as操作符會嘗試把被測試的對象引用轉換成目標類型；否則，它把變量引用設置成null。

17．枚舉器即enum類型(java無),把它作為一個變量值的類型使用，從而把變量可能的取值范圍限制為枚舉器中出現(xiàn)的值。

18．結構（Struct）與類很相似,而結構是一種值類型，它存儲在棧中或者是嵌入式的,結構可以實現(xiàn)接口，可以象類一樣擁有成員，但結構不支持繼承。

19．c#保留了指針。Unsafe。(C#使用指針不安全,最后這條有待考證)

網(wǎng)頁標題：java虛引用代碼對比 java引用值是什么
文章路徑：http://chinadenli.net/article0/ddiodoo.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站維護、網(wǎng)站設計、關鍵詞優(yōu)化、小程序開發(fā)、移動網(wǎng)站建設、營銷型網(wǎng)站建設

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉載內(nèi)容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)