狼子()  14:54:23
我不是很搞得明白接口的，因为我老想不懂接口有什么用，接口只是定义方法，只是定义，又不给出方法里的代码，使用接口的类，就变成要把接口里的类的方法的代码全部写出来了

比如说一个接口里有CallMother()这样子的方法，然后呢，有一个类用到这个接口，那这个类里就要给出CallMother() { //给妈妈打电话的全部代码 }

有什么类用到这个接口，什么类就要自己去重新搞它，有什么好处呢？

逍遥书生()  14:56:28
这个也有好处的

逍遥书生()  14:59:05
1.客户端用户不知道也不必知道组件内部的具体实现，只需使用组件提供的接口就可以了！这样既方便了客户端用户，又可防止客户端的误操作！  
  2.可以用不同的语言编写！！  
  3.接口一旦定义，就是一层不变的，这样便于组件的版本升级！   

逍遥书生()  15:00:32
使用接口可以使程序更加清晰和条理化

狼子()  15:05:01
１、客户端用户如果要用接口，还要自己写接口里每个方法的实现代码，比如这样子的接口：
interface IAdd
{
  int AddNumber(int a, int b);
}
Ａ用户可以这样子定义：
public class AddNumber : IAdd
{
  public AddNumber(int a, int b) { return a + b; }
}
Ｂ用户可以这样子定义：
public class AddNumber : IAdd
{
  public AddNumber(int a, int b) { return a - b; }
}
Ａ、Ｂ用户都实现了接口里的方法，就是Ｂ用户肯定是错误的方法，这个不叫误操作，这个叫做大bug呢

２、可以用不同的语言编写，这个在.net里，本来就可以用不同的语言编写啊，在同一个网站里，在同一个项目里，都可以又用VB.NET又用C#的，只要最后编译过了就行

３、接口只是定义了方法，定义方法的名称、参数、返回值，就是，里面的东西什么都不定义，想怎么改就怎么改，为什么还叫一层不变呢？就是方法名称这一层不变吗？

逍遥书生()  15:06:50
哈哈

狼子()  15:07:42
我知道接口是好东西，不是好东西，不会这么多人用，就是，我想不懂他为什么好，他就像一件衣服，每个人都可以穿。。。

狼子()  15:10:08
一件衣服，每个人都可以穿，就是，有的人穿着刚刚好，有的人穿着太大了，有的人穿着太小了，就好像实现方法的代码都不相同一样子，那做这件衣服干什么呢？为什么不直接给每个人一件衣服呢？

逍遥书生()  15:10:56
我想想怎么说好些呢，比如有人这个类，吃饭是个接口，中国人是人的子类，实现的吃饭的接口是吃中餐，外国人实现的时吃西餐，虽然吃的方法不一样，但都要吃饭这个事先要定义好，不然如果你有个子类不吃饭那就是个怪人了

逍遥书生()  15:11:41
如果这个类指定了必须实现吃饭这个接口的话就不必担心弄出不吃饭的人来了

狼子()  15:12:03
每个人都要吃饭，先定义了这个方法，规定每个人都要吃饭，吃什么饭，就自己定义？

逍遥书生()  15:12:30
是的，不同的子类吃饭的方法不一样

狼子()  15:12:42
我有点明白，我在想

逍遥书生()  15:12:56
但大家都必须吃饭

逍遥书生()  15:16:34
我说的不同国家是不同的子类

逍遥书生()  15:17:51
我的意思是，中国人、外国人这些类都要实现吃饭这个接口

逍遥书生()  15:18:29
这样就可以避免弄出不吃饭的人来

逍遥书生()  15:20:29
不过我觉得这种东西也不是非用不可的，尤其是小项目

狼子()  15:21:50
用接口定义好，每个人都要吃饭
interface IHuman { void Dine(); void Dressing(); void Sleep(); }

然后呢，给出好多个类，每个类都要实现这些方法
public class Chinese : IHuman
{
  public void Dine() { return Chinese food; }
  public void Dressing() { if(boy) { return pants; } else { return skirt; } }
  public void Sleep() { return bed; }
}
public class English : IHuman
{
  public void Dine() { return English food; }
  public void Dressing() { if(boy) { return pants; } else { return skirt; } }
  public void Sleep() { return bed; }
}
看这两个类，对吃饭Dine这个方法，是不同的，所以可以返回不同的方法，接口定义下了是必须要有这个方法，所以必须要吃饭，那穿衣和睡觉呢？两个类，都是完全一样子的方法啊，这样子，如果每个国家的人都要定义一个类，那这样子对dressing和sleep有什么好处呢？

狼子()  15:25:26
书生。。。你说的吃饭我懂了，必须吃饭，就是一个规定，大家都要吃饭，就是，这个规格，有时候是全部一样子的，就是，他又是必须的规定，就像穿衣服和睡觉一样子

狼子()  15:26:30
对全部一样子的规定，接口有什么好处呢？每个类都要重新实现他。。。

逍遥书生()  15:29:47
我想想怎么说呢

逍遥书生()  15:36:00
比如这中国人、英国人类是你定义的，别人对他的实例进行操作时，只要知道这个类是实现了吃饭这个接口的，在要吃饭时直接调用吃饭方法就可以了，不要担心有什么问题

狼子()  15:36:36
那是类啊

狼子()  15:38:08
在要吃饭的时候，是这样子吃的：
Chinese c = new Chinese();
c.Dine();
对不对？有没有接口，不知道，只要知道Chinese类里有Dine方法

狼子()  15:38:43
嗯，我想啊，刚才应该再加上一个die方法的

逍遥书生()  15:43:10
哈哈，这个只能自已慢慢理会

狼子()  15:44:20
我都理会这么久了。。。我就是搞不懂接口干什么用

狼子()  15:44:39
多麻烦啊，还要搞一个接口出来

using System;

namespace studyInterface
{
    //定义接口，在接口里，只声明方法，不包含方法的内容块
    interface ICreature
    {
        void Dine();    //吃饭
        void Sleep();   //睡觉
        void Die();     //死亡
    }
   
    //定义Creature类，声明这个类继承自ICreature，这个是基类，里面实现ICreature中定义的三个方法，设置这三个方法为虚拟方法，允许子类覆盖
    public class Creature : ICreature
    {
        //定义一个类成员变量，记录生物的名称或人的名字
        protected string name = "";

        //实现继承IHuman接口的三个方法
        public virtual void Dine()
        {
            Console.WriteLine("{0} eats nothing today.", name);
        }
        public virtual void Sleep()
        {
            Console.WriteLine("{0} sleeps most of the night.", name);
        }
        public virtual void Die()
        {
            Console.WriteLine("{0} die.", name);
        }
    }

    //定义Human类，声明这个类继承自Creature，添加一个Dressing方法
    public class Human : Creature
    {
        //添加一个成员变量，记录性别
        protected string sex = "";

        //添加Dressing(穿衣)方法
        public void Dressing()
        {
            string dress = "nightgown";
            switch (dress)
            {
                case "boy":
                    dress = "pants";
                    break;
                case "girl":
                    dress = "skirt";
                    break;
            }
            if (sex.Equals(""))
            {
                Console.WriteLine("{0} wears a {1}.", name, dress);
            }
            else
            {
                Console.WriteLine("{0} is a {1} wearing the {2}.", name, sex, dress);
            }
        }
    }

    //定义Animal类，声明这个类也继承自Creature，重写Dine方法
    public class Animal : Creature
    {
        //添加一个成员变量，记录是不是食肉动物
        protected bool isCarnivore;

        //重写Creature类的Dine(吃饭)方法
        public override void Dine()
        {
            if (isCarnivore)
            {
                Console.WriteLine("{0} has meat today.", name);
            }
            else
            {
                Console.WriteLine("{0} has grass today.", name);
            }
        }
    }

    //定义Chinese类，声明这个类继承自Human
    public class Chinese : Human
    {
        //构造函数
        public Chinese(string personName, string personSex)
        {
            name = personName;
            sex = personSex;
        }
    }

    //定义English类，声明这个类继承自Human
    public class English : Human
    {
        //加一个成员变量，设置是不是Scottie
        protected bool isScottie = false;

        //构造函数
        public English(string personName, string personSex, bool pIsScottie)
        {
            name = personName;
            sex = personSex;
            isScottie = pIsScottie;
        }

        //重写父类Human的Dressing方法
        new public void Dressing()
        {
            if (isScottie)
            {
                Console.WriteLine("{0} is a Scottie wearing a kilt.", name);
            }
            else
            {
                Console.WriteLine("{0} wears a robe.", name);
            }
        }
    }

    //定义Hen类
    public class Hen : Animal
    {
        public Hen()
        {
            name = "Hen";
            isCarnivore = false;
        }
        //重写Dine方法
        public override void Dine()
        {
            Console.WriteLine("{0} pecks the corn.", name);
        }
    }

    //定义Tiger类
    public class Tiger : Animal
    {
        public Tiger()
        {
            name = "Tiger";
            isCarnivore = true;
        }

        //重写Dine方法
        public override void Dine()
        {
            Console.WriteLine("{0} preys on bunny.", name);
        }
    }

    //定义Owl类
    public class Owl : Animal
    {
        public Owl()
        {
            name = "Owl";
            isCarnivore = true;
        }
       
        //重写Dine方法
        public override void Dine()
        {
            Console.WriteLine("{0} catchs a mice.", name);
        }

        //重写Sleep方法
        public override void Sleep()
        {
            Console.WriteLine("{0} sleeps most of the day.", name);
        }
    }

    public class TestInterface
    {
        public static int Main()
        {           
            Chinese c = new Chinese("Lanlan", "girl");
            c.Dressing();
            c.Dine();
            c.Sleep();
            Console.WriteLine("--------------------");

            English e = new English("Peter", "boy", true);
            e.Dressing();
            e.Dine();
            e.Sleep();
            e.Die();
            Console.WriteLine("--------------------");

            Hen h = new Hen();
            h.Dine();
            h.Sleep();
            h.Die();
            Console.WriteLine("--------------------");

            Tiger t = new Tiger();
            t.Dine();
            t.Sleep();
            t.Die();
            Console.WriteLine("--------------------");

            Owl o = new Owl();
            o.Dine();
            o.Sleep();
            o.Die();

            return 0;
        }
    }
}