大家都知道，Java中的类只能继承一个父类，但是可以实现多个接口。之所以这样，据说是因为多重继承的概念比较混乱。但是，多接口实现会出现更加混乱的问题。

 1. 如果一个类实现了两个接口，但是两个接口中有签名一致的函数，怎么办？

实际上，在同一个函数中，只能有一个签名一致的函数。如下：

interface ClickListener { 
   void fire(); 
} 
 
interface TouchListener { 
    void fire(); 
} 
 
class Button implements ClickListener, TouchListener { 
    @Override 
    public void fire() { 
        // ... 
    } 
}

两个Listener的对fire的调用，都会指向同一个函数。

 2. 在1的基础上，如果Button的父类已经有一个签名一致的函数。如下： 

interface ClickListener {  
   void fire();  
}  
  
interface TouchListener {  
    void fire();  
}  
 
class ButtonBase { 
    public void fire() { 
        // ... 
    } 
} 
 
class Button extends ButtonBase implements ClickListener, TouchListener {  
}

那么此时Button中可以不存在任何函数。两个Listener的对fire的调用，都会指向ButtonBase中的函数。奇怪么？

 这种奇怪的做法和C++中的“复杂”多重继承相比，在被调用函数中完全不知道调用来自哪个Listener触发，无法根据不同的来源做不同的处理。更加变态的是，如果两个Listener中的函数只有返回值不一样的时候——对不起，悲剧了——你不能同时实现这两个接口——因为编译器不支持。

 但是，这种奇怪的做法也有其实际的用途，请看下例：

/* public interface */ 
public interface Animal { 
    void run(); 
} 
 
/* internal class */ 
private class Dog { 
    @Override 
    void run() { 
        // ... 
    } 
} 
 
/* public interface */ 
public FlyAnimal extends Animal { 
    void fly(); 
} 
 
/* internal class */ 
private class FlyDog extends Dog implements FlyAnimal { 
    @Override 
    void fly() { 
        // ... 
    } 
}

我只能说，Java太凶残了。