捕鱼的最佳是时间

書名：新手學ASP.NET 3.5網絡開發
作者名：孔琳俊陳松等編著
本章字數： 902字
更新時間： 2018-12-27 20:32:17

2 C#面向對象的特性

面向對象是當前計算機界關心的重點，是軟件開發方法的主流，本章從面向對象的基本概念入手，詳細分析面向對象中的知識點。面向對象主要涉及的概念有：類、對象、接口、繼承、多態等，本章主要介紹C#中關于這些概念的應用。

2.1 面向對象編程概述

面向對象編程（OOP）是將現實中的事物抽象化，其設計的重點就是類的設計。本節介紹OOP開發中的一些基本術語。

2.1.1 什么是類和對象

類是面向對象程序設計的核心，實際上是一種復雜的數據類型。將不同類型的數據和與這些數據相關的操作封裝在一起，就構成了類。而將抽象化的類具體化，就成了對象，通常說對象是類的實例。

類是將現實事物抽象化，而對象是將事物具體化。如“張三”是一個“學生”，那么張三其實是比較具體的一個人，而“學生”則是一個抽象事物。此時可以創建一個學生類，包含學號、年齡、班級等，如果指名張三的這些屬性，則張三是學生類的一個實例。

現在創建一個學生類“Student”，代碼如下所示，其中get是類的訪問器，用來返回對象的實際值。

    1.     public class Student
    2.     {
    3.         public string StudentNo
    4.         {get{return"";}}
    5.         public int StudentAge
    6.         {get{return 0;}}
    7.         public string StudentGrade
    8.         {get{return"";}}
    9.     }

現在來實例化這個類，即創建一個對象“zhang”，代碼如下所示。

    Student zhang = new Student();

通過這個實例，希望讀者能夠明白對象和類的概念，以及對象和類的關系。

2.1.2 用C#如何創建類

【本節示例參考：\示例代碼\C02\ StudentClassAPP】

定義類的語法是基本相同的，但不同的工具創建類的方法會不同，下面演示在Windows應用程序中創建類的步驟。

1 新建一個Windows應用程序“StudentClassAPP”，在解決方案資源管理器中，在根目錄上單擊鼠標右鍵，在彈出的快捷菜單中選擇“添加|新建項”菜單命令，打開“添加新項”對話框，如圖2.1所示。

圖2.1 “添加新項”對話框

2 選中“類”模板，修改名稱為“Student.cs”。單擊“添加”按鈕，此時在根目錄下生成一個“Student.cs”類文件，默認生成的代碼如下所示，其中最頂端的3行代碼，表示引用的程序集，這些程序集保存在.NET Framework中。namespace表示類所在的命名空間，默認會是當前的應用程序名。

    1.  using System;
    2.  using System.Collections.Generic;
    3.  using System.Text;
    4.
    5.  namespace WindowsApplication3
    6.  {
    7.     class Student
    8.     {
    9.     }
    10. }

3 上面生成了一個空的Student類，現在為類添加成員：學號、年齡、班級。代碼如下所示。如果希望外部對象可以訪問類中的各個成員，則成員的作用域為“public”，如“StudentNo”。如果變量只在類中有效，則作用域為“private”，如“ no”。

    1.     class Student
    2.     {
    3.         private string_no;
    4.         private int_age;
    5.         private string_grade;
    6.         public string StudentNo//學號
    7.         {
    8.            get{return_no;}
    9.            set{_no=value;}
    10.        }
    11.        public int StudentAge//年齡
    12.        {
    13.           get{return_age;}
    14.           set{_age=value;}
    15.        }
    16.        public string StudentGrade//班級
    17.        {
    18.           get{return_grade;}
    19.           set{_grade=value;}
    20.        }
    21.    }

4 在定義類中的成員時，本例使用了get{ }和set{ }，這是類的兩個訪問器。get表示讀取，set表示編寫，如果一個成員只允許讀取，則不需要set{}語句，相反則不需要get{}語句。在set語句中有個關鍵字“value”，用來表示用戶賦給成員的值。

5 保存這些代碼，VS2008會自動編譯Student類。

2.1.3 用C#如何創建對象

前面創建了類“Student”，本例學習如何在C#中創建類的對象，演示步驟如下：

1 打開Windows應用程序“StudentClassAPP”。

