面向對象（二）——三大特性（封裝、繼承、多態）

一、封裝

目的：保護類，讓類更加安全。

做法：讓類裡面的成員變數變為私有（即訪問修飾符）的，做相應的方法或者屬性去間接的操作成員變數

※訪問修飾符

private 私有的              只能在該類中訪問

protected 受保護的       只能在該類和它的子類中訪問

public 公有的                在任何地方都可以訪問

△封裝成員方法來間接操作類裡面的成員變數

例：

class Ren
    {
        private string name;
        private int age;  //年齡必須在18-50之間
        //取age的值
        public int GetAge()
        {
            return age;
        }
        //給age賦值
        public void SetAge(int a)
        {
            if (age >= 18 && age <= 50)
            {
                age = a;
            }
            else
            {
                age = 18;
            }
        }
        //取name的值
        public string GetName()
        {
            return name;
        }
        //給name賦值
        public void SetName(string n)
        {
            name = n;
        }
    }

static void Main(string[] args)
        {
            Ren r = new Ren();
            r.SetAge(8);
            r.SetName("張三"); //將’張三‘賦值給成員name
            Console.WriteLine(r.GetAge+r.GetName);
            Console.ReadLine();
        }

△使用成員屬性來間接訪問類裡面的成員變數

　　定義變數的時候最好用_下劃線開頭

　　選中要做的成員變數右鍵→重構→封裝欄位（ctrl+r,e）

      自動生成的代碼不是成員變數也不是成員方法  是成員屬性

      造好之後可以通過成員屬性操作成員變數

例：

class Student
    {
        private string _Name;
        public string Name
        {
            get { return _Name; }//簡化的方法
            set { _Name = value; }
        }
        private int _Age;
        public int Age 
        {
            get { return _Age; }
            set 
            {
                if (value >= 18 && value <= 50)
                {
                    _Age = value;
                }
                else
                {
                    _Age = 18;
                }
            }
        }

        private string _Sex;
        public string Sex {get;set;}//簡寫 缺點：不能控制值，不能用於構造函數
    }

static void Main(string[] args)
        {
            Student s = new Student();
            s.Name="趙四";
            s.Sex="男";
            s.Age=19;
            Console.WriteLine(s.Sex+s.Name+s.Age);
            Console.ReadLine();
        }

構造方法（函數）：

作用：造對象所要調用的方法，用來創建對象

　　    每一個類都有一個構造方法，不寫也有隻不過看不到而已

特殊性：寫法特殊 （方法名=類名；沒有返回值）

　　　　  執行時間特殊（創建對象時執行）

用途：可以對成員進行初始化

舉個例子：

class Student
    {
        public Student(string s,string n)
        {
            _Sex = s;
            _Name = n;
        }
    }

static void Main(string[] args)
        {
           Student s = new Student("男","張三");//new Student()就是調用了一個方法

            Console.WriteLine(s.Sex+s.Name);
            Console.ReadLine();
        }

舉個慄子：使用面向對象來求兩個圓之間的面積

class Program
    {
        static void Main(string[] args)
        {
            Yuan y1 = new Yuan();
            y1.R = 10;
            Yuan y2 = new Yuan();
            y2.R = 5;

            double cha = y1.mianji() - y2.mianji();
            Console.WriteLine(cha);
            Console.ReadLine();
        }
    }
    class Yuan
    {
        private int r;

        public int R
        {
            get { return r; }
            set { r = value; }
        }
        public double mianji()
        {
            return r * r * 3.14;
        }
        public double zhouchang()
        {
            return 2 * r * 3.14;
        }
    }

函數重載：

函數重載需要的條件：函數名要相同，參數的個數或者參數的類型不同

this關鍵字：

雖然寫在類裡面，但不是屬於類的，而是屬於該對象的

一般來說在類裡面 this關鍵字是可以省略的，但是如果有一個方法形參名字和成員名字重覆，這時候再調用該對象裡面的成員的時候需要加this關鍵字

is關鍵字： 判斷變數是不是屬於某個類型

例：if (y2 is Ren) 　　

    { 　　　　

                 s = "是一個人"; 　　

    } 　　

    else 　　

    { 　　　　

                s = "不是一個人"; 　　

    }

as關鍵字： 轉換類型（只能轉換相容類型，可以將子類對象轉換為父類對象）

二、繼承

子類可以繼承父類的一切

特點：單繼承   一個子類只能有一個父類  一個父類可以有多個子類

C#特殊點：所有類的祖先都是object

base關鍵字：在子類中代表父類對象，用法和this關鍵字相同 　　　　　　  

                   如果父類有構造方法，那麼子類也要有構造方法，如果父類構造需要參數，那麼子類構造也必須有相應的參數。 　　　　　　  

                   子類構造後面可以通過base調用父類的構造方法 　　　　　　  

                   public China(string m):base(m) {}

class Program
    {
        static void Main(string[] args)
        {
            China c = new China("zs");
            Console.WriteLine(c.Eat());
            Console.ReadLine();
        }
    }

    class Ren
    {
        private string _Name;

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

        public int Age
        {
            get { return _Age; }
            set { _Age = value; }
        }
        //父類的構造方法
        public Ren(string n)
        {
            _Name = n;
        }

        public string Speak()
        {
            return _Name+"人類正在講話";
        }

    }

    class China:Ren
    {
        public China(string m):base(m)
        {
            
        }
        public string Eat()
        {
            return base.Name+"用筷子吃飯";
            //return base.Speak();
        }
    }
    class America : Ren
    {
        public America(string m): base(m)
        {
            
        }
        public string Eat()
        {
            return "用刀叉吃飯";
        }
    }

sealed關鍵字：

密封類 該類不可以被繼承

sealed class 類名

{

}

部分類：partial

可以將一個類拆分成多個部分，分別放在多個文件內

調用需要namespace相同，或用use引用

namespace 命名空間 相當於虛擬文件夾

partial class 類名   //拆分的類均加partial

{

}

三、多態

1.編譯多態

函數重載

2.運行多態

概念：當父類引用指向子類實例的時候，由於子類對父類的方法進行了重寫，在調用該方法的時候表現出的不同就稱為多態

條件：必須要有繼承  父類引用指向子類實例  子類必須對父類的方法進重寫

里氏代換原則：如果有一個地方需要使用到父類對象，那麼你可以將一個子類對象給他

class Program
    {
        static void Main(string[] args)
        {
 　　　　    DongWu dw = new Dog();            
　　　　　　　Dog d = new Dog();
            Console.WriteLine(Ceshi(dw));
            Console.WriteLine(CeShi(d));
            Console.ReadLine();
        }

        public static string CeShi(DongWu d)
        {
            return "ok";
        }
    }

    class DongWu
    {
        public virtual string Eat() //虛方法
        {
            return "該動物在吃飯";
        }
    }
    class Dog:DongWu
    {
        public override string Eat() //重寫
        {
            return "狗正在吃骨頭";
        }
    }
    class Cat : DongWu
    {
        public override string Eat()
        {
            return "貓正在吃魚";
        }
    }