C#基礎-面向對象詳解

面向對象詳解

一.什么是面向對象

1>面向對象是一種程序設計思想

2>面向過程和面向對象是什么？

例如要把大象放冰箱怎么做？

面向過程:打開冰箱門->把大象扔進去->關上冰箱門（如下圖）

面向對象：兩個對象，大象和冰箱。大象有自己的固有屬性高和重量，還有兩個動作分別是進冰箱和出冰箱。冰箱也有自己固有屬性高和重量，動作也有開門和關門

 

 

區分：

1.面向過程是解決問題的常規思路，更加符合解決問題的想法，但是隨着步驟越來越多，就很難滿足需求了。

2.面向對象是把東西分拆為各個對象，每個對象完成自己的核心動作，分工合作，對象之間交互完成功能。

 

二.面向對象的三大特性

1.封裝
下面幾行代碼，就是封裝一個對象，描述的是一只大象，大象有一些特性（身高和重量）和行為（進冰箱或出冰箱）

  public class Elephant
    {
        public int Height = 0;
        public int Weigth = 0;
        public void IntoFridge()
        {
            Console.WriteLine("進冰箱");
        }
        public void OutFridge()
        {
            Console.WriteLine("出冰箱");
        }
    }

總結：

1>把數據和行為打包到class中,就叫封裝

2>封裝的好處有，數據安全，提供重用性，分工合作和方便構建大型復雜的項目

2..繼承

下面幾行代碼，就是實現了繼承，大象子類繼承了動物父類，其中完全一樣的特性（身高，體重）和行為（吃東西）放到父類中，這樣做的好處是可以去掉重復代碼

大象子類可以擁有動物父類的一切公開的屬性和行為，不管大象是否願意，它都必須擁有父類的公開東西。繼承也是實現多態的，接下來會講到。

 

    public class Elephant: Animal
    {
        //public int Height = 0;
        //public int Weigth = 0;
        public void IntoFridge()
        {
            Console.WriteLine("進冰箱");
        }
        public void OutFridge()
        {
            Console.WriteLine("出冰箱");
        }
        //public void CanEat()
        //{
        //    Console.WriteLine("我可以吃東西");
        //}
    }
    public class Animal
    {
        public int Height = 0;
        public int Weigth = 0;
        public void Eat()
        {
            Console.WriteLine("我可以吃東西");
        }
    }

3.多態

1>說白了，可以理解為有相同的變量，相同的操作，但是不同的實現
2>多態種類包括：方法的重載；接口&&實現；抽象&&實現 ；繼承

例如下圖：都是實例化的Animal，都是調用的Eat方法，一個執行的是大象的吃方法，一個執行的是人的吃方法，這就可以理解為相同的變量，相同的操作，實現方式不同，這就是多態啦！是運行時多態（程序運行時，實現的多態）

using System;

namespace _002_Attribute
{
    class Program
    {
        static void Main(string[] args)
        {
            Animal animal = new Elephant();
            animal.Eat(); 
            Animal animal1 = new People();
            animal1.Eat();
            Console.Read();
        }
    }
    public class Elephant : Animal
    {
        public void IntoFridge()
        {
            Console.WriteLine("進冰箱");
        }
        public void OutFridge()
        {
            Console.WriteLine("出冰箱");
        }
        public override void Eat()
        {
            Console.WriteLine("我是大象，我吃植物");
        }
    }
    public class People : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("我是人，我吃米飯");
        }
    }
    public abstract class Animal
    {
        public int Height = 0;
        public int Weigth = 0;
        public abstract void Eat();//抽象方法，必須在抽象類中
    }
}

4.抽象

面向對象說是有封裝，繼承，多態三大特性，也可以說成有四大特性，包括抽象，抽象也是很常見的。

1>抽象方法：子類都得有，實現方式不同，此時考慮用抽象方法。這里注意，抽象方法必須在抽象類中

1>抽象類：

         首先抽象類是父類，里面放得都是共有的東西；

         抽象類中有約束（抽象方法）；

         抽象類是不能實例化，只能由實現抽象了的子類去實例化

         抽象類中，放的都是共有的東西

三.怎么選擇抽象類和接口(重點)

接口：約束
1>只能約束

2>特點是，多實現，更加靈活

3>語義方面有點像：can do，可以說“實現接口的子類 can do 接口約束”

4>有的子類有，有的子類沒有的情況，就要考慮用接口

抽象類:父類+約束

1>可完成通用的實現,只能單繼承

2>語義方面有點像： is a，可以說“子類is a 父類”

選擇接口還是抽象類的原則：子類都一樣的，放在父類；子類都有但是不同，放在父類抽象一下;有的子類有，有的子類沒有，那就用接口
一般情況，接口用的更多，因為接口更簡單靈活 除非有些共有的需要繼承，下面是一個小例子：

需求：門，有材質，貓眼，門鈴，開門（），關門（），煙霧報警（）；等。

請問：用面向對象的程序設計思想，怎么去封裝？？（值得深思，希望能起到與一反三的效果）

    interface IExtend
    {
        string CatEye { get; set; }//貓眼  
        string Doorbell { get; set; }//門鈴
        void SmokeAlarm();//煙霧報警

    }
    public abstract class BaseDoor
    {
        public string RawStock { get; set; }//材料

        //以下兩個開門和關門在父類用抽象，因為開關門的方式會有不同，有些門自動開關，有些需要人去開關
        public abstract void Open();//開門
        public abstract void Close();//關門
    }

四.抽象方法和虛方法的區別

1>最本質的區別：虛方法帶有實現（方法體），可以被重載；抽象方法沒有實現

2>下面的例子，詳細說明了抽象方法和虛方法的用法，程序中做了很詳細的注釋，程序運行結果如下圖：

 

using System;

namespace _002_Attribute
{
    class Program
    {
        static void Main(string[] args)
        {
            //虛方法/抽象方法，程序編譯時候，左邊遇到virtual/abstract時，做個標記，等程序運行的時候，判斷右邊是否有override，如果有，就以右邊為准
        
            ParentClass parent = new Child();
            parent.CommonMethod();//普通方法，父類為准；這個是編譯時確定的，特點是：效率高
            parent.VirtualMethod1();//虛方法，子類沒重載，左邊為准
            parent.VirtualMethod2();//虛方法，子類有重載，右邊為准；運行時確定，特點是為了靈活
            parent.AbstractMethod();//抽象方法，右邊為准；運行時確定，特點是為了靈活
            Console.Read();
        }
    }
    public class Child : ParentClass
    {
        public override void VirtualMethod2()//子類重載了父類的 VirtualMethod2
        {
            Console.WriteLine("我是子類,重載虛方法2");
        }
        public override void AbstractMethod()
        {
            Console.WriteLine("我是子類,實現后的抽象方法");
        }
    }
    public abstract class ParentClass
    {
        /// <summary>
        /// 普通父類方法
        /// </summary>
        public void CommonMethod()
        {
            Console.WriteLine("我是父類，普通方法");
        }
        /// <summary>
        /// 父類虛方法，必須包含實現，可以被重載
        /// </summary>
        public virtual void VirtualMethod1()
        {
            Console.WriteLine("我是父類，虛方法1");
        }
        public virtual void VirtualMethod2()
        {
            Console.WriteLine("我是父類，虛方法2");
        }
        /// <summary>
        /// 我是抽象方法
        /// </summary>
        public abstract void AbstractMethod();
    }

}