2 在Form1.cs設計界面中，添加1個Button和1個Label，其中Label用來顯示文本。Button用來處理業務邏輯。

3 雙擊Button按鈕，切換到窗體的代碼視圖，書寫創建對象的代碼如下所示。

    1.         private void button1_Click(object sender,EventArgs e)
    2.         {
    3.            Student zhang=new Student();//創建對象
    4.            //以下其實是使用了類的編寫器set
    5.            zhang.StudentNo="BJ100010";
    6.            zhang.StudentAge=16;
    7.            zhang.StudentGrade="高二";
    8.            //顯示對象的內容，其實是使用了類的讀取器get
    9.            label1.Text=zhang.StudentNo+zhang.StudentAge.ToString()+zhang.StudentGrade;
    10.        }

4 保存所有的代碼。按F5運行程序，單擊“Button”按鈕，可以看到Label顯示了對象的內容。

2.1.4 什么是面向對象編程

面向對象編程（Object-Oriented Programming），簡稱OOP，：是將程序的相關邏輯，包括屬性和行為封裝到編程所需的“對象”中。面向對象的編程語言，使得復雜的工作條理清晰、編寫容易。

面向對象編程之所以流行，是因為其達到了軟件工程的三個主要目標：重用性、靈活性和擴展性。面向對象編程的基本思想是使用對象的繼承、封裝、多態等來進行程序開發。面向對象編程的本質是以對象為中心，編寫可重復利用、可方便擴展的代碼。

圖2.2以圖形的方式，展示了面向對象開發的一個標準過程。

圖2.2 面向對象開發的標準過程

2.2 面向對象的技術

面向對象的關鍵技術就是對象、類、接口、繼承和多態。對象和類在第一節已經詳細介紹過，本節介紹接口、繼承和多態。

2.2.1 接口

接口只包含成員的定義，不包含成員的實現，成員是指類中的方法、屬性、索引器和事件等。接口的主要目的是為不相關的類，提供通用的屬性和行為，如C#中的接口“IDbConnection”，用來定義數據源的連接，提供了多個未實現的屬性和方法，開發者可以自定義2個類“SqlConnection”和“AccessConnection”，并繼承IDbConnection接口，那么這2個類就具備相同的成員，但實現內容不同，因為SqlConnection用來連接SQL Server數據庫，而AccessConnection用來連接Access數據庫。下面的代碼演示一個簡單的接口定義。其中“interface”是定義接口的關鍵字。

    1.     interface IConnection
    2.     {
    3.         public string DatabaseName;
    4.         public void AddDataBase();
    5.         public string GetDataBaseConn();
    6.     }

接口就好像一個模板，提供基本成員的結構，但并沒有添加實質性的內容。由于C#不能實現多個類的繼承，而可以實現多個接口的繼承，所以使用接口，是可以讓一個類具備兩個以上基類的唯一方式。

2.2.2 用C#如何創建接口

現在演示用C#創建一個接口，步驟如下：

1 打開應用程序，在解決方案資源管理器中，右擊根目錄，在彈出的快捷菜單中，選擇“添加|新建項”菜單命令，打開項模板對話框。

2 選中“接口”模板，默認名稱為“Interface1.cs”。單擊“添加”按鈕，此時在根目錄下生成一個“Interface1.cs”類文件，默認代碼如下所示。

    1.  using System;
    2.  using System.Collections.Generic;
    3.  using System.Text;
    4.
    5.  namespace WindowsApplication3
    6.  {
    7.     interface Interface1
    8.     {
    9.     }
    10. }

3 默認生成一個空的接口“Interface1”，設計一個公司員工的接口定義，代碼如下所示。

    1.     interface Interface1
    2.     {
    3.         string EmployeeNmae;//員工姓名
    4.         void AddEmployee();//添加員工
    5.         void DelEmployee();//刪除員工
    6.         string EmployeeAddress;//員工住址
    7.     }

4 保存并編譯所有的代碼。

2.2.3 繼承

繼承就是從父類中獲取一些公開的成員，如方法和屬性。繼承的語法如下所示。

    class Student:Person    //繼承類
    class Student:Interface1  //繼承接口

子類和父類之間以“：”間隔，C#只允許繼承一個父類，但允許繼承（或者說實現）多個接口。如果子類繼承（實現）了接口，則必須實現接口中定義的所有公開成員。

