C#-接口

 

接口就是指定一组函数成员，而不实现他们的引用类型。

如何定义一个接口

一般来说接口名称首字母都是大写I

interface ICatchMice
        {
            void CatchMice();//默认public，但不能添加任何访问修饰符
        }

接口只能用来被实现

就像抽象类只能被继承

语法很像继承

Cat:IcatchMice
{
public void CatchMice(){....};//必须有实现
}

这是基本的一整段

 interface ICatchMice
    {
        void CatchMice();//默认public，但不能添加任何访问修饰符
    }
    interface IClimbTree
    {
        void ClimbTree();
    }
      class Pet
    {

    }
    class Cat :Pet,ICatchMice,IClimbTree
    {
        public Cat(string v)
        {
            V = v; 
        }

        public string V { get; }

        public void CatchMice()
        {
            Console.WriteLine("Catch mice");
        }
        public void ClimbTree()
        {
            Console.WriteLine("Climb tree");
        }
    } 
    class Program
    {
        static void Main()
        {
            Cat c = new Cat("Tom");
            IClimbTree Climb = c;
            c.CatchMice();
            Climb.ClimbTree();
            ICatchMice CatchM = c;
            CatchM.CatchMice();
        }
    }

这里要注意，一个类如果继承于父类而且引用多接口的话，父类要在第一位，接口要在后面

class Cat :Pet,ICatchMice,IClimbTree

虽然说 C#里一个类只能派生一个类，但是可以引用多接口

IClimbTree Climb = c;//有时候要是转换不成功的话就进行强制转换
//IClimbTree Climb = (IClimbTree)c;
            c.CatchMice();
            Climb.ClimbTree();
            ICatchMice CatchM = c;
            CatchM.CatchMice();

这种情况下，既可以通过接口的引用类型来访问

也可以通过对象来调用 

 接口可以继承其他接口

 public interface ICatchMice
        {
            void CatchMice();
        }
        public interface IClimbTree:ICatchMice
        {
            void ClimbTree();
           
        }

这样就相当于一个接口拥有了两个接口的方法

比如说下面有两个不同返回类型的方法Foo

如果不进行显式实现，则会报错

 如果方法签名和返回类型全部一样

那在类里面实现一次就可以了

不一样的话就像上面重新实现 返回类型+接口+方法 就可以了

public void CatchMice()
        {
            Console.WriteLine("Climb tree");
        }
        int ICatchMice.CatchMice()
        {
            Console.WriteLine("I got it");
            return 0;
        }

然后最后的类里实现的时候

static void Main()
        {
            Cat c = new Cat("Tom");
            c.CatchMice();
            ((ICatchMice)c).CatchMice();
            ((IClimbTree)c).CatchMice();
        }

由于int类型的CatchMice没有public

所以需要用（（））.xxx这种方法去调用

 

隐式实现的接口成员默认是sealed的        

如果想要进行重写的话必须父类中把成员标记成virtual或者abstract

public interface ICatchMice
        {
            int CatchMice();
        }
        public class IClimbTree:ICatchMice
        {
        public void CatchMice() => Console.WriteLine("First thing");
        }
    public interface TakeFood:IClimbTree
    {
        public  void CatchMice() => Console.WriteLine("Two thing ");
    }

当我们去调用方法的时候

比如((ICatchMice)c).CatchMice 结果就会是First thing

然后((ICimbTree).c).CatchMice 结果就是 First thing

c.CatchMice结果就是 Two thing

public interface ICatchMice
        {
            int CatchMice();
        }
        public class IClimbTree:ICatchMice
        {
        public virtual void CatchMice() => Console.WriteLine("First thing");
        }
    public interface TakeFood:IClimbTree
    {
        public override void CatchMice() => Console.WriteLine("Two thing ");
    }

如这样重载之后，所有的结果都是Two thing 因为重写了就相当于是覆盖了前面的结果

显示接口不能被进行重写，但是可以重新实现接口

public interface ICatchMice
        {
            int CatchMice();
        }
        public class IClimbTree:ICatchMice
        {
        void ICatchMice.CatchMice() => Console.WriteLine("First thing");
        }
    public class TakeFood:IClimbTree,ICatchMice
    {
        public  void CatchMice() => Console.WriteLine("Two thing ");
    }

比如说这样，就不能重写

但是可以在需要用到接口的类重新声明

public class TakeFood:IClimbTree,ICatchMice