http 文字 應用程序 ring 類中訪問 含義 讀寫 其中 主體

一：面向對象的基本知識

C#程序分為面向過程和面向對象

什麽是對象：一切皆為對象：Object，生活中常說的“東西”就是程序裏面所指的對象；生活中遇到的東西我們都在下意識的歸類；歸類意味著抽象模型；

類：class，對某類眾多對象的共同特點抽象出來的模型。

他們的關系：類是好多對象的抽象，對象是類的實例化。

創建一個名為Dog的類：

 class Dog  //一般首字母大寫
    {
       int age;
       public void setage(int a) //用方法賦值
        {
           age = a;
        }
       public void buck()
        {
            Console.WriteLine("這是一個方法");
        }
    }

類中一般包括兩類東西，變量（名詞，也交成員變量這裏age是成員變量）和函數（動詞，也叫成員函數或成員方法 buck（）就是方法）。

對象實例化：

Dog d1 = new Dog();

這樣就實例化出了一個Dog的對象a。

例子：兩個套在一起的圓，求內圓的周長和內圓與外圓之間的面積，用面向對象的思想做

class circle
    {
        float r;
        public circle(float a)
        {
            r = a;
        }
        public double zhouchang()
        {
            return 2 * 3.14 * r;
        }
        public double mianji()
        {
            return 3.14 * r * r;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            circle m = new circle(10);
            circle n = new circle(20);
            double bc = m.zhouchang();
            double mj = (n.mianji()-m.mianji());
            Console.WriteLine("內圓的周長為："+bc);
            Console.WriteLine("花磚的面積為："+mj);
        }
    }

首先做了一個名為circle的類，它可以生產任何一個半徑不同的圓，在構造函數中，為半徑賦值。

二：面向對象的三大特性

三大特性是指：封裝，繼承，多態。

類中的方法一般分為：構造方法（函數）；屬性方法（函數）：成員變量賦值取值；行為方法（函數）：變量運算。

（一）： 封裝

1.封裝含義：

（1）不同類的變量只屬於各自的類。

（2）不同對象的成員變量只屬於各自的對象，彼此不受影響。

（3）對象中的變量需要通過方法（函數）實現操作，比較安全。

封裝為了安全，盡量不用public來聲明變量，避免在main函數中可以直接訪問賦值而降低了安全性，在類中建立public的方法來賦值，main中調用此方法傳值。

2. 成員變量及訪問修飾

private 私有成員 ,protected 受保護的成員,public 公有成員

3. 構造函數

它是一個特殊的成員函數，一般在構造函數裏進行初始化。如果不寫構造函數在new的時候會自動生成一個默認空的構造函數。

寫法特殊：沒有返回值，函數名只能與類名一樣；public 類名(){};

執行特殊：類在實例化（new出來的時候）自動執行，構造函數是最早執行的成員函數，構造函數是用來生成對象的函數。

它的主要作用：對象實例化生成的時候，做一些初始化的工作。

下面例子就是做了一個Ren()的構造函數，為其變量賦上初始化的值：

 class Ren
    {
        string _Name;
        int _Age;

        public Ren()
        {
            _Name = "龍神";
            _Age = 25;
        }
    }

4. 重載（函數或方法）

函數名相同，參數不同（參數個數或類型不同）的多個函數就形成了重載。

重載只與函數名和形參有關，與返回類型無關。

下面舉個例子，構造函數的重載：

    class Ren()
        {
            string _Name;
            int _Age;

            public Ren()
            {
                _Name = "ZSMJ";
                _Age = 25;
            }
            public Ren(string name)
            {
                _Name = name;
            }
            public Ren(string name,int age)
            {
                _Name = name;
                _Age = age;
            }
        }

這樣Ren類中就做了三個構造函數，第一個是無參的，第二個是一個string類型的參數，第三個是兩個參數，類型分別為string和int。他們符合重載的條件，所以會形成重載在Main函數中new的時候根據參數的不同會自動選擇執行其中一個構造函數。