所謂公開的成員，就是在父類中被定義為public的成員，因為public的作用域，可以在子類中生效，而private的作用域則不可。

2.2.4 用C#如何實現繼承

本節創建了一個父類，一個子類，并介紹了如何調用子類。演示步驟如下：

1 創建一個類“ParentClass”作為父類，代碼如下所示，只定義了一個屬性“ParentName”。

    1.     class ParentClass
    2.     {
    3.         private string_name;
    4.         public string ParentName//父類名
    5.         {
    6.            get{return_name;}
    7.            set{_name=value;}
    8.         }
    9.     }

2 再創建一個類“SonClass”作為子類，代碼如下所示，要求其繼承“ParentClass”類。同時還定義了一個屬性“SonName”。

    1.     class SonClass:ParentClass
    2.     {
    3.         private string_name;
    4.         public string SonName//子類名
    5.         {
    6.            get{return_name;}
    7.            set{_name=value;}
    8.         }
    9.     }

3 在窗體中調用子類的代碼如下所示。

              SonClass myson=new SonClass();   //創建子類對象
              myson.ParentName="父名";         //自動繼承父類的屬性
              myson.SonName="子名";          //子類自己的屬性

2.2.5 多態

多態是指類可以有多種形態，通過修改可以形成多個類的實現方法。當子類從父類繼承時，它會獲得父類的所有方法、字段、屬性和事件。若要更改父類的數據和行為，通常有兩種選擇：可以創建新的成員替換父級成員，或者可以重寫虛擬的父級成員。

如果要替換父級成員，需要使用new關鍵字。下面代碼演示了GetName方法的2種形態，一種是返回父級名稱，一種是返回子級名稱。

    1.     class ParentClass  //父類
    2.     {
    3.         public string GetName()
    4.         {
    5.            return"父級名稱";
    6.         }
    7.     }
    8.     class SonClass:ParentClass   //子類繼承父類
    9.     {
    10.        public new string GetName()
    11.        {
    12.           return"子級名稱";
    13.        }
    14.    }

如果要重寫虛擬的父級成員，需要兩個條件，父級成員使用了關鍵字“virtual”，而子級成員使用關鍵字“override”。下面演示這種形式下的GetName方法。

    1.     class ParentClass  //父類
    2.     {
    3.         public virtual string GetName()
    4.         {
    5.            return"父級名稱";
    6.         }
    7.     }
    8.     class SonClass:ParentClass  //子類繼承父類
    9.     {
    10.        public override string GetName()
    11.        {
    12.           return"子級名稱";
    13.        }
    14.    }

2.2.6 用C#如何實現多態

使用多態要注意被調用的究竟是哪一種形態。本例通過兩個類和1個方法，演示多態的使用，實現步驟如下所示：

1 創建類“Employee”，表示公司里的員工。代碼如下所示，其包含一個虛方法getDepart。

    1.     class Employee  //父類
    2.     {
    3.         public virtual string getDepart()
    4.         {
    5.            return"總公司";
    6.         }
    7.     }

2 創建類“MarketEmployee”，表示市場部員工，代碼如下所示，其重寫了父類的getDepart方法。

    1.     class MarketEmployee:Employee   //子類繼承父類
    2.     {
    3.         public override string getDepart()
    4.         {
    5.            return"市場部";
    6.         }
    7.     }

3 下面代碼演示了如何調用這2種形態的方法，注釋中還給出了運行結果。

    Employee myee=new Employee();            //創建父類
    string str1=  myee.getDepart();               //結果為“父公司”
    MarketEmployee yee=new MarketEmployee();   //創建子類
    string str2 = yee.getDepart();//結果為“市場部”

2.3 面向對象開發的簡單實例

為了讓讀者徹底地掌握面向對象開發的技術，本節以一個非常簡單的案例，介紹如何在日常應用開發中，采用面向對象技術。

2.3.1 面向對象功能設計

本例要實現的功能是在一個公司中有2個部門：采購部和銷售部，這2個部門的員工具備相同的屬性：員工號、姓名、年齡、住址，但銷售部員工還有一個比較特別的屬性：銷售額。2個部門的員工也具備相同的“操作”：上班和下班。但采購部還有一個操作是采購，銷售部還有一個操作是銷售。圖2.3以圖形方式展現了這2個部門的相同點和不同點。

