C# VS Java

時間 2019-12-14

標籤 c# java 欄目 C# 简体版

原文原文鏈接

摘要：C#的語言規範由Microsoft的Anders Hejlsberg與Scott Wiltamuth編寫。在當前Microsoft天花亂墜的宣傳中，對C#和C++、Java做一番比較老是頗有趣的。

　　1、C#、C++和Javajava

　　C#的語言規範由Microsoft的Anders Hejlsberg與Scott Wiltamuth編寫。在當前Microsoft天花亂墜的宣傳中，對C#和C++、Java做一番比較老是頗有趣的。考慮到當前IT媒體的輿論傾向，若是你早就知道C#更接近Java而不是C++，事情也不值得大驚小怪。顯然，結論應該是：Java和C#雖然不是孿生子，但C#最主要的特點卻更接近 Java而不是C++。編程

表1：比較C#、C++和Java最重要的功能
功能	C#	C++	Java
繼承	容許繼承單個類，容許實現多個接口	容許從多個類繼承	容許繼承單個類，容許實現多個接口
接口實現	經過「interface」關鍵詞	經過抽象類	經過「interface」關鍵詞
內存管理	由運行時環境管理，使用垃圾收集器	須要手工管理	由運行時環境管理，使用垃圾收集器
指針	支持，但只在不多使用的非安全模式下才支持。一般以引用取代指針	支持，一種很經常使用的功能。	徹底不支持。代之以引用。
源代碼編譯後的形式	.NET中間語言（IL）	可執行代碼	字節碼
單一的公共基類	是	否	是
異常處理	異常處理	返回錯誤	異常處理。

　　下面將說說C#和Java的一些重要區別。數組

　　2、語言規範的比較

　　2.一、簡單數據類型

　　簡單數據類型（Primitive）在C#中稱爲值類型，C#預約義的簡單數據類型比Java多。例如，C#有unit，即無符號整數。表2列出了全部C#的預約義數據類型：安全

表2：C#中的值類型
類型	說明
object	全部類型的最終極的基類
string	字符串類型；字符串是一個Unicode字符的序列
sbyte	8位帶符號整數
short	16位帶符號整數
int	32位帶符號整數
long	64位帶符號整數
byte	8位無符號整數
ushort	16位無符號整數
uint	32位無符號整數
ulong	64位無符號整數
float	單精度浮點數類型
double	雙精度浮點數類型
bool	布爾類型；bool值或者是true，或者是false
char	字符類型；一個char值便是一個Unicode字符
decimal	有28位有效數字的高精度小數類型

　　2.二、常量

　　忘掉Java中的static final修飾符。在C#中，常量能夠用const關鍵詞聲明。編程語言

public const int x = 55;

　　此外，C#的設計者還增長了readonly關鍵詞。若是編譯器編譯時未能肯定常量值，你可使用readonly關鍵詞。readonly域只能經過初始化器或類的構造函數設置。函數

　　2.三、公用類的入口點

　　在Java中，公用類的入口點是一個名爲main的公用靜態方法。main方法的參數是String對象數組，它沒有返回值。在C#中，main方法變成了公用靜態方法Main（大寫的M），Main方法的參數也是一個String對象數組，並且也沒有返回值，以下面的原型聲明所示：性能

public static void Main(String[] args)

　　可是，C#的Main方法不侷限於此。若是不向Main方法傳遞任何參數，你可使用上述Main方法的一個重載版本，即不帶參數列表的版本。也就是說，下面的Main方法也是一個合法的入口點：測試

public static void Main()

　　另外，若是你認爲有必要的話，Main方法還能夠返回一個int。例如，下面代碼中的Main方法返回1：ui

using System;
public class Hello {
public static int Main() {
Console.WriteLine("Done");
return 1;
}
}

　　與此相對，在Java中重載main方法是不合法的。this

　　2.四、switch語句

　　在Java中，switch語句只能處理整數。但C#中的switch語句不一樣，它還可以處理字符變量。請考慮下面用switch語句處理字符串變量的C#代碼：