如果在Main函數中：

Ren a = new Ren("王大錘");

則執行的構造函數是第二個。

5. 屬性

它的聲明：public 類型 屬性名；也可以選擇成員變量右鍵重構，封裝字段來生成屬性方法，例如：

    string _Name;
    public string Name
   {
      get { return _Name; }
      set { _Name = value; }
   }

這樣Name就是該類的一個屬性，在Main函數中可以用此屬性為其成員變量賦值取值：

     Ren a = new Ren("王大錘");
     a.Name = "王尼瑪";

註意：（1）屬性是用來為成員變量賦值和取值的，它有代替屬性方法的作用，一般用屬性。

（2）屬性定義的時候，屬性名後面沒有小括號。

（3）屬性都是public。

（4）屬性中只能包含兩個部分：get和set。代碼也只能寫在get和set的花括號裏面。

（5）屬性分為只讀屬性，只寫屬性和可讀寫屬性，與get和set的有無有關系。

6. this關鍵字

概念：this引用，this在哪個對象裏面執行代表該對象本身。

用法：this.成員變量（成員方法），this._Name; this.Eat();

例子：this 調用當前對象的其它構造函數。

  public class Mydate
    {
        int _Year;
        int _Month;
        int _Day;
        int _Hours;

       public Mydate(int year,int month) 
       {
           _Year = year;
           _Month = month;
       }
       public Mydate(int year,int month,int day,int hours): this(year,month)
       {
           _Day = day;
           _Hours = hours;
       }
    }

這裏第一個構造函數中有兩個參數year和month，在做第二個構造函數的時候為了方便用“：this”來調用了本類中第一個構造函數，這樣第二個構造函數只需寫後day和hours的執行語句就可以了。

在new的時候傳入不同的參數，會實例出不同的對象，這時候的this就代表不同的對象。

7. is關鍵字(運算符)

用法：對象 is 類名；is左邊是對象，右邊是類型；

 Console.WriteLine(a is Ren);

如果a是一個Ren類的對象，則返回值為true，否則返回值為false。

8. partial關鍵字

如果一個類特別大，不宜擋在一個文件中實現或者一個類中有一部分代碼不宜與其他混淆或者需要多人合作編寫一個類，這就需要將一個類拆開來寫。

用partial關鍵字可以實現，也可以用來補充完善類，擴展性比較強。 如在程序集裏的一個文件裏寫了 partial class Ren{裏面是成員} ； 在另一個文件裏也可以對Ren類進行補充，需要這樣寫 partial class Ren{裏面是成員} 。 9. 靜態成員

非靜態變量稱為實例變量，非靜態方法稱為實例方法，實例成員的數據存在每個對象中，用對象名來調用。

靜態成員包括：靜態變量，靜態屬性，靜態方法。

定義一個成員為靜態的：在變量或方法前加static，如：static int a;

靜態變量是屬於類的，每個對象都有的並且相同的東西只保存一份，不和實例變量那樣在每個對象裏都面保存一份。

可以說它不屬於任何對象，也可以說它又屬於任何一個對象，給每個對象用，節省空間。

例如：每包粉筆的顏色是靜態成員，每支粉筆的剩余長度是實例成員。

靜態變量或方法不需要new出來。

在C#中，定義了一個粉筆的類：

   class Fenbi
   {
       static string _Color;

    public static string Color
    {
      get { return Fenbi._Color; }
      set { Fenbi._Color = value; }
    }
       int _Lenght;

    public int Lenght
    {
      get { return _Lenght; }
      set { _Lenght = value; }
    }  
   }

（1）在當前類的花括號外，靜態成員只能用類名來調用，不能用對象名來調用，而實例成員只能用對象名來調用，不能用類名來調用。

      Fenbi.Color ="Yellow";
      Fenbi b = new Fenbi();
      b.Lenght = 10;

