對於學習一門新的語言，關鍵是學習新語言和以前掌握的語言的區別，但是也不要讓以前語言的東西，固定了自己的思維模式，多看一下新的語言的程式設計思想。

1.引包

  using System;ｊａｖａ用ｉｍｐｏｒｔ
2.建構函式和java語法相同
3.解構函式
  變數和類的物件都有生命週期，生命週期結束，這些變數和物件就要被撤銷。
  類的物件被撤銷時，將自動呼叫解構函式。一些善後工作可放在解構函式中完成。
  解構函式的名字為~類名，無返回型別，也無引數。Person類的解構函式為~ Person()。
  C#中類解構函式不能顯示地被呼叫，它是被垃圾收集器撤銷不被使用的物件時自動呼叫的。
4.C#資料型別
  從大的方面來分，C#語言的資料型別可以分為三種：值型別，引用型別，指標型別，指標型別僅用於非安全程式碼中。
  C#執行在CLR中，其中有垃圾自動回收器，和java類似
  4.1值型別
    簡單型別：
      --數值型別:整數型別、字元型別(char)、浮點數型別和十進位制型別(decimal)
      --布林型別（bool）
      (1)簡單型別也是結構型別，因此有建構函式、資料成員、方法、屬性等;
         因此下列語句int i=int.MaxValue;string s=i.ToString()是正確的;
         即使一個常量，C#也會生成結構型別的例項，因此也可以使用結構型別的方法，
         例如：string s=13.ToString()是正確的。
      (2)
        保留字 | System名稱空間中的名字 | 位元組數  |  取值範圍
        sbyte     System.Sbyte1              1        -128~127
byte      System.Byte                1         0~255
        short     System.Int16               2     -32768~32767
        ushort    System.UInt16              2       0~65535
  int       System.Int32               4      -2147483648~2147483647
uint      System.UInt32              4      0~4292967295
        long      System.Int64               8      -9223372036854775808~9223372036854775808
ulong     System.UInt64              8      0~18446744073709551615
        char      System.Char                2      0~65535
float     System.Single              4      3.4E-38~3.4E+38
double    System.Double              8      1.7E-308~1.7E+308
  bool      System.Boolean                    (true,false)
decimal   System.Decimal             16     ±1.0 × 10?28 to ±7.9 × 1028
        
        (1)decimal型別用來表示高精度的浮點數,可以用到金融相關領域。
        (2)浮點數都有精度損失問題，操作時注意下即可。