using System;
public class Hello {
public static void Main(String[] args) {
switch (args[0]) {
case "老闆":
Console.WriteLine("早上好！咱們隨時準備爲您效勞！");
break;
case "僱員":
Console.WriteLine("早上好！你能夠開始工做了！");
break;
default:
Console.WriteLine("早上好！祝你好運！");
break;
}
}
}

　　與Java中的switch不一樣，C#的switch語句要求每個case塊或者在塊的末尾提供一個break語句，或者用goto轉到switch內的其餘case標籤。

　　2.五、foreach語句

　　foreach語句枚舉集合中的各個元素，爲集合中的每個元素執行一次代碼塊。請參見下面的例子。

using System;
public class Hello {
public static void Main(String[] args) {
foreach (String arg in args)
Console.WriteLine(arg);
}
}

　　若是在運行這個執行文件的時候指定了參數，好比「Hello Peter Kevin Richard」，則程序的輸出將是下面幾行文字：

Peter
Kevin
Richard

　　2.六、C#沒有>>>移位操做符

　　C#支持uint和ulong之類的無符號變量類型。所以，在C#中，右移操做符（即「>>」）對於無符號變量類型和帶符號變量類型（好比int和long）的處理方式不一樣。右移uint和ulong丟棄低位並把空出的高位設置爲零；但對於int和long類型的變量，「>>」操做符丟棄低位，同時，只有當變量值是正數時，「>>」才把空出的高位設置成零；若是「>>」操做的是一個負數，空出的高位被設置成爲1。

　　Java中不存在無符號的變量類型。所以，咱們用「>>>」操做符在右移時引入負號位；不然，使用「>>」操做符。

　　2.七、goto關鍵詞

　　Java不用goto關鍵詞。在C#中，goto容許你轉到指定的標籤。不過，C#以特別謹慎的態度對待goto，好比它不容許goto轉入到語句塊的內部。在Java中，你能夠用帶標籤的語句加上break或continue取代C#中的goto。

　　2.八、聲明數組

　　在Java中，數組的聲明方法很是靈活，實際上有許多種聲明方法都屬於合法的方法。例如，下面的幾行代碼是等價的：

int[] x = { 0, 1, 2, 3 };
int x[] = { 0, 1, 2, 3 };

　　但在C#中，只有第一行代碼合法，[]不能放到變量名字以後。

　　2.九、包

　　在C#中，包（Package）被稱爲名稱空間。把名稱空間引入C#程序的關鍵詞是「using」。例如，「using System;」這個語句引入了System名稱空間。

　　然而，與Java不一樣的是，C#容許爲名稱空間或者名稱空間中的類指定別名：

using TheConsole = System.Console;
public class Hello {
public static void Main() {
TheConsole.WriteLine("使用別名");
}
}

　　雖然從概念上看，Java的包相似於.NET的名稱空間。然而，二者的實現方式不一樣。在Java中，包的名字同時也是實際存在的實體，它決定了放置.java文件的目錄結構。在C#中，物理的包和邏輯的名稱之間是徹底分離的，也就是說，名稱空間的名字不會對物理的打包方式產生任何影響。在C#中，每個源代碼文件能夠從屬於多個名稱空間，並且它能夠容納多個公共類。

　　.NET中包的實體稱爲程序集（Assembly）。每個程序集包含一個manifest結構。manifest列舉程序集所包含的文件，控制哪些類型和資源被顯露到程序集以外，並把對這些類型和資源的引用映射到包含這些類型與資源的文件。程序集是自包含的，一個程序集能夠放置到單一的文件以內，也能夠分割成多個文件。.NET的這種封裝機制解決了DLL文件所面臨的問題，即臭名昭著的DLL Hell問題。

　　2.十、默認包

　　在Java中，java.lang包是默認的包，它無需顯式導入就已經自動包含。例如，要把一些文本輸出到控制檯，你可使用下面的代碼：

System.out.println("Hello world from Java");