（2）在當前類的花括號內，靜態方法只能直接調用靜態成員，不能調用非靜態成員，實例方法可以調用非靜態和靜態的成員。

     public static void xiezi()
       {
           Console.WriteLine("寫出"+_Color+"的文字了");
       }

     public void change()
        {
            Console.WriteLine(_Color+"的粉筆長度變為："+_Lenght);
         }

10. 拷貝

淺拷貝：傳遞引用，不賦值對象。
深拷貝：創建一個新的對象。

（二）： 繼承

1. 語法：public 子類名：父類名；如：class Dog:Pet。

2. 特點：單繼承，一個父類可以派生多個子類，但每個子類只能有一個父類

如果一個類，沒有明確指定父類是誰，默認是object。除了object類之外，所有類都有一個父類。

子類可以從父類繼承下父類的成員變量和成員方法。

3. 訪問修飾符合訪問權限：

private 的成員不被繼承，只能在該類中訪問。

protected成員可以被繼承，能在該類和派生類中訪問到，在外界訪問不到。父類中的變量一般用protected。

public成員可以被繼承，能在所有地方訪問到。

4. base 關鍵字：子類中可以用（base.父類中的成員 ）來調用父類中的成員，base()調用父類構造，base.xxx()調用父類成員方法。

調用的參數值會被覆蓋，方法也會被覆蓋。

5. 繼承關系中實例化子類的流程：

先執行父類的構造函數，再執行子類的構造函數。

6. 繼承關系的實例化：

如果父類的構造函數沒有空參構造函數，全是帶參數的，則子類必須要寫構造函數，構造函數的形參中必須包含父類構造函數所需要的參數，還要用base()把父類構造函數所需要的參數傳遞父類。

例如：父類中只有這個構造函數

      public Ren(string name, int age)
      {
          _Name = name;
          _Age = age;
      }

那麽子類中的構造函數應該這樣寫：

      public Chinese(string name, int age, string yuyan):base(name,age)
        {
            _Yuyan = yuyan;
        }

7. sealed 關鍵字：

如果用來修飾class，稱為密封類，此類無法被繼承；如果用來修飾方法，該方法無法被重寫。

如： sealed class Ren{}；

（三）： 多態

1. 概念：父類引用指向不同子類實例的時候，父類引用所調用的函數都是子類的函數，由於子類對象不同，父類引用調用的成員表現出來的不同狀態就是一種多態。

2. 實現的方式：多態需要通過繼承來實現

3. 分類：分為編譯多態（重載overload）和運行多態（重寫override）。父類方法被重寫了之後也可以在子類中用base.方法 調用。

4. virtual關鍵字：虛方法，允不允許重寫，要重寫父類方法必須是虛方法：public virtual void Eat()。

5. 運行多態實現的條件：

（1）子類對父類方法的重寫（override），父類和子類中都有相同的方法。

（2）父類引用指向子類實例。

例如，有一個Ren類是父類，一個Chinese類和American是子類，Ren r = new Chinese();父類的引用 r 指向子類實例。

    class Ren
    {
        protected string _Name;
        protected string _Country;
        public virtual void Eat()
        {
            Console.WriteLine("正在吃飯...");
        }
    }
    class American : Ren
    {
        public override void Eat()
        {
            Console.WriteLine("正在用叉子和刀子吃飯....");
        }
    }
    class Chinese : Ren
    {
        public override void Eat()
        {
            Console.WriteLine("正在用筷子吃飯...");
        }
    }

父類Ren中有個Eat方法為虛方法，在子類Chinese和American中進行了重寫，在Main函數中：

    Random rand = new Random();
    int n = rand.Next(100);
    Ren a;
    if (n % 2 == 0)
    {
        a = new American();
    }
    else
    {
        a = new Chinese();
    }
    a.Eat();

隨機讓父類引用 a 指向 不同的子類實例，這樣用父類引用 a 調用方法Eat()的時候表現出不同對象的操作。

6. 裏氏代換原則和抽象依賴原則

