接口与多重继承

在很多时候，常会听别人说，接口（interface）可以达到多重继承的效果，这是怎么回事？

其实要讨论这个问题，首先您对于C++中多重继承要先有认识，新手看了书说接口可以达到多重继承，切莫人云亦云，尤其是没有学过C++的新手们，如果您对于C++多重继承想要有所认识，请先看看 多重继承（一）与 多重继承（二）。

 
Java不能多重继承，但为何说Java中可以使用接口（interface）来达到多重继承的效果，首先效果之一，就如 多重继承（二） 中描述的「多重继承时通常其中一个基底类别作为private实作体，而其它的用以表现完全的抽象接口。」，在Java中这个效果可以使用接口来达到，接口此时所扮演的即 多重继承（二）中的抽象类别，一个完全的抽象接口，这个效果的达成方式，如 接口（interface）型态 中所介绍的，您可以直接对应这两个主题中的程序实作来了解，了解Java中如何使用接口（interface）型态来达到C++中所谓多重继承的「一种」效果。

 

来看看另一个情况。

 

如果有SomeClass类别与OtherClass类别，您想要SomeAndOther类别可以同时拥有SomeClass类别与 OtherClass类别中已定义好的操作，并可以进行多型操作，在C++中可以用多重继承来达到，但在Java中显然的无法使用多重继承，怎么办？您可以在设计上先绕个弯，先使用两个接口分别定义好SomeClass与OtherClass两个类别的公开方法，例如：

• ISome.java

public interface ISome {
    public void doSome();
}

• IOther.java

public interface IOther {
    public void doOther();
}

接着让Some与Other类别分别实作两个接口：

• Some.java

public class Some implements ISome {
    public void doSome() {
        ....
    }
}

• Other.java

public class Other implements IOther {
    public void doOther() {
        ....
    }
}

SomeAndOther如何同时拥有两个Some与Other类别已定义好的操作？并可以多型操作？SomeAndOther可以 继承其中之一，并拥有其中之一，例如：

• SomeAndOther.java

public class SomeAndOther extends Some implements IOther {
    private IOther other = new Other();

    public void doOther() {
        other.doOther();
    }
}

虽不满意，但至少解决了目前的问题，当然这边只是其中一例，毕竟C++是C++，Java是Java，两者语法并不是一对一的关系，视实际需求还可以变化 一下。 

Java也提供继承机制﹐但还另外提供一个叫interface的概念。由于Java的继承机制只能提供单一继承（就是只能继承一种父类别）﹐所以就以Java的interface来代替C++的多重继承。interface就是一种介面﹐规定欲沟通的两物件﹐其通讯该有的规范有哪些。如以Java程式语言的角度来看﹐Java的interface则表示：一些函数或资料成员﹐为另一些属于不同类别的物件所需共同拥有﹐则将这些函数与资料成员﹐定义在一个interface中﹐然后让所有不同类别的Java物件可以共同操作使用之。

  所以﹐对于Java的继承与interface﹐我们总结如下：

1.Java的class只能继承一个父类别（用extends关键字）﹐但可以拥有（或称实作）许多interface（用implements关键字）。

2.Java的interface可以继承许多别的interface（也是用extends关键字）﹐但不可以实作任何interface。



因此﹐我们可以利用Java的interface来模拟C++的多重继承。如上面的例子可以转化如下：

interface Test1 {

    public void f1();

    public void g1();

}

interface Test2 {

    public void f2();

    public void g2();

}

interface Test3 extends Test1, Test2 {

    public void gg();

}

class CTest implements Test3 {

    public void f1() { System.out.println("Test1::f1()"); }

    public void g1() { System.out.println("Test1::g1()"); }

    public void f2() { System.out.println("Test2::f2()"); }

    public void g2() { System.out.println("Test2::g2()"); }

    public void gg() { System.out.println("Test3::gg()"); }

}

class Run {

public void run() {

  CTest ct=new CTest(); ct.f1();ct.f2();

  ct.g1();ct.g2();     ct.gg();

}}

class Main {

public static void main (String args[]) {

    Run rr=new Run();    

    rr.run();

    }}

// 程式输出：

Test1::f1()   Test2::f2()   Test1::g1()

Test2::g2()   Test3::gg()

=============================================================================

interface（接口）的运用机制

interface USB
{
   Static final String USBString = “USB1.1对低速……“;
   public void showUSB();
}

interface IEE
{
  Static final String USBString = “IEE充许最高到……“;
  public void showIEE();
}

第一种方式：
class ExterTest implements USB,IEE
{
   public void showUSB()
   {
      System.out.prinltn(USB.USBString);
   }
   public void showIEE()
   {
      System.out.prinltn(IEE.USBString);
   }
}
测试类：
 public class Test
{
   public static void main(String[] args)
   {
      ExterTest usbcase = new ExterTest();
      USB usb = usbcase;
      usb.showUSB();
      //usb.showIEE();//此处不能调用。
      IEE ieeusb = usbcase;
      ieeusb.showIEE();
     //ieeusb.shwoUSB();//此处不能调用。
   }
}


第二种方式：（采用标志与延伸制）
interface Multiple extends USB,IEE
{}

class ExterTest implements Multiple
{
  public void showUSB()
  {
   System.out.println(USB.USBString);
  }
  public void showIEE()
  {
   System.out.println(IEE.USBString);
  }
}
测试类：
public class Test
{
   public static void main(String[] args)
   {
      ExterTest usbcase = new ExterTest();
      USB usb = usbcase;
      usb.showUSB();
      usb.showIEE();
   }
}