interface

     //interface IMyInterface
    //{
    //    // 接口成员
    //    void MethodToImplement();
    //}
    
    //class InterfaceImplementer : IMyInterface
    //{
    //    static void Main()
    //    {
    //        InterfaceImplementer iImp = new InterfaceImplementer();
    //        iImp.MethodToImplement();
    //    }
    
    //    public void MethodToImplement()
    //    {
    //        Console.WriteLine("MethodToImplement() called.");
    //    }
    //}

//隐式实现接口时，接口和类（实现接口的类）都可以访问类中的方法；
//显式实现接口时，只有通过接口来访问类中的方法；
//接口可以继承接口，接口成员不能用public, protected internal private 等访问修饰符，接口里面的方法都是由外面接口实现去实现方法体，那么修饰符必public ,C#接口中测成员默认的是public 
//接口成员 不能有 new static，abstr，override，virtual，等修饰符，
//如果一个借口继承其它接口，那么实现类或结构就需要实现所有接口的成员。
//接口用于规范，抽象类用于共性，抽象类是类，所以只能被单继承，而接口就是用来弥补类只能被单继承的这个问题的。
//接口中只能声明方法，属性，事件，索引器，而且接口中的方法不能有任何实现，只能声明
//抽象类 可以有方法，但不能实例化，应为抽象类是空的，里面只有描写的方法（或者说方法还没被实现），并没有实体，所以说他不能被实例化，和接口一样,可以定义非静态的类变量，

//接口可以被多重实现（implements）,抽象类只能被单一继承（extends）
//implements 的意思更接近“实现”，比如实现一个接口的方法。
//extends extends，表示对父类的继承，可以实现父类，也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。
//interface IParentInterface
//{
//    void ParentInterfaceMethod();
//}
//interface IMyInterface: IParentInterface //声明一个接口，然后继承另一个接口
//{
//    void MethodToImplement();
//}
/*
     抽象与于接口测比较
    同：
    都不能实例化
    包含未实现的方法的声明
    派生类必须实现未实现的方法，抽象类是抽象方法
    （面向对象编程语言中抽象方法指一些只有方法声明，而没有具体方法体的方法。抽象方法一般存在于抽象类或接口中。），
    接口则是所有成员
    （所有方法都是抽象方法，应为在 interface 所有的方法都是 public abstract6 的，即使你没有声明 所有的数据成员都是public static final 的，即使你没有声明）
     抽象方法：  
     
*/

//abstract class ananan
//{
//    public void EatFood() { }
//}
//class InterfaceImplementer : ananan, IMyInterface
//{
//    static void Main()
//    {
//        InterfaceImplementer iImp = new InterfaceImplementer();
//        iImp.MethodToImplement();
//        iImp.ParentInterfaceMethod();
//        iImp.EatFood();
//    }
//    public void MethodToImplement()
//    {
//        Console.WriteLine("引用接口");
//    }
//    public void ParentInterfaceMethod()
//    {
//        Console.WriteLine("引用接口");
//    }
//    public  void EatFood()
//    {
//        Console.WriteLine("引用接口");
//    }
//}

/*
 一个类他可以实现多个接口（多继承），而父类只有一个,单继承模式
    当多接口隐式实现是，如果接口内有重名的方法，编辑器就会无法识别，就会被混淆
    举个接口的隐式实现的栗子
     */
//    public interface IL
//{
//    object ll();
//}
//public class lll : IL
//{
//    public object ll()
//    {
//        Console.WriteLine("举杯邀明月，对影成三人");
//        return 0;
//    }
//    public static void Main()
//    {
//        IL l = new lll();//实现该接口，然后调用接口方法  / 1  为什么能用接口呢？因为 lll 继承了 IL 接口，
//        l.ll();
//        Console.WriteLine("分割线---------------------");
//        lll s = new lll();// 2  为什么能用类名呢？因为 lll 继承了 IL 接口， 导致这个类里面也具备了 IL 接口的属性
//        s.ll();
//        /*
//         这里有两种调用接口的方法，建议用第一种，应为使用接口实现，因为这种方法更具弹性，他除了可以储存本实例的数据，还可以储存利用这个接口来实现的其他类的实例
//         */
//    }
//}
 

    /* 
     隐式方法和显示方法实现的区别
   1  隐式方式的成员，实现有而且必须有自己的访问修饰符，显示实现方式 的成员不能有任何修饰符
   2 显示实现方式使用接口名称和一个句点命名该类成员来实现 列如  接口名.抽象方法（）
     */
、  
    /*
     举一个接口的显示实现的栗子
     显示实现相对于隐式实现来说更加直接一点，直接冲上去 接口.方法（） 就完事了
     */
    interface IL
{
    object ll();

}
interface Ill
{
    object ll();
}
class Lll : IL
{

    object IL.ll()
    {
        Console.WriteLine("还在");
        return 0;
    }

    public static void Main()
    {
        IL l = new Lll();
        l.ll();
        //  Lll s = new Lll();
        //   s.ll();
        Console.WriteLine("在");
    }
}