裏氏代換原則，如果某個方法接收的是父類引用，可以向裏面傳父類或其子類的元素，子類對象替代父類對象。

抽象依賴原則，用父類的引用來指向子類的實例。

例子：怪獸吃人，傳入Ren的引用 r ，則r.Cry()表現出來不同的結果。

class Monster
    {
        public void EatFood(Ren r)   //r = a;
        {
            r.Cry();
            Console.WriteLine("人類真好吃，吃飽了！");
        }
    }
    class Ren   
    {
        public virtual void Cry()
        {
            Console.WriteLine(".......");
        }
    }
    class American:Ren
    {
       
        public override void Cry()
        {
              Console.WriteLine("MyGod,God bless me!");
        }
    }
    class Chinese:Ren
    {
        public override void Cry()
        {
            Console.WriteLine("天哪，老天爺保佑我！");
        }
    }

在Main函數中 ，先實例出一個怪獸，隨機生成一個Ren的對象，將此對象的引用傳入怪獸類裏，通過這個引用來表現出不同的狀態。

            Monster m = new Monster();
            Random rand = new Random();
            int n = rand.Next(100);
            if (n % 2 == 0)
            {
                American a = new American();
                //或者是這樣寫 Ren a = new American();

                m.EatFood(a);
            }
            else
            {
                Chinese c = new Chinese();
                //或者是這樣寫 Ren c = new Chinese();

                m.EatFood(c);
            }

一：抽象方法

1. 在面向對象編程語言中抽象方法指一些只有方法聲明，而沒有具體方法體的方法。抽象方法一般存在於抽象類或接口中。

在一些父類中，某些行為不是非常明確，因此無法用代碼來具體實現，但是類還必須具備此方法，因此，把這樣的方法定義為抽象方法。

2. 聲明方法：public abstract Eat(); 方法聲明只是以一個分號結束，並且在簽名後沒有大括號，沒有函數體，因為太抽象不清楚，具體的實現由各個子類中重寫函數實現。

3. 它的特點：

（1） 抽象方法是隱式的 virtual 方法。

（2） 只允許在抽象類中使用抽象方法聲明。

（3） 因為抽象方法只聲明不提供實實現，所以沒有方法體。抽象方法只在派生類中真正實現，這表明抽象方法只存放函數原型(方法的返回類型，使用的名稱及參數)，而不涉及主體代碼。

（4） 加abstract關鍵詞。

（5）抽象方法的目的在於指定派生類必須實現與這一方法關聯的行為。

二：抽象類

1. 抽象類：無法被實例化的類。關鍵詞是abstract，凡是帶有abstract關鍵詞的類都無法被new出來。抽象類是不完整的，它只能用作基類。在面向對象方法中，抽象類主要用來進行類型隱藏和充當全局變量的角色。

2. 聲明：抽象類聲明：public abstract class Ren{}；

3. 註意：

（1）凡是帶有抽象方法的類肯定是抽象類；抽象類卻不一定包含抽象方法。

（2）構造方法，靜態成員方法不能聲明為抽象方法。

（3）一個非抽象類必須實現從父類繼承來的所有抽象方法，如果有一個抽象方法沒有實現，則此類必須要加abstract關鍵字。如果父類被聲明為抽象類，並存在未實現的抽象方法，那麽子類就必須實現父類中所有的abstract成員，除非該類也是抽象的。

4. 特征：

（1）抽象類不能實例化。

（2）一個抽象類可以同時包含抽象方法和非抽象方法。

（3）不能用sealed修飾符修飾抽象類，因為這兩個修飾符的含義是相反的，采用sealed修飾符的類無法繼承，而abstract修飾符要求對類進行繼承。

（4）從抽象類派生的非抽象類必須包括繼承的所有抽象方法和抽象訪問器的實際實現。

例子：Ren類中有一個抽象方法Eat()，在其派生類Chinese和American中必須重寫這個方法

