您的位置:时时app平台注册网站 > 编程知识 > .net接口学习笔记

.net接口学习笔记

2019-10-30 04:20

2. 接口声明饱含如下几连串型:属性、方法、事件和目录;这几个函数阐明不能够包罗其余实现代码,而在每一个成员的基点后必得使用分号

Interface/接口,interface接口

  1. 类和结构可以贯彻接口

2. 接口表明富含如下各个等级次序:属性、方法、事件和目录;那些函数注明不能够包蕴别的实今世码,而在每二个分子的宗旨后必得利用分号

  1. 接轨接口的类或结构必需落实接口中的全部成员

  2. 展示接口的贯彻注意上边的代码

    class Program

     {
         static void Main(string[] args)
         {
             SampleClass_1 sc = new SampleClass_1();
             IControl ctr1 = (IControl)sc;
             ISurface srfc = (ISurface)sc;
             // 调用一样的方法,继承
             sc.Paint();
             ctr1.Paint();
             srfc.Paint();
             Console.WriteLine();
    
             //显式接口实现
             SampleClass_2 obj = new SampleClass_2();
             IControl c = (IControl)obj;
             ISurface s = (ISurface)obj;
             obj.Paint();
             c.Paint();
             s.Paint();
    
             Console.ReadKey();
         }
     }
     public interface IControl // 接口可以有访问修饰符
     {
         void Paint();      //成员不允许有任何访问修饰符,默认public
         int P { get; }
     }
     public interface ISurface
     {
         void Paint();
     }
     class SampleClass_1:IControl,ISurface
     {
         //IControl.Paint和ISurface.Paint都会调用这个方法
         public void Paint()
         {
             Console.WriteLine("Paint method in SampleClass");
         }
         private int _value=10;
         public int P
         {
             get { return _value; }
             set { _value = value; }  //可以添加set访问器
         }
     }
     class SampleClass_2:IControl ,ISurface 
     {
         //显式接口实现
        void IControl.Paint()  //这时候不能加访问修饰符public, 要完全和接口定义一致
         {
             Console.WriteLine("IControl.Paint");
         }
         void ISurface.Paint()
         {
             Console.WriteLine("ISurface.Paint");
         }
         public void Paint()
         {
             Console.WriteLine("SampleClass_2.Paint");
         }
         private int _value=10;
         int IControl.P
         {
             get { return _value; }
             //set { }显式接口必须和接口定义完全一致,不能任意添加set访问器
         }
     }
    

  

1. 类和结构能够落到实处接口 2. 接口注明包括如下几体系型:属性、方法、事件和目录;那一个函数评释无法饱含任何...

1.接口的评释

  接口的宣示不能够包括:数据成员,静态变量;只可以分包如下类型的静态成员函数的申明:方法,属性,事件,索引器。证明中不可能富含其余达成的代码,而在各类成员成名的关键性后,必需利用分号。

  接口注脚能够有此外的修饰符public、protect、internl或private。

  接口的成员是隐式的public,不容许任何访谈修饰符,满含public。

1 Public Interface IMyInterface
2 {
3      //接口成员是隐式的public,并且只有声明
4      int Method1(int nVar1,int nVar2) ;          
5 }

  

5.代码Demo

图片 1图片 2

 1 namespace ConsoleApplication2
 2 {
 3     interface ILoveWorld { void SayHello();}
 4     class Creature{}
 5 
 6     //基类和接口同时实现的时候,基类要放在最前面
 7     class Person : Creature,ILoveWorld
 8     {
 9         //隐式的声明接口,既可以被类的对象访问,又可以转换为接口引用对象访问
10         void SayHello()
11         {
12             Console.WriteLine("Hello World!");
13         }
14         //显式的声明接口成员,只能转换为接口引用对象来访问
15          void ILoveWorld.SayHello()
16         {
17             Console.WriteLine("Hello World!");
18         }
19     }
20     class Cat : Creature, ILoveWorld
21     {
22         //相对于显式的接口实现方式。类级别的接口实现不是必须的。
23         void ILoveWorld.SayHello()
24         {
25             Console.WriteLine("MiaoMiaoMiao");
26         }
27     }
28     class Dog : Creature, ILoveWorld
29     {
30         //在显式调用接口成员的时候不能用public 
31         void ILoveWorld.SayHello()
32         {
33             Console.WriteLine("WangWangWang");
34         }
35     }
36     class Program
37     {
38         static void Main(string[] args)
39         {
40             //声明一个Creature的数组
41             Creature[] pCreatureArray = new Creature[3];
42             //这里用到了上次学的面向对象的IS-A的关系
43             pCreatureArray[0] = new Person();
44             pCreatureArray[1] = new Cat();
45             pCreatureArray[2] = new Dog();
46             foreach (var creature in pCreatureArray)
47             {
48                 //利用as进行转换
49                 ILoveWorld b = creature as ILoveWorld;
50                 b.SayHello();
51             }
52             Console.ReadKey();
53         }
54     }
55 }

接口Demo

运营结果:

图片 3

  

 

3. 三回九转接口的类或结构必得实现接口中的全体成员

4.接口的继续

