C#抽象类、接口说明

很多初学者看抽象类和接口那一长串的定义就被绕晕了，更别提灵活使用了。

要了解抽象类和接口，首先我们要知道他们是怎么来的，不要死背定义。
抽象类和接口都是“软件工程产物”，具体类->抽象类->接口，越来越抽象，内部实现的东西越少。

首先，定义两个类，他们结构非常相似。

    class Car
    {
        public void Run()
        {
            Console.WriteLine("Car is Running");
        }

        public void Stop()
        {
            Console.WriteLine("Stop");
        }
    }

    class Trunk
    {
        public void Run()
        {
            Console.WriteLine("Trunk is running");
        }

        public void Stop()
        {
            Console.WriteLine("Stop");
        }
    }

这样整两个类是不是很麻烦，懒得打字，还占内存。
为了简化上述代码，我们合并代码，求同存异

    class Vehicle1
    {
        public void Stop()
        {
            Console.WriteLine("Stop");
        }

        public void Run(string type)
        {
            if(type == "Car")
            {
                Console.WriteLine("Car is running");
            }
            else if(type == "Trunk")
            {
                Console.WriteLine("Trunk in running");
            }
            else if (type == "Racing Car")	//增加一个Racing Car
            {
                Console.WriteLine("Racing car is running");
            }
        }
    }

以上处理方式不易于扩展，增加一个type就必须改原来封装好的类。
不符合开闭原则。非必要的bug、需求，尽量不动封装好的代码。

下面进一步优化，用继承，重写基类虚方法实现多态。

    //定义基类
    class Vehicle2
    {
        public void Stop()
        {
            Console.WriteLine("Stop");
        }

        public void Fill()
        {
            Console.WriteLine("Pay and fill");
        }

        //虚方法
        public virtual void Run()
        {
            Console.WriteLine("Vehicle is running");
        }
    }

    //子类
    class Car2:Vehicle2
    {
        //重写基类Run方法
        public override void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

    //子类
    class Truck2:Vehicle2
    {
        //重写基类Run方法
        public override void Run()
        {
            Console.WriteLine("Truck is running");
        }
    }
    
    //新加的子类，不会对已有的结构进行改动
    class RacingCar2 : Vehicle2
    {
        //重写基类Run方法
        public override void Run()
        {
            Console.WriteLine("RacingCar is running");
        }
    }

以上处理方式，易于扩展，且符合开闭原则。
但如果基类不会被实例化，它的Run方法永远不会被调用呢？那基类虚方法实现部分完全没有意义。

由此产生了抽象类的概念。

    //定义抽象类
    abstract class Vehicle3
    {
        public void Stop()
        {
            Console.WriteLine("Stop");
        }

        public void Fill()
        {
            Console.WriteLine("Pay and fill");
        }

        //抽象方法
        //没有实现的方法
        public abstract void Run();
    }

    //子类
    class Car3:Vehicle3
    {
        //实现虚方法
        public override void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

    //子类
    class Truck3:Vehicle3
    {
        //实现虚方法
        public override void Run()
        {
            Console.WriteLine("Truck is running");
        }
    }

抽象方法：只有方法声明，没有实现的方法。进一步优化了代码。它会在子类中被实现。因此不能定义为private
抽象类：未完全实现逻辑的类，不能被实例化。可以有字段和非public类（实现部分，代表了具体逻辑）。为复用而生，专门作为基类来使用，也具有解耦功能。封装确定的，开放不确定的下推到合适的子类中实现。

如果抽象类的全部成员都未实现，它是个纯虚类。
接口就出现了。

    //接口
    //将成员下推到Vehicle4中实现
    interface IVehicle
    {
        void Stop();
        void Fill();
        void Run();
    }

    //实现IVehicle接口中的两个成员，将Run下推到子类中实现
    abstract class Vehicle4:IVehicle
    {
        public void Stop()
        {
            Console.WriteLine("Stop");
        }

        public void Fill()
        {
            Console.WriteLine("Pay and fill");
        }

        //抽象方法
        public abstract void Run();
    }

    class Car4:Vehicle4
    {
        public override void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

    class Truck4:Vehicle4
    {
        public override void Run()
        {
            Console.WriteLine("Truck is running");
        }
    }

接口：完全未实现的类（“纯虚类“），只有函数成员，不能被实例化。为解耦而生，高内聚、低耦合，方便单元测试。它是一个协议。

建议大家可以找找张铁锰的教程视频看看，他讲得深入浅出，很适合新手入门。