(3)字元型別採用Unicode字符集，一個Unicode標準字元長度為16位。
        (4)整數型別不能隱式被轉換為字元型別(char)，和java不同,必須強轉或者用Unicode表示
        (5)布林型別有兩個值：false,true。不能認為整數0是false，其它值是true。
          bool x=1是錯誤的，不存在這種寫法，只能寫成x=true 或x=false
        
       
    結構型別(Struct types）
      (1)結構型別和類一樣，可以宣告建構函式、資料成員、方法、屬性等。
      (2)結構和類的最根本的區別是結構是值型別，類是引用型別。
      (3)和類不同，結構不能從另外一個結構或者類派生，本身也不能被繼承，因此不能定義抽象結構，
           結構成員也不能被訪問許可權控制字protected修飾，也不能用virtual和abstract修飾結構方法。
      (4)在結構中不能定義解構函式。
      (5)雖然結構不能從類和結構派生，可是結構能夠繼承介面，結構繼承介面的方法和類繼承介面的方法基本一致。
       例子：
          using System;
 //結構定義
          struct point{
public int x,y;//結構中也可以宣告建構函式和方法，變數不能賦初值
          }
   class Test{
      static void Main(){
                point P1;
                P1.x=166;
                P1.y=111;
                point P2;
                P2=P1;//值傳遞，使P2.x=166,P2.y=111
                point P3 = new point();//用new生成結構變數P3，P3仍為值型別變數
                //用new生成結構變數P3僅表示呼叫預設建構函式，使x=y==0。
             }
          }
    列舉型別(Enumeration types)
      C#列舉型別使用方法和C、C++中的列舉型別基本一致，和java的區別較大
      (1）定義列舉
//設定初值，從1開始
         enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
//位設定初值，從0開始 
         enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};
  
      (2)使用列舉
         Days day=Days.Tue;
         int x=(int)Days.Tue;
     （3）C、C++中不同，C#列舉元素型別可以是byte、sbyte、short、ushort、int、uint、long和ulong型別，但不能是char型別

        enum Days:byte{Sun,Mon,Tue,Wed,Thu,Fri,Sat};//元素為位元組型別
     （4）學習連結http://www.cnblogs.com/liyingyi/archive/2005/12/28/306772.aspx
      
   變數的初始值：一般簡單型別的初始值是0，布林型的是false，引用型別的是null。

    對於複雜結構型別，其中的每個資料成員都按此種方法賦值，顯得過於麻煩。
    由於數值型別都是結構型別，可用new語句呼叫其建構函式初始化數值型別變數，
    例如：int j=new int()。
    請注意，用new語句並不是把int變數變為引用變數，j仍是值型別變數，
    這裡new僅僅是呼叫其建構函式。所有的數值型別都有預設的無引數的建構函式，其功能就是為該數值型別賦初值為預設值。
    對於自定義結構型別，由於已有預設的無引數的建構函式，不能再定義無引數的建構函式，但可以定義有引數的構造函
  ***引用型別分類
     --類：C#語言中預定義了一些類：物件類(object類)、陣列類、字串類、自定義類等
     --介面
     C#語言引用型別變數無論如何定義，總是引用型別變數，不會變為值型別變數。
     C#語言引用型別物件一般用運算子new建立，用引用型別變數引用該物件。

     
   （1）物件類(object類)
       C#中的所有型別(包括數值型別)都直接或間接地以object類為基類。
       物件類(object類)是所有其它類的基類。任何一個類定義，如果不指定基類，預設object為基類。
       C#語言規定，基類的引用變數可以引用派生類的物件(注意，派生類的引用變數不可以引用基類的物件)，
       因此，對一個object的變數可以賦予任何型別的值
    
       object關鍵字是在名稱空間System中定義的，是類System.Object的別名
    
    （2）陣列
        C#語言中陣列是類System.Array類物件，和java中的陣列用法基本一致，不說了。
    （3）string：和java的api中的功能類似，可以對比學習，現在先大致瞭解即可，用到時再查
        C#還定義了一個基本的類string，專門用於對字串的操作。
        這個類也是在名字空間System中定義的，是類System.String的別名
        注意，兩個字串的比較比較的是值：string a,b; a==b,而java中時比的是hashcode
3.加框(boxing)和消框(unboxing）
  
  加框(boxing)和消框(unboxing)是C#語言型別系統提出的核心概念，加框是值型別轉換為object(物件)型別，
  消框是object(物件)型別轉換為值型別。有了加框和消框的概念，對任何型別的變數來說最終我們都可以看作是object型別
  
  可以理解成java中的拆箱與裝箱操作，java中時自動拆裝箱，這個需要手動操作
  c#中的更加寬泛，需要自己在使用中慢慢理解。

4.關於運算子：和java中的幾乎一致，如有遇到不一致的，就直接去查。
  （1）typeof運算子：操作符用於獲得指定型別在system名字空間中定義的型別名字
  例如：
     Console.WriteLine(typeof(System.Int32))；
     輸出如下：
     System.Int32
  （2）溢位檢查操作符checked和unchecked
  在進行整型算術運算(如+、-、*、/等)或從一種整型顯式轉換到另一種整型時，有可能出現運算結果超出這個結果所屬型別值域的情況，
  這種情況稱之為溢位。整型算術運算表示式可以用checked或unchecked溢位檢查操作符，決定在編譯和執行時是否對錶達式溢位進行檢查。
  如果表示式不使用溢位檢查操作符或使用了checked操作符，常量表達式溢位，在編譯時將產生錯誤，表示式中包含變數
  ，程式執行時執行該表示式產生溢位，將產生異常提示資訊。而使用了unchecked操作符的表示式語句，即使表示式產生溢位，
   編譯和執行時都不會產生錯誤提示。但這往往會出現一些不可預期的結果，所以使用unchecked操作符要小心。
  下面的例子說明了checked和unchecked操作符的用法：
  using System;
  class Class1{
       static void Main(string[] args){
           const int x=int.MaxValue;
           unchecked//不檢查溢位
          {
                int z=x*2;//編譯時不產生編譯錯誤，z=-2
                Console.WriteLine("z={0}",z);//顯示-2
           }
          checked//檢查溢位
         {
            int z1=(x*2);//編譯時會產生編譯錯誤
            Console.WriteLine("z={0}",z1);
         }
   }
   （3）new運算子
      和java不同之處是可以建立值型別的變數（基本資料型別），java中只能建立物件。
      new操作符可以建立值型別變數、引用型別物件，同時自動呼叫建構函式。
      例如：
         int x=new int();//用new建立整型變數x，呼叫預設建構函式
         Person C1=new Person ();//用new建立的Person類物件。Person 變數C1物件的引用
         int[] arr=new int[2];//陣列也是類，建立陣列類物件，arr是陣列物件的引用需注意的是，
         int x=new int()語句將自動呼叫int結構不帶引數的建構函式，給x賦初值0，x仍是值型別變數，
         不會變為引用型別變數
 4.控制語句
   控制語句幾乎和java相同，這裡只之處不同之處，可以會有遺漏的地方，請指正，需要在使用中體會，
   這裡只是快速的從java到c#的學習過程。
   （1)foreach(型別 變數名 in 表示式) 迴圈語句
      其中表達式必須是一個數組或其它集合型別，每一次迴圈從陣列或其它集合中逐一取出資料，
      賦值給指定型別的變數，該變數可以在迴圈語句中使用、處理，但不允許修改變數，
      該變數的指定型別必須和表示式所代表的陣列或其它集合中的資料型別一致。
      例子：
         using System;class Test()
        {
             public static void Main(){
                 int[] list={10,20,30,40};//陣列
                 foreach(int m in list)
                    Console.WriteLine("{0}",m);
            }
        }
對於一維陣列，foreach語句迴圈順序是從下標為0的元素開始一直到陣列的最後一個元素。
        對於多維陣列，元素下標的遞增是從最右邊那一維開始的。同樣break和continue可以出現在foreach語句中，功能不變
    （2）異常處理語句和java相同，try,catch,finally
 5.類的繼承
   （1）和java中的類的繼承幾乎一樣，都是單繼承，建構函式不能繼承
       語法格式有區別：
       父類：Person
       子類：Employee
       子類這麼定義:
       class Employee:Person{

       }
    （2）base關鍵字
       和java中的supper關鍵字用法一致
     (3)類的成員型別
        區域性變數：在for、switch等語句中和類方法中定義的變數，只在指定範圍內有效。
        欄位：即類中的變數或常量，包括靜態欄位、例項欄位、常量和只讀欄位。
方法成員：包括靜態方法和例項方法。
        屬性：按屬性指定的get方法和Set方法對欄位進行讀寫。屬性本質上是方法。
        事件：代表事件本身，同時聯絡事件和事件處理函式。
        索引指示器：允許象使用陣列那樣訪問類中的資料成員。
        操作符過載：採用過載操作符的方法定義類中特有的操作。
        建構函式和解構函式。
     （4）修飾符
        c#的類修飾符和java的比較
                                  C#                                  java
       private             只能本類訪問                             只能本類訪問
       protected        本類，派生類                                本類，子類，同包
       public           外部程式                                    本程式
       internal         本程式                                      類似於java的public 
      (5)欄位和屬性
         欄位：變數或者常量
         屬性：帶有get,set的方法(與java的不同，java帶有set,get方法的成員變數叫屬性，我此處理解的可能有誤)
     （6）
         靜態欄位：用static宣告的欄位，和java中的靜態變數相同
         例項欄位：普通的變數，和java中的成員變數相同
         常量：使用const修飾宣告的常量，和java中的static final 修飾的用法相同
         只讀欄位：使用readonly修飾宣告的欄位，它只能在欄位宣告中賦值或者在建構函式中賦值，java中沒有對應的定義。
     （7）C#中的屬性
         屬性不是欄位，但必然和類中的某個或某些欄位相聯絡，屬性定義了得到和修改相聯絡的欄位的方法。
         C#中的屬性更充分地體現了物件的封裝性：不直接操作類的資料內容，而是通過訪問器進行訪問，
         藉助於get和set方法對屬性的值進行讀寫。訪問屬性值的語法形式和訪問一個變數基本一樣，
         使訪問屬性就象訪問變數一樣方便，符合習慣。
         在類的基本概念一節中，定義一個描述個人情況的類Person，其中欄位name和age是私有欄位，記錄姓名和年齡，
         外部通過公有方法SetName和SetAge修改這兩個私有欄位。現在用屬性來描述姓名和年齡。例子如下：
         using System;
public class Person
{ private string P_name="張三";//P_name是私有欄位
private int P_age=12;//P_age是私有欄位
public void Display()//類的方法宣告，顯示姓名和年齡
{ Console.WriteLine("姓名:{0},年齡：{1}",P_name,P_age);
}
public string Name//定義屬性Name
{ get
{ return  P_name;}
set
{ P_name=value;}
}
public int Age//定義屬性Age
{ get
{ return  P_age;}
set
{ P_age=value;}
}
}
public class Test
{ public static void Main()
{ Person OnePerson= new Person();
OnePerson.Name="田七";//value="田七"，通過set方法修改變數P_Name
string s=OnePerson.Name;//通過get方法得到變數P_Name值
OnePerson.Age=20;//通過定義屬性，既保證了姓名和年齡按指定方法修改
int x=OnePerson.Age;//語法形式和修改、得到一個變數基本一致，符合習慣
OnePerson.Display();
}
}

在屬性的訪問宣告中，只有set訪問器表明屬性的值只能進行設定而不能讀出，只有get訪問器表明屬性的值是隻讀的不能改寫，
        同時具有set訪問器和get訪問器表明屬性的值的讀寫都是允許的。
雖然屬性和欄位的語法比較類似，但由於屬性本質上是方法，因此不能把屬性當做變數那樣使用，也不能把屬性作為引用型引數或輸出引數來進行傳遞。

 6.方法引數的種類
    
   c#的引數型別比較多，比javav的複雜好多

   -- 方法修飾符包括new、public、protected、internal、private、static、virtual、sealed、override、abstract和extern
   -- C#語言的方法可以使用如下四種引數(請注意和引數型別的區別)：
      值引數，不含任何修飾符。
      引用引數，以ref修飾符宣告。
      輸出引數，以out修飾符宣告。
      陣列引數，以params修飾符宣告。
   1．值引數
    （1）當用值引數向方法傳遞引數時，程式給實參的值做一份拷貝，並且將此拷貝傳遞給該方法，被呼叫的方法不會修改實參的值，
    所以使用值引數時，可以保證實參的值是安全的。
    （2）如果引數型別是引用型別，例如是類的引用變數，則拷貝中儲存的也是
    物件的引用，所以拷貝和實參引用同一個物件，通過這個拷貝，可以修改實參所引用的物件中的資料成員。
     值引數和java中的引數傳遞一致。
  2．引用引數
    有時在方法中，需要修改或得到方法外部的變數值，C語言用向方法傳遞實參指標來達到目的，C#語言用引用引數。
    當用引用引數向方法傳遞實參時，程式將把實參的引用，即實參在記憶體中的地址傳遞給方法，方法通過實參的引用，
    修改或得到方法外部的變數值。引用引數以ref修飾符宣告。注意在使用前，實參變數要求必須被設定初始值。
    
    這個類似於C語言中傳遞地址，然後根據地址找到相應的記憶體空間，並可以修改這個記憶體空間的值。
  3． 輸出引數
    為了把方法的運算結果儲存到外部變數，因此需要知道外部變數的引用(地址)。輸出引數用於向方法傳遞外部變數引用(地址)，
    所以輸出引數也是引用引數，與引用引數的差別在於呼叫方法前無需對變數進行初始化。在方法返回後，傳遞的變數被認為經過了初始化。
    
    這個也類似於c語言中實現多個返回值的實現方式，區別是初始化問題，當然java也可以實現引用的修改，但是對於基本資料
    型別做不到，只能用基本資料型別的封裝類去實現。    

    值引數、引用引數和輸出引數的使用見下例
    using System;
class g{public int a=0;}//類定義
class Class1
{ public static void F1(ref char i)//引用引數
{ i='b';}
public static void F2(char i)//值引數，引數型別為值型別
{ i='d';}
public static void F3(out char i)//輸出引數
{ i='e';}
public static void F4(string s)//值引數，引數型別為字串
{ s="xyz";}
public static void F5(g gg)//值引數，引數型別為引用型別
{ gg.a=20;}
public static void F6(ref string s)//引用引數，引數型別為字串
{ s="xyz";}
static void Main(string[] args)
{ char a='c';
string s1="abc";
F2(a);//值引數，不能修改外部的a
Console.WriteLine(a);//因a未被修改，顯示c
F1(ref a);//引用引數,函式修改外部的a的值
Console.WriteLine(a);//a被修改為b，顯示b
Char j;
F3(out j);//輸出引數，結果輸出到外部變數j
Console.WriteLine(j);//顯示e
F4(s1);//值引數，引數型別是字串，s1為字串引用變數
Console.WriteLine(s1);//顯示：abc,字串s1不被修改
g g1=new g();
F5(g1);//值引數，但實參是一個類引用型別變數
Console.WriteLine(g1.a.ToString());//顯示:20，修改物件資料
F6(ref s1);//引用引數，引數型別是字串，s1為字串引用變數
Console.WriteLine(s1);//顯示：xyz，字串s1被修改
}
}
  
     4．陣列引數
　　　　陣列引數使用params說明，
　　　（１）如果形參表中包含了陣列引數，那麼它必須是引數表中最後一個引數，陣列引數只允許是一維陣列。
　　　　比如string[]和string[][]型別都可以作為陣列型引數
　　　（２）陣列型引數不能再有ref和out修飾符。見下例：
　　　　using System;
class Class1
{ static void F(params int[] args)//陣列引數，有params說明
{ Console.Write("Array contains {0} elements:",args.Length);
foreach (int i in args)
Console.Write(" {0}",i);
Console.WriteLine();
}
static void Main(string[] args)
{ int[] a = {1,2,3};
F(a);//實參為陣列類引用變數a
F(10, 20, 30, 40);//等價於F(new int[] {60,70,80,90});
F(new int[] {60,70,80,90});//實參為陣列類引用
F();//等價於F(new int[] {});
F(new int[] {});//實參為陣列類引用，陣列無元素
}
}
程式輸出
Array contains 3 elements: 1 2 3
Array contains 4 elements: 10 20 30 40
Array contains 4 elements: 60,70,80,90
Array contains 0 elements:
Array contains 0 elements:
  　　　
　　　　和ｊａｖａ中的可變引數用法類似，在傳參的時候相同，定義時不同，但是都必須是引數中的最後一個引數
　　　　
    ５．Ｃ＃和ｊａｖａ中的靜態方法和成員方法用法相同
　　６.　Ｃ＃的方法和構造器的過載和ｊａｖａ的用法相同
　　7.  操作符過載:java中操作符不能過載
    
　 操作符過載是將C#語言中的已有操作符賦予新的功能，但與該操作符的本來含義不衝突，
  使用時只需根據操作符出現的位置來判別其具體執行哪一種運算。操作符過載，實際是定義了一個操作符函式，操作符函式宣告的格式如下：
static public 函式返回型別 operator 重新定義的操作符(形參表)
C#語言中有一些操作符是可以過載的，例如：+ - ! ~ ++ -- true false * / % & | ^ << >> == != > < >= <=等等。
但也有一些操作符是不允許進行過載的，例如：=, &&, ||, ?:, new, typeof, sizeof, is等。
    8.ｔｈｉｓ關鍵字
　　　ｔｈｉｓ關鍵字和ｊａｖａ中的ｔｈｉｓ用法一致。
　　　注意：ｊａｖａ中的supper在Ｃ＃中使用ｂａｓｅ
　　９.類的多型
　　　C#支援兩種型別的多型性,
　　　　第一種是編譯時的多型性，一個類的物件呼叫若干同名方法，系統在編譯時，根據呼叫方法的實參型別及實參的個數決定呼叫那個同名方法，
　　　　實現何種操作。編譯時的多型性是通過方法過載來實現的。
　　　第二種是執行時的多型性，是在系統執行時，不同物件呼叫一個名字相同，引數的型別及個數完全一樣的方法，會完成不同的操作。
　　　　C#執行時的多型性通過虛方法實現。在類的方法宣告前加上了virtual修飾符，被稱之為虛方法，反之為非虛方法。
　　　
　　　第一種多型寫法和ｊａｖａ相同，但是用法不同，方法執行時，執行基類的方法
　　　第二中多型和ｊａｖａ寫法不同，子類繼承的寫法也不同，但是和ｊａｖａ繼承的意義相同。
　　　　基類返回值前用ｖｉｒｔｕａｌ關鍵字修飾，派生類繼承的時候在返回值前加上一個ｏｖｅｒｒｉｄｅ關鍵字去修飾。
　　　
　　１０：抽象類和抽象方法
　　　　　和ｊａｖａ對比基本一樣，只是在寫法上有少許差別，ｊａｖａ可以用註解，不知Ｃ＃是否可以
　　１１．密封類和密封方法
Ｃ＃用sealed修飾的類或者方法叫密封類和密封方法，和ｊａｖａ中用ｆｉｎａｌ修飾的類和方法相同，不能被繼承
　　１２.介面和ｊａｖａ中的介面意義和用法幾乎相同，
　　　　　區別是，Ｃ＃在介面中可以有方法、屬性、索引指示器和事件，不能是常量、域、操作符、建構函式或解構函式，不能包含任何靜態成員。
　　１３．代表
　　　　在這裡要介紹的是C#的一個引用型別----代表(delegate)，也翻譯為委託，可以當做ｊａｖａ中的代理，也可以理解成ｃ中的指標的傳遞
　　　　語法自己去查，比較簡單。
　　１４.事件
事件是C#語言內建的語法，可以定義和處理事件，為使用元件程式設計提供了良好的基礎
　　１５.事件驅動
　　　　Windows作業系統把使用者的動作都看作訊息，C#中稱作事件，例如用滑鼠左鍵單擊按鈕，發出滑鼠單擊按鈕事件。
　　　　Windows作業系統負責統一管理所有的事件，把事件傳送到各個執行程式。各個程式用事件函式響應事件，這種方法也叫事件驅動。
　　　　和ａｎｄｒｏｉｄ中的ｂｕｔｔｏｎ等ｖｉｅｗ的事件的處理基本類似。
　　１６．
　　　索引指示器
　　　在C#語言中，陣列也是類，比如我們宣告一個整型數陣列：int[] arr=new int[5]，實際上生成了一個數組類物件，
　　　arr是這個物件的引用(地址)，訪問這個陣列元素的方法是：arr[下標]，在陣列類中，使用索引訪問元素是如何實現的呢？
　　　是否可以定義自己的類，用索引訪問類中的資料成員？索引指示器(indexer)為我們提供了通過索引方式方便地訪問類的資料成員的方法。
　　　　
　　　可以這麼理解，就是自己定義的陣列，可以通過下表訪問其中的元素
　　１７，名字空間或者叫名稱空間：ｎａｍｅｓｐａｃｅ。
　　　　　用法和ｊａｖａ中的包ｐａｃａｇｅｒ類似
　　　　　名稱空間也是用來唯一識別類的，和包相同
　　　　　名稱空間可以定義子名稱空間，包可以定義子包。
　　　　　名稱空間和ｊａｖａ中的不同，除了寫法不同外，名稱空間只是邏輯上的分類。
　　１８：和ｊａｖａ不同還有
　　　　Ｃ＃可以使用指標，通過ｕｎｓａｆｅ關鍵字可以修飾方法或者程式碼行，說明這個是不安全的程式碼，需要使用ｃ的指標
　　　　Ｃ＃的方法，變數，引數首字母大寫，而ｊａｖａ的是小寫
　　　發現Ｃ＃更加的面相物件，但是還留有Ｃ和Ｃ＋＋的影子。　　

　　當然以上只是Ｃ＃和ｊａｖａ基本語法的對比學習，可以讓ｊａｖａ程式設計師快速的學習Ｃ＃語言，能看懂Ｃ＃程式，這些已經足夠了，
　　只是熟悉的問題。關於Ｃ＃的ｓｄｋ的ａｐｉ的學習也要和ｊａｖａ的對應學習，這樣學習會非常快速，也能加深對ｊａｖａ的理解。
--------------------- 
作者：com360 
來源：CSDN 
原文：https://blog.csdn.net/com360/article/details/8201930 
版權宣告：本文為博主原創文章，轉載請附上博文連結！