要内定某些接口传承其余接口,应在接口申明中把接口以逗号分隔的列表情势放在接口名称从今未来。和类的接轨格式雷同。但是又与类分裂,贰个接口能够继续任意多个接口,能够张开多重承继。子接口除了含有自个儿注脚的接口之外还包蕴持有父接口的持有接口成员。

  1. 展示接口的完结注意上面包车型客车代码

    class Program

     {
         static void Main(string[] args)
         {
             SampleClass_1 sc = new SampleClass_1();
             IControl ctr1 = (IControl)sc;
             ISurface srfc = (ISurface)sc;
             // 调用一样的方法,继承
             sc.Paint();
             ctr1.Paint();
             srfc.Paint();
             Console.WriteLine();
    
             //显式接口实现
             SampleClass_2 obj = new SampleClass_2();
             IControl c = (IControl)obj;
             ISurface s = (ISurface)obj;
             obj.Paint();
             c.Paint();
             s.Paint();
    
             Console.ReadKey();
         }
     }
     public interface IControl // 接口可以有访问修饰符
     {
         void Paint();      //成员不允许有任何访问修饰符,默认public
         int P { get; }
     }
     public interface ISurface
     {
         void Paint();
     }
     class SampleClass_1:IControl,ISurface
     {
         //IControl.Paint和ISurface.Paint都会调用这个方法
         public void Paint()
         {
             Console.WriteLine("Paint method in SampleClass");
         }
         private int _value=10;
         public int P
         {
             get { return _value; }
             set { _value = value; }  //可以添加set访问器
         }
     }
     class SampleClass_2:IControl ,ISurface 
     {
         //显式接口实现
        void IControl.Paint()  //这时候不能加访问修饰符public, 要完全和接口定义一致
         {
             Console.WriteLine("IControl.Paint");
         }
         void ISurface.Paint()
         {
             Console.WriteLine("ISurface.Paint");
         }
         public void Paint()
         {
             Console.WriteLine("SampleClass_2.Paint");
         }
         private int _value=10;
         int IControl.P
         {
             get { return _value; }
             //set { }显式接口必须和接口定义完全一致,不能任意添加set访问器
         }
     }
    

2.接口的贯彻

  唯有类和结构体工夫贯彻接口,而且必需在基类列表中归纳接口名称;使用接口的类或社团要求为接口的每八个成员提供落成。

1 Class MyClass:IMyInterface
2 {
3     //在进行隐式的实现接口成员的时候,访问修饰符要设为public   
4      public int Method(int a,int b)
5     {
6         Console.WriteLine("{0}",a b);
7         return a b;
8     }
9 }

  固然二个类即继承了基类,又实现了接口,那么在此个类的基类列表中的基类名称必须放在全数的接口的眼下。並且贰个类只可以有一个基类,列出的任何类型必需都以接口名。

  接口不止是类或结构要兑现的成员列表,它是四个援用类型,大家不能够一向通过类对象的积极分子访谈接口,然则大家得以因此把类对象引用强制调换为接口类型来收获指向接口的引用。那样大家就能够应用点号来调用接口的办法了。这里转变推荐用as进行更改。

 1 Static void Main(string[] args)
 2 {
 3     int a = 5;
 4     int b = 8;
 5     MyClass mc = new MyClass();
 6     //调用类对象的实现方法
 7     mc.Method(a,b);
 8     //将类型转化为接口类型
 9     IMyInterface mif = mc as IMyInterface;
10     mif.Method(a,b);   
11 }

出口结果:13

       13

应用as进行强制调换的收益:假设类达成了接口就能够回去接口的引用(安然依旧)借使类未有达成接口就能够抛出极其,方便及时的开采错误。

1. 类和组织可以贯彻接口

3.兑现四个接口

  类或结构能够完结自由数量的接口。

  全部落成的接口必得列在基类列表中且以逗号分隔。

  假设叁个类完结的两个接口在这之中有双重的成员(具有同样的具名和千篇大器晚成律的回来类型),那么在这里类实现接口成员的时候,达成一遍就能够满意全数富含重复成员的接口。

 1     interface interface1 { void Method(int a ,int b);}
 2     interface interface2 { void Method(int a, int b);}
 3     //实现多个接口用逗号相隔
 4     public class MyClass : interface1, interface2
 5     {
 6         /*
 7          * 如果两个接口成员函数的返回类型和参数一致,
 8          * 那么进行一次实现就可以了
 9          */
10         public void  Method(int a, int b)
11         {
12             Console.WriteLine("{0}", a   b);
13         }
14     }

  借使想特意的分别那七个接口的接口成员,就供给创设显式的接口成员成员得以达成。格式:接口名称 点分隔符 接口的成员函数。注意:在展现的调用接口成员的时候,已经默以为public,不可能再增添访谈修饰符了。

 1     interface interface1 { void Method(int a ,int b);}
 2     interface interface2 { void Method(int a, int b);}
 3     //实现多个接口用逗号相隔
 4     public class MyClass : interface1, interface2
 5     {
 6         //显示的实现interface1的接口成员
 7         //已经默认为public,不能添加访问修饰符了
 8         void interface1.Method(int a, int b)
 9         {
10             Console.WriteLine("{0}", a   b);
11         }
12         void interface2.Method(int a, int b)
13         {
14             Console.WriteLine("{0}", a   b);
15         }
16     }

但是如此就唯有显式接口成员的落到实处,而未有类等第的落到实处,所以在实例化该类的目标后,是心有余而力不足点出该方法的。假若有显式接口成员落实,类级其他兑现是同意的,不过否必得的。並且显式接口成员落到实处智能通过指向接口的援引来访谈,尽管是类在那之中的成员函数来对接口成员开展拜望。

假诺三个类完毕了接口,那么它的子类也会三翻五次其基类达成的接口成员,没有必要重新兑现。

本文由时时app平台注册网站发布于编程知识,转载请注明出处:.net接口学习笔记

关键词: