[Java]例解Interface

因为经常需要接触Java代码，加上该篇文章对Interface讲述思路清晰、例子简洁（简洁是智慧的灵魂——by莎翁）、内容全面。原文等可以FQ了在贴。

之前我们叙说过抽象类（abstract类），用来实现软件中的抽象机制（即，隐藏那些对用户不相干的细节的一种机制）。但是抽象类实现的是不完全的（partial abstraction）抽象机制，接下来要讨论的interface则实现了完整的抽象机制。涉及：

1、interface是什么

2、interface的重要性

3、怎么用interface？使用中的细节？

一、interface是什么

interface代码段长得像类，但本质上它并不是。interface和类一样拥有自己的方法（methods）和变量（variables），但声明在interface中方法默认是抽象的，只有方法签名，没有实现该方法。至于声明的变量，默认属性是public，static，final，接下来的部分会详细讨论这些方面。

二、interface用来做什么

上面文章曾总结性的说过：interface用来实现抽象机制。鉴于interface中方法都没有实现其具有的功能，所以使用前必须先实现这些个方法，而且implement这个interface的类必须实现这个interface中的所有方法。我们知道，Java不支持多重继承（multiple inheritance），使用interface则可以实现多重继承——一个类可以implement多个interface。

三、怎么用interface

1、interface的声明

Java使用“interface”关键字声明一个interface，例如：

interface MyInterface
{
   /* All the methods are public abstract by default
    * Note down that these methods are not having body
    */
   public void method1();
   public void method2();
}

2、interface的实现

以下例子展示了一个类如何实现一个interface，该类必须提供interface中声明的所有方法的具体实现：

interface MyInterface
{
   public void method1();
   public void method2();
}

class XYZ implements MyInterface
{
  public void method1()
  {
      System.out.println("implementation of method1");
  }
  public void method2()
  {
      System.out.println("implementation of method2");
  }
  public static void main(String arg[])
  {
      MyInterface obj = new XYZ();
      obj. method1();
  }
}

运行输出如下：

implementation of method1

3、interface和继承的关系

interface可以继承（extends）另一个interface，但不能实现（implement）另一个interface。需要的话，只能extends其他interface。下面的例子有两个interface，Inf1、Inf2，Inf2通过继承的方式extendsInf1，如果有类implement Inf2，它必须实现Inf1和Inf2所有方法。

public interface Inf1{
   public void method1();
}

public interface Inf2 extends Inf1 {
   public void method2();
}

public class Demo implements Inf2{
  public void method1(){
    //Implementation of method1
  }
  public void method2(){
    //Implementation of method2
  }
}

以上代码，因为“Demo”类implements了Inf2，所以它也必须实现Inf1中的方法，因为Inf2 extends Inf1。

四、interface使用中的关键点

（1）在Java中，不能实例化（instantiate）一个interface。

（2）interface提供了真正意义上的完全的抽象机制实现途径，因为它的所有方法都没有提供具体实现。另外，我们说抽象类提供了抽象机制的不完全实现是因为在类中，抽象方法和具体方法（concrete methods，methods with body）可以共存。

（3）implements关键字用来让类实现某个interface。

（4）类提供了interface中方法的具体实现，这些方法需要用public修饰。

（5）类必须实现interface中的所有方法，否则该类应该声明为抽象类“abstract”。

（6）interface不能被如下关键字修饰：private、protected、transient。

（7）interface中所有方法默认属性：abstract、public。

（8）interface中所有变量默认属性：public、static and final。

interface Try
{
   int a=10;
   public int a=10;
   public static final int a=10;
   final int a=10;
   static int a=0;
}

以上代码中所有变量都是同样性质。

（9）interface中的所有变量都必须在声明时初始化（initialized），否则编译器会抛出错误。

interface Try
{
      int x;//Compile-time error
}

（10）在实现interface的类中，不能更改interface中声明的变量的值，原因见（8）。一旦试着更改之，编译器抛出错误。

Class Sample implements Try
{
  public static void main(String arg[])
  {
     x=20; //compile time error
  }
<span style="font-family:Comic Sans MS;">｝</span> 

（11）任何interface都可以extends其他任何interface，但不能implements。

（12）一个类可以implements无数个interface。

（13）如果几个interface中包含完全相同的方法，在类中只需要实现一次该方法。

interface A
{
   public void aaa();
}

interface B
{
   public void aaa();
}

class Central implements A,B
{
   public void aaa()
   {
        //Any Code here
   }
   public static void main(String arg[])
   {
        //Statements
    }
}

（14）如果几个interface中包含同名方法，但是返回值不一样，类对此无能为力。

interface A
{
   public void aaa();
}

interface B
{
   public int aaa();
}

class Central implements A,B
{

   public void aaa() // error
   {
   }
   public int aaa() // error
   {
   }
   public static void main(String arg[])
   {

   }
}

（15）如果几个interface中包含重名的变量，可以通过前置interface名称解决这个冲突。

interface A
{
    int x=10;
}

interface B
{
    int x=100;
}

class Hello implement A,B
{
    public static void Main(String arg[])
    {

       System.out.println(x); // reference to x is ambiguous both variables are x
       System.out.println(A.x);
       System.out.println(B.x);
    }
}

五、interface的好处

以下就是interface的优势：

无需为interface中方法的具体实现操心；

Java中不允许多重继承，通过interface就可以实现同样的目的；

一个类只能继承一个类但可以implements无数个interface；

最后：

It saves you from Deadly Diamond of Death(DDD) problem.