设计理念中——抽象与接口和用（C#）

前言

在程序设计中，使用抽象类还是用接口应该是一个需要考虑的场景，有时我们感觉这两者并没有太大的区别，有时又有很大区别。这里是一些说明和示例。

一、抽象类和接口

1、相同点：

1)都可以被继承

2）都不能被实例化

3）都可以包含方法声明

4）派生类必须实现未实现的方法

2、区别

1）抽象基类可以定义字段、属性、方法实现。接口只能定义属性、索引器、事件、和方法声明，不能包含字段。
2）抽象类是一个不完整的类，需要进一步细化，而接口是一个行为规范。微软的自定义接口总是后带able字段，证明其是表述一类“我能做……”
3）接口可以被多重实现，抽象类只能被单一继承
4）抽象类更多的是定义在一系列紧密相关的类间，而接口大多数是关系疏松但都实现某一功能的类中。
5）抽象类是从一系列相关对象中抽象出来的概念，因此反映的是事物的内部共性；接口是为了满足外部调用定义的一个功能约定，因此反映的是事物的外部特性
6）接口基本上不具备继承的任何具体特点，它仅仅承诺了能够调用的方法。
7）接口可以用于支持回调，而继承并不具备这个特点。
8）抽象类实现的具体方法默认为虚的，但实现接口的类中的接口方法却默认为非虚的，当然您也可以声明为虚的。
9）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为 抽象方法而不必实现，而在抽象类的子类中实现接口中方法。

3、使用规则

1）抽象类主要用于关系密切的对象，而接口最适合为不相关的类提供通用功能。
2）如果要设计大的功能单元，则使用抽象类；如果要设计小而简练的功能块，则使用接口。
3）如果预计要创建组件的多个版本，则创建抽象类。接口一旦创建就不能更改。如果需要接口的新版本，必须创建一个全新的接口。
4）如果创建的功能将在大范围的全异对象间使用，则使用接口；如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类。
5）分析对象，提炼内部共性形成抽象类，用心表示对象本质，即“是什么”。为外部提供调用或功能需要扩充时优先使用接口。
6）好的接口定义应该是具有专一功能性的，而不是多功能的，否则生成接口污染。如果一个类只是实现了这个接口中一个功能，而不得不去实现接口中的其他方法，就叫接口在污染。
7）尽量避免使用继承来实现组建功能，而是使用黑箱复用，即对象组合。因为继承的层次增多，造成最直接的后果就是当调用这个类群中某一类，就必须把他们全部加载到栈中！后果可想而知
（结合堆栈原理理解）。微软在构建一个类时，很多时候用到了对象组合的方法。

二、代码示例

public delegate void EnableHadler(object sender, EventArgs e);
        public delegate void CPU_CallBack(CPU cpu);

        public interface I9_Cpu_Interface
        {
            void FCLGA1700();
            bool Enable
            {
                get;
            }
            int this[int index]
            {
                get;
            }
            event EventHandler EnableFCLGA1700;
        }
        public abstract class CPU : I9_Cpu_Interface
        {
            public event EventHandler EnableFCLGA1700;
            int[] pins;
            string _name;
            double _frequency;
            int _kernel;
            int _pinNum;
            bool _isEnableFCLGA1700;

            public CPU(string name, double frequency, int kernel, int pin, bool isEnableFCLGA1700)
            {
                _name = name;
                _frequency = frequency;
                _kernel = kernel;
                _pinNum = pin;
                pins = new int[pin];
                _isEnableFCLGA1700 = isEnableFCLGA1700;
                EnableFCLGA1700 += new EventHandler(CPU_EnableFCLGA1700);
            }

            void CPU_EnableFCLGA1700(object sender, EventArgs e)
            {
                Console.WriteLine("我支持FCLGA1700");
            }

            public string Name => _name;
            public double Frequency => _frequency;
            public int Kernel => _kernel;
            public int PinNum => _pinNum;

            protected abstract void ProwerOn();
            protected abstract void SelfCheck();
            public override string ToString()
            {
                return string.Format("我是{0} CPU,我的主频是{1:0.0},我有{2}个内核，我的引脚有{3}个", _name, _frequency, _kernel, _pinNum);
            }
            public int this[int index]
            {
                get
                {
                    if (index<pins.Length)
                    {
                        return pins[index];
                    }
                    return -1;
                }
            }

            public bool Enable {
                get
                {
                    if (_isEnableFCLGA1700)
                    {
                        EnableFCLGA1700.Invoke(this, null);
                    }
                    return _isEnableFCLGA1700;
                }
            }

            public void FCLGA1700()
            {
                Console.WriteLine("1、处理器最高可达二十四核。");
                Console.WriteLine("2、支持双通道DDR4或DDR5内存。");
                Console.WriteLine("3、支持PCI-E 5.0规范。");
                Console.WriteLine("4、芯片组使用单芯片设计，支持两个SATA 3Gbps和多达十个SATA/SAS 6Gbps接口。");


            }
        }

        public class i7_13900K : CPU
        {
            public i7_13900K()
                :base("i7_13900K", 5.8,16,1700,true)
            {
                Console.WriteLine(base.ToString());
                ProwerOn();

                SelfCheck();

            }
            protected override void ProwerOn()
            {
                Console.WriteLine("i7_13900K 上电完成");
            }

            protected override void SelfCheck()
            {
                Console.WriteLine("i7_13900K 自检完成");
            }
        }

         public class i7_14900K : CPU
        {
            public i7_14900K()
                : base("i7- 14900K", 6.0, 16, 1700, true)
            {
                Console.WriteLine(base.ToString());
                ProwerOn();

                SelfCheck();

            }
            protected override void ProwerOn()
            {
                Console.WriteLine("i7-14900K 上电完成");
            }

            protected override void SelfCheck()
            {
                Console.WriteLine("i7-14900K 自检完成");
            }
        }

        public class CreateCPU
        {
            CPU_CallBack callBack;
            CPU _cpu = null;
            public CreateCPU(CPU cpu)
            {
                _cpu = cpu;
                callBack = new CPU_CallBack(cpu_call_balc);
            }

            void cpu_call_balc(CPU u)
            {
                if (u.Enable)
                {
                    u.FCLGA1700();
                }
            }
            public void ShowMessage()
            {
                callBack.Invoke(_cpu);
            }
        }


        static void Main(string[] args)
        {
            CreateCPU createI7_13900k = new CreateCPU(new i7_13900K());
            createI7_13900k.ShowMessage();

            Console.WriteLine();

            CreateCPU createI7_14900k = new CreateCPU(new i7_14900K());
            createI7_14900k.ShowMessage();
            Console.Read();
        }

三、效果