生活小例子，通俗易懂讲接口

接口

注：本篇文字约4300字，可能花费10分钟。

　　先不讲开发中为什么要使用接口？有什么好处？

　　假设你是一个修水管的工人，有一个客户让你装水管，但是客户喜欢管子是三角形的。

　　很熟练的你就将水管安装到墙上，如图：

　　过几天，客户又来找你，他觉得三角形的不好看，要让你把三角形的管子，换成正方形的，你不得不还，因为顾客是上帝，（你会觉得为什么一开始不说要用正方形的管子呢？因为需求一直在变化。。。）如图：

　　哔哩啪啦的累的满头大汗，花费2 3个小时才将管子换成正方形的。没过多久，客户又来找你，这次客户想要换个椭圆形的管子。虽然很无奈，顾客是上帝，又花费几个小时换好管子，如图：

　　这时你可能会想，为什么换不同形状的水管，需要大动干戈一番呢？刚开始的时候，可以在墙上设计一个固定的水管，并且是圆形的，根据客户的喜好更换不同的水管。这样，以后都不用去动墙上的水管了。这个方法好！~~这就叫做接口，如图：

　　这里，我查阅了一下百度百科给接口最权威的定义。

　　接口：是指定一组函数成员而不实现成员的引用类型，其他类型-类和结构可以实现接口。

 换句话说：接口没有具体实现，他只是一种行为约束规范，需要子类继承该接口来实现方法。

 　　这就是为什么小白们会觉得接口什么都不做，只定义一个接口，没有任何实现，那不多此一举么？

　　下面我们在代码中体现接口的作用，再次声明，不讨论场景是否合情合理~~~

 需求：公司有两个人分别写了两个国家的母语类，来输出该国的母语，你来负责调用他们写好的类。

        class China //中国
        {
            public void Speak()
            {
                Console.WriteLine("我们国家说中国话！~");
            }
        }
        class America //美国
        {
            public void Speak()
            {
                Console.WriteLine("我们国家说英语！~");
            }
        }

你写的Country类

        class Country
        {
            public void show(China china)
            {
                china.Speak();
            }
            public void show(America america)
            {
                america.Speak();
            }
        }

调用

        static void Main(string[] args)
        {
            Country c = new Country();
            c.show(new China());
            c.show(new America());
            Console.ReadKey();
        }

过了一段时间，公司业务变了，需要增加一个俄罗斯类，暂且叫C吧，让C去写这个，并调用

        class China //中国
        {
            public void Speak()
            {
                Console.WriteLine("我们国家说中国话！~");
            }
        }
        class America //美国
        {
            public void Speak()
            {
                Console.WriteLine("我们国家说英语！~");
            }
        }
        class Russia //俄罗斯
        {
            public void Speak()
            {
                Console.WriteLine("我们国家说俄语！~");
            }
        }

于是你的Country类，又多了一个方法重载：

        class Country
        {
            public void show(China china)
            {
                china.Speak();
            }
            public void show(America america)
            {
                america.Speak();
            }
            public void show(Russia russia)
            {
                russia.Speak();
            }
        }

调用

        static void Main(string[] args)
        {
            Country c = new Country();
            c.show(new China()); //我们国家说中国话！~
            c.show(new America()); //我们国家说英语！~
            c.show(new Russia()); //我们国家说俄语！~
            Console.ReadKey();
        }

　　细心的你已经发现，多一个类，就多一个方法的重载，世界上还有怎么多的国家，以后增加一个，Country类就要修改一次，显然不是什么好事！

　　我们仔细观察Country类，不变的是show方法，变化的是show方法中的参数，如果有那么一个类，能接收所有世界各国，问题不就解决了嘛？聪明的你可能想到了重载，定义一个Person父类，让子类去继承，里面有个show方法。

