接口总结

为什么要使用接口呢？其实大部分时候我们能不用接口尽量不用，因为比起抽象类来，它的运行速度是慢的。但正如书中所言，接口最吸引人的原因之一就是允许同一个接口具有不同的具体实现。其次，它向上转型也可以实现多个基类，防止客户端程序员创建该类的对象等等。接口可以实现多继承，而抽象类不可以。抽象类可以有一些默认的方法实现，接口没有。接口的访问修饰符默认是public的，不允许修改。接口没有构造器，接口不能实现main方法。

适配问题

在适配接口中，我们能学到， 可以依据不同接口，来给一个类实现不同的适配功能。这里也提到了Scanner类和Readable接口之间的适配问题。

同时将查阅过的文档和Readable接口的说明附上：

http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

请看代码如下：

// Implementing an interface to conform to a method.
import java.nio.*;
import java.util.*;
 
public class RandomWords implements Readable {
  private static Random rand = new Random(47);
  private static final char[] capitals =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
  private static final char[] lowers =
    "abcdefghijklmnopqrstuvwxyz".toCharArray();
  private static final char[] vowels =
    "aeiou".toCharArray();
  private int count;
  public RandomWords(int count) { this.count = count; }    
  public int read(CharBuffer cb) {
    if(count-- == 0)
      return -1; // Indicates end of input
    cb.append(capitals[rand.nextInt(capitals.length)]);
    for(int i = 0; i < 4; i++) {
      cb.append(vowels[rand.nextInt(vowels.length)]);
      cb.append(lowers[rand.nextInt(lowers.length)]);
    }
    cb.append(" ");
    return 10; // Number of characters appended
  }
  public static void main(String[] args) {
    Scanner s = new Scanner(new RandomWords(10));
    while(s.hasNext())
      System.out.println(s.next());
  }
}

 

这里实现了接口Readable中的read（）方法。而它只是单独为Scanner创建的，让Scanner成为不会被限制的某个特定类。这样就解放了Scanner，它可以作用于更多的类型了。所以说，在现有类上增加新的接口，可以让方法接受接口类型，是一种让任何类都可以对该方法进行适配的方式。

接口的域

接口的任何域自动都是static和final的。在接口的常量初始化的时候必须给其初值。定义的常量中不允许有空final。

嵌套接口

在类中可以增加内部接口，内部接口可以被置为private，但是它的调用必须是用类中的某个private方法调用的。在接口中也可以镶嵌内部接口，但是所有的接口都是public。

参考以下代码：

//: interfaces/nesting/NestingInterfaces.java
package interfaces.nesting;
 
class A {
  interface B {
    void f();
  }
  public class BImp implements B {
    public void f() {}
  }
  private class BImp2 implements B {
    public void f() {}
  }
  public interface C {
    void f();
  }
  class CImp implements C {
    public void f() {}
  }    
  private class CImp2 implements C {
    public void f() {}
  }
  private interface D {
    void f();
  }
  private class DImp implements D {
    public void f() {}
  }
  public class DImp2 implements D {
    public void f() {}
  }
  public D getD() { return new DImp2(); }
  private D dRef;
  public void receiveD(D d) {
    dRef = d;
    dRef.f();
  }
}    
 
interface E {
  interface G {
    void f();
  }
  // Redundant "public":
  public interface H {
    void f();
  }
  void g();
  // Cannot be private within an interface:
  //! private interface I {}
}    
 
public class NestingInterfaces {
  public class BImp implements A.B {
    public void f() {}
  }
  class CImp implements A.C {
    public void f() {}
  }
  // Cannot implement a private interface except
  // within that interface's defining class:
  //! class DImp implements A.D {
  //!  public void f() {}
  //! }
  class EImp implements E {
    public void g() {}
  }
  class EGImp implements E.G {
    public void f() {}
  }
  class EImp2 implements E {
    public void g() {}
    class EG implements E.G {
      public void f() {}
    }
  }    
  public static void main(String[] args) {
    A a = new A();
    // Can't access A.D:
    //! A.D ad = a.getD();
    // Doesn't return anything but A.D:
    //! A.DImp2 di2 = a.getD();
    // Cannot access a member of the interface:
    //! a.getD().f();
    // Only another A can do anything with getD():
    A a2 = new A();
    a2.receiveD(a.getD());
  }
} ///:~

 

仔细看一看，这段代码极为有趣。