　　C#中不存在默認的包。若是要向控制檯輸出文本，你使用System名稱空間Console對象的WriteLine方法。可是，你必須顯式導入全部的類。代碼以下：

　　2.十一、面向對象

　　Java和C#都是徹底面向對象的語言。在面向對象編程的三大原則方面，這兩種語言接近得不能再接近。

繼承：這兩種語言都支持類的單一繼承，但類能夠實現多個接口。全部類都從一個公共的基類繼承。
封裝與可見性：不管是在Java仍是C#中，你均可以決定類成員是否可見。除了C#的internal訪問修飾符以外，二者的可見性機制很是類似。
多態性：Java和C#都支持某些形式的多態性機制，且二者實現方法很是相似。

　　2.十二、可訪問性

　　類的每一個成員都有特定類型的可訪問性。C#中的訪問修飾符與Java中的基本對應，但多出了一個internal。簡而言之，C#有5種類型的可訪問性，以下所示：

public：成員能夠從任何代碼訪問。
protected：成員只能從派生類訪問。
internal：成員只能從同一程序集的內部訪問。
protected internal：成員只能從同一程序集內的派生類訪問。
private：成員只能在當前類的內部訪問。

　　2.1三、派生類

　　在Java中，咱們用關鍵詞「extends」實現繼承。C#採用了C++的類派生語法。例如，下面的代碼顯示瞭如何派生父類Control從而建立出新類Button：

public class Button: Control { . . }

　　2.1四、最終類

　　因爲C#中不存在final關鍵詞，若是想要某個類再也不被派生，你可使用sealed關鍵詞，以下例所示：

sealed class FinalClass { . . }

　　2.1五、接口

　　接口這個概念在C#和Java中很是類似。接口的關鍵詞是interface，一個接口能夠擴展一個或者多個其餘接口。按照慣例，接口的名字以大寫字母「I」開頭。下面的代碼是C#接口的一個例子，它與Java中的接口徹底同樣：

interface IShape { void Draw(); }

　　擴展接口的語法與擴展類的語法同樣。例如，下例的IRectangularShape接口擴展IShape接口（即，從IShape接口派生出IRectangularShape接口）。

interface IRectangularShape: IShape { int GetWidth(); }

　　若是你從兩個或者兩個以上的接口派生，父接口的名字列表用逗號分隔，以下面的代碼所示：

interface INewInterface: IParent1, IParent2 { }

　　然而，與Java不一樣，C#中的接口不能包含域（Field）。

　　另外還要注意，在C#中，接口內的全部方法默認都是公用方法。在Java中，方法聲明能夠帶有public修飾符（即便這並不是必要），但在C#中，顯式爲接口的方法指定public修飾符是非法的。例如，下面的C#接口將產生一個編譯錯誤。

interface IShape { public void Draw(); }

　　2.1六、is和as操做符

　　C#中的is操做符與Java中的instanceof操做符同樣，二者均可以用來測試某個對象的實例是否屬於特定的類型。在Java中沒有與C#中的as操做符等價的操做符。as操做符與is操做符很是類似，但它更富有「進取心」：若是類型正確的話，as操做符會嘗試把被測試的對象引用轉換成目標類型；不然，它把變量引用設置成null。

　　爲正確理解as操做符，首先請考慮下面這個例子中is操做符的運用。這個例子包含一個IShape接口，以及兩個實現了IShape接口的類Rectangle和Circle。

using System;
interface IShape {
void draw();
}
public class Rectangle: IShape {
public void draw() {
}
public int GetWidth() {
return 6;
}
}
public class Circle: IShape {
public void draw() {
}
public int GetRadius() {
return 5;
}
}
public class LetsDraw {
public static void Main(String[] args) {
IShape shape = null;
if (args[0] == "rectangle") {
shape = new Rectangle();
}
else if (args[0] == "circle") {
shape = new Circle();
}
if (shape is Rectangle) {
Rectangle rectangle = (Rectangle) shape;
Console.WriteLine("Width : " + rectangle.GetWidth());
}
if (shape is Circle) {
Circle circle = (Circle) shape;
Console.WriteLine("Radius : " + circle.GetRadius());
}
}
}