终极代码

        static void Main(string[] args)
        {
            Country c = new Country();
            c.show(new China()); //我们国家说中国话！~
            c.show(new America()); //我们国家说英语！~
            c.show(new Russia()); //我们国家说俄语！~
            Console.ReadKey();
        }
        class China : Person //中国
        {
            public China() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
            {

            }
            public override void Speak() //注意增加了override，表示方法重写
            {
                Console.WriteLine("我们国家说中国话！~");
            }
        }
        class America : Person //美国
        {
            public America() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
            {

            }
            public override void Speak() //注意增加了override，表示方法重写
            {
                Console.WriteLine("我们国家说英语！~");
            }
        }
        class Russia:Person //俄罗斯
        {
            public Russia() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
            {

            }
            public override void Speak() //注意增加了override，表示方法重写
            {
                Console.WriteLine("我们国家说俄语！~");
            }
        }
        class Country
        {
            public void show(Person person)
            {
                person.Speak();
            }
        }
        class Person
        {
            public virtual void Speak() // 注意修饰符中增加了一个virtual，它表示此方法是虚方法，可以被子类重写
            {
                Console.WriteLine("我是Person父类");
            }
        }

　　不管以后还有什么国家的类，只要让需要添加的国家类，继承Person，并且有个Speak方法，那么就不用修改Country类了，只需要传入一个国家类的实例即可。

　　有一天，公司新来一个人，暂且叫D吧，现在让D写一个France（法国类），并且继承Person类，里面有个母语的方法。

D写的类如下：

        class France : Person //法国
        {
            public France() : base()
            {

            }
            public void MotherLanguage()
            {
                Console.WriteLine("我们国家说法语！~");
            }
        }

调用

        static void Main(string[] args)
        {
            Country c = new Country();
            c.show(new China()); //我们国家说中国话！~
            c.show(new America()); //我们国家说英语！~
            c.show(new Russia()); //我们国家说俄语！~
            c.show(new France()); //我是Person父类
            Console.ReadKey();
        }

　　很显然不是我们想要的输出结果，你不得不花点时间去排查原因，最后你发现原来D虽然写了。

　　France类，但是他并不知道之前约定的命名为：Speak()

　　D写的France类中，里面的方法是：MotherLanguage()

　　细心的童鞋们已经发现问题的关键了，虽然D继承了Person类，但是没有一种约束，使其继承父类的时候必须实现父类中的方法。有没有一个类，能让它的子类必须实现它定义的方法？？？

　　有，那就是接口。

接口如下：

        interface Person
        {
            void Speak();
        }

　　由于Person接口有一个Speak()方法，所有子类继承接口的类，必须实现该方法，否则程序不能通过。

　　这时你再想想，虽然继承一个父类也可以满足要求，但是一个父类根本没有约束力，而接口就不一样了，子类继承接口，必须实现接口中的所有方法。

　　在多人协作下，定义一系列方法，让子类必须继承该接口，防止在调用一个人写的子类时，找不到方法。

最终完整代码

        static void Main(string[] args)
        {
            Country c = new Country();
            c.show(new China()); //我们国家说中国话！~
            c.show(new America()); //我们国家说英语！~
            c.show(new Russia()); //我们国家说俄语！~
            c.show(new France()); //我们国家说法语！~
            Console.ReadKey();
        }
        class China : Person //中国
        {
            public void Speak() //注意增加了override，表示方法重写
            {
                Console.WriteLine("我们国家说中国话！~");
            }
        }
        class America : Person //美国
        {
            public void Speak() //注意增加了override，表示方法重写
            {
                Console.WriteLine("我们国家说英语！~");
            }
        }
        class Russia : Person//俄罗斯
        {
            public void Speak() //注意增加了override，表示方法重写
            {
                Console.WriteLine("我们国家说俄语！~");
            }
        }
        class France : Person //法国
        {
            public void Speak()
            {
                Console.WriteLine("我们国家说法语！~");
            }
        }
        class Country
        {
            public void show(Person person)
            {
                person.Speak();
            }
        }
        interface Person
        {
            void Speak();
        }

开放闭关原则：

　　对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。