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

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

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

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

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

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

你看 java:?

A a = new A(1);?

A b = new A(2);?

b = a;?

沒有問題，a 和 b引用同一個對象A(2)，原來的A(1)成為沒有被引用的對象。 垃圾回收機(jī)制會在之后的某個時刻把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 )?

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

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

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

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

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

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

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

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

具體應(yīng)用：

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

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

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

int a=1;int *p=a;

int a=1;int b=a;

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

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

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

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

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

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

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

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

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

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

#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;

}

結(jié)果為2 1；

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

再看一個程序;

#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;

}

運(yùn)行結(jié)果為：

0x22ff44 1

指針p為NULL

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

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

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

在講引用作為函數(shù)參數(shù)進(jìn)行傳遞時，實(shí)質(zhì)上傳遞的是實(shí)參本身，即傳遞進(jìn)來的不是實(shí)參的一個拷貝，因此對形參的修改其實(shí)是對實(shí)參的修改，所以在用引用進(jìn)行參數(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;

}

輸出結(jié)果為： 0x22ff44 1

0x22ff44 1

再看下這個程序：

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

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

#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;

}

輸出結(jié)果為：0x22ff44 1

指針p不為NULL

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

引言

我選擇寫?C++?中的引用是因?yàn)槲腋杏X大多數(shù)人誤解了引用。而我之所以有這個感受是因?yàn)槲抑鞒诌^很多?C++?的面試，并且我很少從面試者中得到關(guān)于?C++?引用的正確答案。

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

背景

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

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

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

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

下面是一段使用引用的簡單?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;

}

引用其實(shí)就是?c++?中的指針常量。表達(dá)式???int i = j;?將會被編譯器轉(zhuǎn)化成?int *const i = j;?而引用之所以要初始化是因?yàn)?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;

}

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

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

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

[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;

}

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

[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;

}

結(jié)論

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

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

[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ù)機(jī)制。如果引用僅僅是一個別名，那如何實(shí)現(xiàn)虛函數(shù)機(jī)制，而虛函數(shù)機(jī)制所需要的動態(tài)信息只能通過指針才能實(shí)現(xiàn)，所以更加說明引用其實(shí)就是一個?const?指針。

補(bǔ)充：const 指針（指針常量）與指向const的指針（常量指針）

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

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

const?int* p; （推薦）

int?const* p;

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

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

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

int* const p=一個地址; (因?yàn)橹羔槺旧淼闹凳遣荒鼙恍薷牡乃运仨毐怀跏蓟?/p>

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

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

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

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

看了上面的內(nèi)容是不是有點(diǎn)暈，沒關(guān)系，你不用去背它，用的多了就知道了，還有個技巧，通過上面的觀察我們不難總結(jié)出一點(diǎn)規(guī)律，是什么呢？也許你已經(jīng)看出來了，什么！竟然沒看也來，那只好還得聽我嘮叨了。這個規(guī)律就是： 指向const的指針（指針指向的內(nèi)容不能被修改）const關(guān)健字總是出現(xiàn)在*的左邊而const指針（指針本身不能被修改）const關(guān)健字總是出現(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)典的面向過程的編程語言，編程入門一般都學(xué)C語言以了解編程以及鍛煉邏輯思維能力，在一些跟硬件比較緊密的編程中也經(jīng)常用到。\x0d\x0a\x0d\x0aC++是在C語言的基礎(chǔ)上加入了面向?qū)ο蟮母拍?，成為混合型面向?qū)ο笳Z言，功能強(qiáng)大，但難度也大。\x0d\x0a\x0d\x0aJava是在C++的基礎(chǔ)上進(jìn)行改進(jìn)的，摒棄了一些C++的不足之處，語法跟C++很像，它是運(yùn)行在Java虛擬機(jī)上，所以可以跨平臺，一處編譯，到處執(zhí)行。\x0d\x0a\x0d\x0a編程都是易學(xué)難精，哪個都好學(xué)，哪個又都不好學(xué)。都有很好的發(fā)展前景，就看是什么方向了。底層的C、桌面應(yīng)用程序、游戲等等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#都是編程的語言，它們是兩個不同方向的兩種語言

相同點(diǎn):

他們都是面向?qū)ο蟮恼Z言,也就是說,它們都能實(shí)現(xiàn)面向?qū)ο蟮乃枷?封裝,繼承,多態(tài))

區(qū)別：

1.c#中的命名空間是namespace類似于Java中的package（包），在Java中導(dǎo)入包用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．?dāng)?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．?dāng)?shù)組：兩種語言的聲明都是用new關(guān)鍵字的。都可以在創(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#的引用傳遞的關(guān)鍵字是ref與out，ref側(cè)重于修改，out側(cè)重于輸出。而Java中都以傳值方式;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

廣告

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