　　編譯好代碼以後，用戶能夠輸入「rectangle」或者「circle」做爲Main方法的參數。若是用戶輸入的是「circle」，則shape被實例化成爲一個Circle類型的對象；反之，若是用戶輸入的是「rectangle」，則shape被實例化成爲Rectangle類型的對象。隨後，程序用is操做符測試shape的變量類型：若是shape是一個矩形，則shape被轉換成爲Rectangle對象，咱們調用它的GetWidth方法；若是shape是一個圓，則shape被轉換成爲一個Circle對象，咱們調用它的GetRadius方法。

　　若是使用as操做符，則上述代碼能夠改爲以下形式：

using System;
interface IShape {
void draw();
}
public class Rectangle: IShape {
public void draw() {
}
public int GetWidth() {
return 6;
}
}
public class Circle: IShape {
public void draw() {
}
public int GetRadius() {
return 5;
}
}
public class LetsDraw {
public static void Main(String[] args) {
IShape shape = null;
if (args[0] == "rectangle") {
shape = new Rectangle();
}
else if (args[0] == "circle") {
shape = new Circle();
}
Rectangle rectangle = shape as Rectangle;
if (rectangle != null) {
Console.WriteLine("Width : " + rectangle.GetWidth());
}
else {
Circle circle = shape as Circle;
if (circle != null)
Console.WriteLine("Radius : " + circle.GetRadius());
}
}
}

　　在上面代碼的粗體部分中，咱們在沒有測試shape對象類型的狀況下，就用as操做符把shape轉換成Rectangle類型的對象。若是shape正好是一個Rectangle，則shape被轉換成爲Rectangle類型的對象並保存到rectangle變量，而後咱們調用它的GetWidth方法。若是這種轉換失敗，則咱們進行第二次嘗試。這一次，shape被轉換成爲Circle類型的對象並保存到circle變量。若是shape確實是一個Circle對象，則circle如今引用了一個Circle對象，咱們調用它的GetRadius方法。

　　2.1七、庫

　　C#沒有本身的類庫。可是，C#共享了.NET的類庫。固然，.NET類庫也能夠用於其餘.NET語言，好比VB.NET或者JScript.NET。值得一提的是StringBuilder類，它是對String類的補充。StringBuilder類與Java的StringBuffer類很是類似。

　　2.1八、垃圾收集

　　C++已經讓咱們認識到手工管理內存是多麼缺少效率和浪費時間。當你在C++中建立了一個對象，你就必須手工地拆除這個對象。代碼越複雜，這個任務也越困難。Java用垃圾收集器來解決這個問題，由垃圾收集器蒐集再也不使用的對象並釋放內存。C#一樣採用了這種方法。應該說，若是你也在開發一種新的OOP語言，追隨這條道路是一種很是天然的選擇。C#仍舊保留了C++的內存手工管理方法，它適合在速度極端重要的場合使用，而在Java中這是不容許的。

　　2.1九、異常處理

　　若是你據說C#使用與Java類似的異常處理機制，你不會爲此而驚訝，對吧？在C#中，全部的異常都從一個名爲Exception的類派生（聽起來很熟悉？）另外，正如在Java中同樣，你還有熟悉的try和catch語句。Exception類屬於.NET System名稱空間的一部分。

　　3、Java沒有的功能

　　C#出生在Java成熟以後，所以，C#擁有一些Java（目前）尚未的絕妙功能也就不足爲奇。

　　3.一、枚舉器

　　枚舉器即enum類型（Enumerator，或稱爲計數器），它是一個相關常量的集合。精確地說，enum類型聲明爲一組相關的符號常量定義了一個類型名字。例如，你能夠建立一個名爲Fruit（水果）的枚舉器，把它做爲一個變量值的類型使用，從而把變量可能的取值範圍限制爲枚舉器中出現的值。

