接口

接口是多态的第三种实现形式

一.什么时候用接口：

1.类需要多继承的时候，因为类是不允许多继承（继承多个类，有多个父类）的，所以会用到接口

二、接口是什么：

1.接口是一种规范，是一种能力

2.接口的语法：

接口中的成员不可以有访问修饰符，默认为public

接口中的函数不可以写方法体

public interface Iflyable
    {
        //接口中的成员不可以有访问修饰符，默认为public
        void fly();

        string Test();//可以有返回值
        //接口中的函数不可以写方法体

        //接口中可以有自动属性，属性其实就是方法，自动属性中的get ，set方法是没有函数体的；
        string Name
        {
            get;
            set;
        }
    }

 2.1普通属性与自动属性

普通属性：需要自己定义字段，写出get与set方法

自动属性：字段是自己生成的，get与set方法都是没有方法体的，不可以修改set与get方法；如果想要修改get与set方法，必须在构造函数中进行修改

class Class1
    {
        string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public int Age {
            get;
            set;
        }
        
        
    }

3.接口要求：

只要一个类继承了一个接口，这个类就必须实现这个接口中的所有成员.

为了多态，接口不能被实例化；也就是说，接口不能new （不能创建对象）

如下所示：fly既可以表现出人类的特征又可以表现出鸟类的特征，所以这就实现了多态

class Program
    {
        static void Main(string[] args)
        {
            IFlyable fly = new Bird();//new Person();
            fly.Fly();
        }
    }
    class Person:IFlyable
    {
       public void Fly()
        {
            Console.Write("人类在飞");
        }
    }
    class Bird:IFlyable
    {
        public void Fly()
        {
            Console.Write("鸟在飞");
        }
    }
    public interface IFlyable
    {
        //接口中的成员只能包括：方法，自动属性
        //方法不可以有方法体
        void Fly();
    }
}

（默认为public）接口中的成员不能有任何的实现（“光说不做” 只是定义了一组未实现的成员）

接口中只能有方法，属性，索引器，事件，不可以有字段和构造函数

接口与在接口之间可以继承，并且可以多继承

public interface M1
    {
        void Test1();
    }
    public interface M2
    {
        void Test2();
    }
    public interface M3
    {
        void Test3();
    }
    public interface Superinterface : M1, M2, M3
    {

    }
    class Student : Superinterface
    {
        public void Test1()
        {
            throw new NotImplementedException();
        }

        public void Test2()
        {
            throw new NotImplementedException();
        }

        public void Test3()
        {
            throw new NotImplementedException();
        }
    }

 

接口并不能去继承一个类，而一个类可以去继承接口（接口只能继承接口，而类可以继承接口，也可以继承类）

实现接口的子类必须实现该接口的全部成员

一个类可以继承一个类，并实现多个接口，如果一个类继承了父类A，并实现了接口IA，语法上必须写在IA前面,因为类是单继承的

class MyClass:A,IA{}

 

显示实现接口的目的，解决方法的重名问题

下列代码中，方法Fly()是Bird类的方法，但却默认成了接口中的方法，这是方法重名造成的：

class Bird:IFlyable
    {
        public void Fly()
        {
            Console.Write("鸟会飞");
        }
    }
    public interface IFlyable
    {
        void Fly();
    }

 

什么时候显示的去实现的接口：

当继承的接口中的方法和参数一模一样的时候，要使用显示的实现接口

class Program
    {
        static void Main(string[] args)
        {
            //显示接口就是为了解决方法的重名问题
            IFlyable fly = new Bird();
            fly.Fly();//接口的Fly（）
            Bird bird = new Bird();
            bird.Fly();//Bird类中的Fly（）
        }
    }
    class Bird:IFlyable
    {
        public void Fly()
        {
            Console.Write("鸟会飞");
        }
        //显示的接口实现
         void IFlyable.Fly()
        {
            Console.Write("我是接口中的飞");
        }
    }
    public interface IFlyable
    {
        void Fly();
    }

 

当一个抽象类实现接口的时候，需要子类去实现接口