## [接口嵌套](https://lingcoder.gitee.io/onjava8/#/book/10-Interfaces?id=%e6%8e%a5%e5%8f%a3%e5%b5%8c%e5%a5%97) 接口可以嵌套在类或其他接口中。下面揭示一些有趣的特性： ~~~ // interfaces/nesting/NestingInterfaces.java // {java interfaces.nesting.NestingInterfaces} package interfaces.nesting; class A { interface B { void f(); } public class BImp implements B { @Override public void f() {} } public class BImp2 implements B { @Override public void f() {} } public interface C { void f(); } class CImp implements C { @Override public void f() {} } private class CImp2 implements C { @Override public void f() {} } private interface D { void f(); } private class DImp implements D { @Override public void f() {} } public class DImp2 implements D { @Override 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 { @Override public void f() {} } class CImp implements A.C { @Override public void f() {} } // Cannot implements a private interface except // within that interface's defining class: //- class DImp implements A.D { //- public void f() {} //- } class EImp implements E { @Override public void g() {} } class EGImp implements E.G { @Override public void f() {} } class EImp2 implements E { @Override public void g() {} class EG implements E.G { @Override public void f() {} } } public static void main(String[] args) { A a = new A(); // Can't access to 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()); } } ~~~ 在类中嵌套接口的语法是相当显而易见的。就像非嵌套接口一样，它们具有**public**或包访问权限的可见性。 作为一种新添加的方式，接口也可以是**private**的，例如**A.D**（同样的语法同时适用于嵌套接口和嵌套类）。那么**private**嵌套接口有什么好处呢？你可能猜测它只是被用来实现一个**private**内部类，就像**DImp**。然而**A.DImp2**展示了它可以被实现为**public**类，但是**A.DImp2**只能被自己使用，你无法说它实现了**private**接口**D**，所以实现**private**接口是一种可以强制该接口中的方法定义不会添加任何类型信息（即不可以向上转型）的方式。 `getD()`方法产生了一个与**private**接口有关的窘境。它是一个**public**方法却返回了对**private**接口的引用。能对这个返回值做些什么呢？`main()`方法里进行了一些使用返回值的尝试但都失败了。返回值必须交给有权使用它的对象，本例中另一个**A**通过`receiveD()`方法接受了它。 接口**E**说明了接口之间也能嵌套。然而，作用于接口的规则——尤其是，接口中的元素必须是**public**的——在此都会被严格执行，所以嵌套在另一个接口中的接口自动就是**public**的，不能指明为**private**。 类**NestingInterfaces**展示了嵌套接口的不同实现方式。尤其是当实现某个接口时，并不需要实现嵌套在其内部的接口。同时，**private**接口不能在定义它的类之外被实现。 添加这些特性的最初原因看起来像是出于对严格的语法一致性的考虑，但是我通常认为，一旦你了解了某种特性，就总能找到其用武之地。