public class Demo {
public enum Fruit {
Apple, Banana, Cherry, Durian
}
public void Process(Fruit fruit) {
switch (fruit) {
case Fruit.Apple:
...
break;
case Fruit.Banana:
...
break;
case Fruit.Cherry:
...
break;
case Fruit.Durian:
...
break;
}
}
}

　　在上例的Process方法中，雖然你能夠用int做爲myVar變量的類型，可是，使用枚舉器Fruit以後，變量的取值範圍限制到了Applet、Banana、Cherry和Durian這幾個值以內。與int相比，enum的可讀性更好，自我說明能力更強。

　　3.二、結構

　　結構（Struct）與類很類似。然而，類是做爲一種引用類型在堆中建立，而結構是一種值類型，它存儲在棧中或者是嵌入式的。所以，只要謹慎運用，結構要比類快。結構能夠實現接口，能夠象類同樣擁有成員，但結構不支持繼承。

　　然而，簡單地用結構來取代類可能致使慘重損失。這是由於，結構是以值的方式傳遞，因爲這種傳遞方式要把值複製到新的位置，因此傳遞一個「肥胖的」結構須要較大的開銷。而對於類，傳遞的時候只需傳遞它的引用。

下面是一個結構的例子。注意它與類很是類似，只要把單詞「struct」替換成「class」，你就獲得了一個類。

struct Point {
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}

　　3.三、屬性

　　C#類除了能夠擁有域（Field）以外，它還能夠擁有屬性（Property）。屬性是一個與類或對象關聯的命名的特徵。屬性是域的一種天然擴展——二者都是有類型、有名字的類成員。然而，和域不一樣的是，屬性不表示存儲位置；相反，屬性擁有存取器（accessor），存取器定義了讀取或者寫入屬性值時必須執行的代碼。所以，屬性提供了一種把動做和讀取、寫入對象屬性值的操做關聯起來的機制，並且它們容許屬性值經過計算獲得。

在C#中，屬性經過屬性聲明語法定義。屬性聲明語法的第一部分與域聲明很類似，第二部分包括一個set過程和/或一個get過程。例如，在下面的例子中，PropertyDemo類定義了一個Prop屬性。

public class PropertyDemo {
private string prop;
public string Prop {
get {
return prop;
}
set {
prop = value;
}
}
}

　　若是屬性既容許讀取也容許寫入，如PropertyDemo類的Prop屬性，則它同時擁有get和set存取過程。當咱們讀取屬性的值時，get存取過程被調用；當咱們寫入屬性值時，set存取過程被調用。在set存取過程當中，屬性的新值在一個隱含的value參數中給出。

　　與讀取和寫入域的方法同樣，屬性也能夠用一樣的語法讀取和寫入。例如，下面的代碼實例化了一個PropertyDemo類，而後寫入、讀取它的Prop屬性。

PropertyDemo pd = new PropertyDemo();
pd.Prop = "123"; // set
string s = pd.Prop; // get

　　3.四、以引用方式傳遞簡單數據類型的參數

　　在Java中，當你把一個簡單數據類型的值做爲參數傳遞給方法時，參數老是以值的方式傳遞——即，系統將爲被調用的方法建立一個參數值的副本。在C#中，你能夠用引用的方式傳遞一個簡單數據類型的值。此時，被調用的方法將直接使用傳遞給它的那個值——也就是說，若是在被調用方法內部修改了參數的值，則原來的變量值也隨之改變。

　　在C#中以引用方式傳遞值時，咱們使用ref關鍵詞。例如，若是編譯並運行下面的代碼，你將在控制檯上看到輸出結果16。注意i值被傳遞給ProcessNumber以後是如何被改變的。

using System;
public class PassByReference {
public static void Main(String[] args) {
int i = 8;
ProcessNumber(ref i);
Console.WriteLine(i);
}
public static void ProcessNumber(ref int j) {
j = 16;
}
}

