接口的显示与隐式调用

接口的实现实际上和类之间的继承是一样的，也是重写了接口中的方法，让其有了具体的实现内容。

但需要注意的是，在类中实现一个接口时必须将接口中的所有成员都实现，否则该类必须声明为抽象类，并将接口中未实现的成员以抽象方式实现。

从上面的代码可以看出，在实现类 Test 中将未实现的属性和方法分别定义为抽象属性和抽象方法，并将实现类定义为抽象类。

这是一种特殊的实现方式，在实际应用中通常是将接口中的所有成员全部实现。

在实现接口的成员时有两种方式，一种是隐式实现接口成员，一种是显式实现接口成员。

在实际应用中隐式实现接口的方式比较常用，由于在接口中定义的成员默认是 public 类型的，隐式实现接口成员是将接口的所有成员以 public 访问修饰符修饰。

显式实现接口是指在实现接口时所实现的成员名称前含有接口名称作为前缀。

需要注意的是使用显式实现接口的成员不能再使用修饰符修饰，即 public、abstract、virtual、 override 等。

接下来将通过实例来演示在编程中隐式实现接口与显式实现接口有什么区别。

1. interface ICompute
       {
           int A { get; set; }
           string B { get; set; }
           void point1();
           void point2();
       }
       class ComputerMajor : ICompute
       {
           public int A{ get; set; } //隐式的实现接口中的属性
           public string B{ get; set; } //隐式实现接口中的属性
           public double E { get; set; }
           public double P { get; set; }
           public double D { get; set; }
           public void point1() //隐式实现接口中的方法
           {
               double avg = (E + P + D) / 3;
               Console.WriteLine("平均分：" +avg);
           }
           public void point2()
           {
               double sum = E + P + D;
               Console.WriteLine("总分为：" + sum);
           }
       }

从上面的代码可以看出，所有接口中的成员在实现类 ComputerMajor 中都被 public 修饰符修饰。

在 Main 方法中调用该实现类的成员，代码如下。

1. class Program
2. {
3. static void Main(string[] args)
4. {
5. static void Main(string[] args)
           {
               ComputerMajor computerMajor = new ComputerMajor();
               computerMajor.A = 1;
               computerMajor.B = "李明";
               computerMajor.E = 80;
               computerMajor.P = 90;
               computerMajor.D = 85;
               Console.WriteLine("学号：" + computerMajor.A);
               Console.WriteLine("姓名：" + computerMajor.B);
               Console.WriteLine("成绩信息如下：");
               computerMajor.point1();
               computerMajor.point2();
           }
6. }
7. }

使用显式方式来实现接口成员的代码如下。

1. class ComputerMajor : ICompute
2. {
3. public double E { get; set; }
4. public double P { get; set; }
5. public double D { get; set; }
6. int ICompute.A { get; set; } //显示实现接口中的属性
7. string ICompute.B{ get; set; } //显示实现接口中的属性
8. void ICompute.point1() //显示实现接口中的方法
9. {
10. double sum = E + P + D;
11. Console.WriteLine("总分数：" + sum);
12. }
13. void ICompute.point2()
14. {
15. double avg = (E + P + D) / 3;
16. Console.WriteLine("平均分为：" + avg);
17. }
18. }

从上面的代码可以看出，在使用显式方式实现接口中的成员时，所有成员都会加上接口名称 ICompute 作为前缀，并且不加任何修饰符。

在Main方法中调用实现类中的成员,代码如下

1. class Program
2. {
3. static void Main(string[] args)
4. {
5. ComputerMajor computerMajor = new ComputerMajor();
6. ICompute compute = computerMajor; //创建接口的实例
7. compute.A= 1;
8. compute.B = "李明";
9. computerMajor.E = 80;
10. computerMajor.P = 90;
11. computerMajor.D = 85;
12. Console.WriteLine("学号：" + compute.A);
13. Console.WriteLine("姓名：" + compute.B);
14. Console.WriteLine("成绩信息如下：");
15. compute.point1l();
16. compute.point2();
17. }
18. }

执行上面的代码，效果与上图一致。从调用的代码可以看出，在调用显式方式实现接口的成员时，必须使用接口的实例来调用，而不能使用实现类的实例来调用。

与类之间的继承类似，实现类的实例也可以隐式转换为其所实现接口的接口类型。