显式实现接口，通过接口变量调用，隐式实现接口，通过对象变量调用

1. interface IFlyable
   
2.     {
   
3.         void Fly();
   
4.     }
   
5.     class FeiQin : IFlyable
   
6.     {
   
7.         public void Fly()
   
8.         {
   
9.             Console.WriteLine("飞禽都会飞！");
   
10.         }
    
11. 
    
12.         void IFlyable.Fly()
    
13.         {
    
14.             Console.WriteLine("。。。。会飞！");
    
15.         }
    
16.     }
    
17.     class Program
    
18.     {
    
19.         static void Main(string[] args)
    
20.         {
    
21.             FeiQin feiQin = new FeiQin();
    
22.             feiQin.Fly(); //显示"飞禽都会飞！"，调用隐式实现接口
    
23.             IFlyable fly = feiQin;
    
24.             fly.Fly();//显示"。。。。会飞！"，调用显式实现接口，只能通过接口变量调用
    
25.             Console.ReadKey();
    
26.         }
    
27.     }

复制代码

看到这里，写了以上代码区别了一下，可是为什么要在一个类里面实现两个同名的方法，这样做有什么实用的意义吗？请大家不吝赐教！

c19t043 发表于 2014-7-15 22:42

interface IFlyable

    {

        void Fly();

学习了~

• interface IFlyable
•     {
•         void Fly();
•     }
•     class FeiQin : IFlyable
•     {
•         public void Fly()
•         {
•             Console.WriteLine("飞禽都会飞！");
•         }
•         void IFlyable.Fly()
•         {
•             Console.WriteLine("。。。。会飞！");
•         }
•     }
• -------------------→FeiQin类继承了2个接口，IFlyable1,IFlyable2,
• interface IFlyable1
•     {
•         void Fly();
•     }
• interface IFlyable2
•     {
•         void Fly();
•     }
• class FeiQin:IFlyable1,IFlyable2
• {
•      public void Fly()
•      {
•             Console.WriteLine("飞禽都会飞！");
•      }
• }
•     class Program
•     {
•         static void Main(string[] args)
•         {
•             FeiQin feiQin = new FeiQin();
•             feiQin.Fly();
•             Console.ReadKey();
•         }
•     }
• 你认为FeiQin类中调用的那个接口的Fly()?
• 继承接口，编译器，只认FeiQin类中是否实现了接口中的Fly();
• 不管子类中有几个Fly()方法
• --------------------------------------------→↓
• 首先，我们定义接口的时候，不会有2个相同意义的接口
• → →  →→鸟类都有翅膀，并不代表有翅膀就能长时间飞行，
• 我们将IFlyable1接口中的Fly()，是长时间的飞行
• IFlyable2接口中的Fly(),是短时间的飞行
• 所以，Fly()有了2个分支
• class Bird:IFlyable1,IFlyable2
• {
•      public void Fly() //默认的继承自IFlyable1,,,,,,,,,
•      {
•             Console.WriteLine("燕子能长时间飞行！");
•      }
•      
•      public void IFlyable2.Fly() //显示实现IFlyable2的Fly();
•      {
•             Console.WriteLine("鸭子能短时间飞行！");
•      }
• }
•     class Program
•     {
•         static void Main(string[] args)
•         {
•             Bird b = new Bird();
•             b.Fly(); //长时间飞行
•             b.IFlyable.Fly();//短时间飞行
•             Console.ReadKey();
•         }
•     }
  

weiwei10153 发表于 2014-7-8 09:23
显示实现接口,可以解决方法重名的问题,FeiQin 类实现了IFlyable接口,那么就必须重写IFlyable接口中的Fly方 ...

谢谢你的耐心回答

向晓伟 发表于 2014-7-8 09:25
隐式实现可以通过接口和类调用
显示实现只能通过接口来调用
显示实现可以隐藏实现代码，而且在一些使用接口 ...

谢谢你的回答，你的回答解决了我的疑问

也一直不明白。。学习了   

2楼说的太对了。。

隐式实现可以通过接口和类调用
显示实现只能通过接口来调用
显示实现可以隐藏实现代码，而且在一些使用接口的系统中，调用者只能通过接口调用而不是底层的类来访问。

显示实现接口,可以解决方法重名的问题,FeiQin 类实现了IFlyable接口,那么就必须重写IFlyable接口中的Fly方法,但是FeiQin 类本身有一个Fly方法,而实现接口的类必须重写接口中所有的方法,为了区分这两个方法,通过显示实现接口的方式,把实现IFlyable接口的方法设置为私有方法.在外部调用方法的时候,普通类只能调用到FeiQin 类的public void Fly()方法,而通过接口调用,就可以调用到private void IFlyable.Fly()的方法

这个问题我也不懂，抢个座，坐等大牛解答……