　　C#中還有一個容許以引用方式傳遞參數的關鍵詞out，它與ref類似。可是，使用out時，做爲參數傳遞的變量在傳遞以前沒必要具備已知的值。在上例中，若是整數i在傳遞給ProcessNumber方法以前沒有初始化，則代碼將出錯。若是用out來取代ref，你就能夠傳遞一個未經初始化的值，以下面這個修改後的例子所示。

using System;
public class PassByReference {
public static void Main(String[] args) {
int i;
ProcessNumber(out i);
Console.WriteLine(i);
}
public static void ProcessNumber(out int j) {
j = 16;
}
}

　　通過修改以後，雖然i值在傳遞給ProcessNumber方法以前沒有初始化，但PassByReference類可以順利經過編譯。

　　3.五、C#保留了指針

　　對於那些以爲本身可以恰到好處地運用指針並樂意手工進行內存管理的開發者來講，在C#中，他們仍舊能夠用既不安全也不容易使用的「古老的」指針來提升程序的性能。C#提供了支持「不安全」（unsafe）代碼的能力，這種代碼可以直接操做指針，可以「固定」對象以便臨時地阻止垃圾收集器移動對象。不管從開發者仍是用戶的眼光來看，這種對「不安全」代碼的支持實際上是一種安全功能。「不安全」的代碼必須用unsafe關鍵詞顯式地標明，所以開發者不可能在無心之中使用「不安全」的代碼。同時，C#編譯器又和執行引擎協做，保證了「不安全」的代碼不能假裝成爲安全代碼。

using System;
class UsePointer {
unsafe static void PointerDemo(byte[] arr) {
.
.
}
}

　　C#中的unsafe代碼適合在下列情形下使用：當速度極端重要時，或者當對象須要與現有的軟件（好比COM對象或者DLL形式的C代碼）交互時。

　　3.六、代理

　　代理（delegate）能夠看做C++或者其餘語言中的函數指針。然而，與函數指針不一樣的是，C#中的代理是面向對象的、類型安全的、可靠的。並且，函數指針只能用來引用靜態函數，但代理既可以引用靜態方法，也可以引用實例方法。代理用來封裝可調用方法。你能夠在類裏面編寫方法並在該方法上建立代理，此後這個代理就能夠被傳遞到第二個方法。這樣，第二個方法就能夠調用第一個方法。

　　代理是從公共基類System.Delegate派生的引用類型。定義和使用代理包括三個步驟：聲明，建立實例，調用。代理用delegate聲明語法聲明。例如，一個不須要參數且沒有返回值的代理能夠用以下代碼聲明：

delegate void TheDelegate();

　　建立代理實例的語法是：使用new關鍵詞，並引用一個實例或類方法，該方法必須符合代理指定的特徵。一旦建立了代理的實例，咱們就能夠用調用方法的語法調用它。

　　3.七、包裝和解除包裝

　　在面向對象的編程語言中，咱們一般使用的是對象。但爲了提升速度，C#也提供了簡單數據類型。所以，C#程序既包含一大堆的對象，又有大量的值。在這種環境下，讓這二者協同工做始終是一個不可迴避的問題，你必需要有一種讓引用和值進行通訊的方法。

　　在C#以及.NET運行時環境中，這個「通訊」問題經過包裝（Boxing）和解除包裝（Unboxing）解決。包裝是一種讓值類型看起來象引用類型的處理過程。當一個值類型（簡單數據類型）被用於一個要求或者可使用對象的場合時，包裝操做自動進行。包裝一個value-type值的步驟包括：分配一個對象實例，而後把value-type值複製到對象實例。

　　解除包裝所執行的動做與包裝相反，它把一個引用類型轉換成值類型。解除包裝操做的步驟包括：首先檢查並確認對象實例確實是給定value-type的一個通過包裝的值，而後從對象實例複製出值。

　　Java對該問題的處理方式略有不一樣。Java爲每一種簡單數據類型提供了一個對應的類封裝器。例如，用Integer類封裝int類型，用Byte類封裝byte類型。