圖2.3 2個部門的相似點和不同點

2.3.2 面向對象的類設計

根據這2個部門的共性和特性，又為了以后擴展的需要，設計一個員工類（Employee），此類包含所有員工的共性。因為各個部門又有自己的特性，所以為每個部門單獨設計一個類，但這些類必須繼承員工類，才能包含那些共性。

圖2.4是一個標準的類設計圖，其中SaleEmployee表示銷售部門員工類，BuyEmployee表示采購部門員工類，這2個類都繼承自Employee（員工類）。

圖2.4 標準的類設計圖

2.3.3 面向對象的應用

【本節示例參考：\示例代碼\C02\ OOPSample】

本節將根據類的設計創建一個應用程序，創建的步驟如下：

1 打開VS2008，新建一個項目“OOPSample”。

2 在解決方案資源管理器的根目錄下，添加一個類“Employee.cs”，類的設計代碼如下所示，主要是設計員工的共性。

    1.     class Employee
    2.     {
    3.         //私有屬性的設計
    4.         private int_id;
    5.         private string_name;
    6.         private int_age;
    7.         private string_address;
    8.         public int EmployeeID  //員工號
    9.         {
    10.           get{return_id;}
    11.           set{_id=value;}
    12.        }
    13.        public string Name  //員工號
    14.        {
    15.           get{return_name;}
    16.           set{_name=value;}
    17.        }
    18.        public int Age  //員工號
    19.        {
    20.           get{return_age;}
    21.           set{_age=value;}
    22.        }
    23.        public string Address  //員工號
    24.        {
    25.           get{return_address;}
    26.           set{_address=value;}
    27.        }
    28.        public void WorkOn()
    29.        {
    30.           //上班操作的代碼
    31.        }
    32.        public void WorkOff()
    33.        {
    34.           //下班操作的代碼
    35.        }
    36.    }

3 在根目錄下再添加一個類“SaleEmployee.cs”，此類繼承Employee類，代碼如下所示，主要是設計銷售部員工的特性。

    1.     class SaleEmployee:Employee
    2.     {
    3.         private int_salecount;
    4.         public int SaleCount//銷售額
    5.         {
    6.            get{return_salecount;}
    7.            set{_salecount=value;}
    8.         }
    9.         public void Sale()
    10.        {
    11.           //銷售操作的代碼
    12.        }
    13.    }

4 在根目錄下再添加一個類“BuyEmployee.cs”，此類繼承Employee類，代碼如下所示，主要是設計采購部員工的特性。

    1.     class BuyEmployee:Employee
    2.     {
    3.         public void Buy()
    4.         {
    5.            //采購操作的代碼
    6.         }
    7.     }

5 下面的代碼演示如何在應用程序中，使用這2個部門的類。

        SaleEmployee mysale = new SaleEmployee();//實例化銷售部員工類
        mysale.Name = "銷售員1";
        mysale.Sale(); //銷售操作
        mysale.WorkOff(); //下班
        label1.Text=mysale.SaleCount.ToString(); //顯示此員工的銷售額
        BuyEmployee mybuy = new BuyEmployee();//實例化采購部員工類
        mybuy.Name = "采購員1";
        mybuy.WorkOn();//上班
        mybuy.Buy();//采購

承上啟下

■ 學完本章后，讀者需要回答：

1.什么是類？什么是對象？

2.如何聲明類、屬性、方法？

3.如何編譯類？

4.什么是接口，如何用C#實現一個接口？

5.什么是多態，如何實現類的多態？

6.什么是繼承？如何實現類的繼承？

7.是否對.NET基礎類庫框架有了初步的認識？

8.如何設計應用程序中的類，如何應用對象？

■ 在下一章中，讀者將會了解：

1.ASPX的幾個核心對象。

2.使用Response對象向瀏覽器輸出字符串。

3.使用Request對象接受用戶的POST方式和GET方式提交的數據。

4.使用Server對象獲取服務器的信息。

5.使用Application對象實現程序級別的數據共享。

6.使用Session對象實現會話級別的數據共享。

官术网_书友最值得收藏!

新手學ASP.NET 3.5網絡開發