abstract class Ren
    {
        protected string name;
        public abstract void Eat();
    }

    class Chinese:Ren
    {
        public override void Eat()
        {
            Console.WriteLine("用筷子吃飯");
        }
    }
    class American : Ren
    {
        public override void Eat()
        {
            Console.WriteLine("用刀叉吃飯");
        }
    }

三：接口

1. 關鍵字：interface，用interface 關鍵詞來定義。

2. 概念：極度抽象的類，無成員變量，無實例屬性和實例方法，只有抽象方法或抽象屬性，生活中的例子：標準，規則。

3. 寫法：接口不用class，用interface，名字一般以I作為首字母；不用寫abstract，裏面所有都是，不用寫public，必須是public。

    interface IUSB         //接口
    {
        void start();
        void stop();
    }

4. 特點：

（1）接口中的方法都是抽象的，因此無需加abstract修飾符。

（2）接口中的方法都是公用的，因此無需加public修飾符。

（3）接口就是一個規則標準。

（4）接口可以繼承父接口。

（5）一個類可以實現（繼承）多個接口。一個類只能有一個父類，但可以實現多個接口。

例子：簡單的IUSB接口，裏面有兩個抽象方法start()和stop()，派生類實現接口必須實現接口中的所有方法。

 interface IUSB         //接口
    {
        void start();
        void stop();
    }
    class UDisk : IUSB  //實現接口必須實現裏面的所有方法
    {
        public void start()
        {
            Console.WriteLine("U盤啟動了");
        }
        public void stop()
        {
            Console.WriteLine("U盤停止了");
        }
    }
    class Cammer : IUSB
    {

        public void start()
        {
            Console.WriteLine("攝像頭啟動了");
        }

        public void stop()
        {
            Console.WriteLine("攝像頭關閉了");
        }
    }

    class computer
    {
        public void CheckUSB(IUSB usb)
        {
            usb.start();
        }
        public void CloseUSB(IUSB usb)
        {
            usb.stop();
        }
    }

用的時候：

       computer c = new computer();
       UDisk u = new UDisk();
       Cammer m = new Cammer();

       c.CheckUSB(u); //插入U盤
       c.CheckUSB(m); //插入攝像頭

       c.CloseUSB(u); //拔出U盤
       c.CloseUSB(m); //插入攝像頭

四：命名空間

1. 概念：namespace 相當於一個包，它是對類進行分類管理的工具，給計算機看的，相同命名空間下的類可以分在不同的文件中存儲。

2. 一般寫法：namespace 公司名.項目名.模塊名

3. 在別的命名空間上面要使用其它命名空間內的類，可以在它的上面寫 using 要使用的命名空間；

五：項目名

一般默認：ConsoleApplication1，用來給人類標識出這個項目是做什麽的，給人看的。

六：程序集

在項目名上打右鍵：屬性，即可修改程序集名稱

編譯出來的exe或dll文件就是程序集。exe是控制臺應用程序，dll是庫類。

程序集的名字就是編譯出來的exe或dll名字。

如果一個項目分三個人來寫，A寫一個類庫，B寫一個類庫，C寫Main函數，把他們整合在一起的流程是：

1. A寫完了編譯出一個名字如 cc.dll 的文件；

2. B寫的時候要用到A命名空間中的某個類，B先將A的cc.dll文件拷貝到自己的目錄下，B需要在項目中的引用上打右鍵：添加引用，通過瀏覽找到該引用添加進來，然後using A 的命名空間;

3. B寫完了編譯出一個名字如 dd.dll 的文件；

4. C要寫Main函數，在Main函數中操作AB中的類，他需要將AB的dll文件拷貝過來，然後再項目中的引用上打右鍵，添加引用，通過瀏覽找到該引用添加進來，然後using A 的命名空間; using B的命名空間，這樣就可以在Main函數中用了。

5. 如果A的命名空間中有個類Ren和B的命名空間中有個類Ren重名了，這C在用的時候要用哪一個命名空間下的Ren類就要用該命名空間點出來再用。

C#面向對象