JavaSE基础知识(十九)--Java接口之接口的嵌套

Java SE 是什么，包括哪些内容(十九)？

本文内容参考自Java8标准
再次感谢Java编程思想对本文的启发！
一个接口可以嵌套在另一个接口中，这揭示了许多非常有趣的特性。
代码示例：

// 接口嵌套
   //包访问权限类A
   class A{
      //嵌套的包访问权限接口B
      interface B{
         //方法f()
         void f();
      }
      //public类BImp实现接口B
      //说明包访问权限接口可以被implements
      public class BImp implements B{
         //实现方法f()
         public void f() {}
      }
      //private类BImp2实现接口B
      private class BImp2 implements B{
         //实现方法f()
         public void f() {}
      }
      //嵌套的public接口C
      public interface C{
         public void f();
      }
      //包访问权限类CImp实现接口C
      class CImp implements C{
         public void f() {}
      }
      //private类CImp2实现接口C
      private class CImp2 implements C{
         //实现方法f()
         public void f() {}
      }
      //private嵌套接口D
      private interface D{
         //方法f()
         void f();
      }
      //private类DImp实现接口D
      //说明private的接口可以被implements
      private class DImp implements D{
         //实现方法f()
         public void f() {}
      }
      //public类DImp2实现接口D
      //说明private的接口可以被implements
      public class DImp2 implements D{
         //实现方法f()
         public void f() {}
      }
      //方法getD(),返回类型为D
      public D getD(){
         //返回一个子类DImp2的对象实例
         return new DImp2();
      }
      //D类型的类变量dRef;
      private D dRef;
      //方法recieveD,带一个D类型的形式参数d
      public void receiveD(D d){
         //将d的值赋值给dRef;
         dRef = d;
         //调用方法f()
         dRef.f();
      }
   }
   //包访问权限接口E
   interface E{
      //嵌套的包访问权限接口G
      interface G{
         //方法f()
         void f();
      }
      //public的嵌套接口H
      public interface H{
         //方法f()
         void f();
      }
      //方法g()
      void g();
      //接口中不能嵌套private的接口
      //比如：
      //private interface I{}
   }
   //类NestingInterfaces
   public class NestingInterfaces{
      //public类BImp实现接口A中的嵌套接口B
      public class BImp implements A.B{
         //实现方法f()
         public void f() {}
      }
      //类CImp实现接口A中的嵌套接口B
      class CImp implements A.C{
         //实现方法f()
         public void f() {}
      }
      //不能在一个类外部去实这个一个类中的private接口
      //但是在这个类中可以.
      //比如
      //class DImp implements A.D{}
      //类A中的接口D是private,因此不能在类A外实现,但是在类A内部可以。
      //类EImp实现接口E
      class EImp implements E{
         //实现方法g()
         public void g() {}
      }
      //类EGImp实现接口E中的嵌套接口G
      class EGImp implements E.G{
         //实现方法g()
         public void f() {}
      }
      //类EImp2实现接口E
      class EImp2 implements E{
         //实现方法g()
         public void g() {}
         //内部类EG实现接口E中的嵌套接口G
         class EG implements E.G{
            //实现方法g()
            public void f() {}
         }
      }
      //程序执行入口main方法
      public static void main(String[] args){
         A a = new A();
         //下面的代码不能执行
         //A.D ad = a.getD();
         //因为接口D是private的,而方法getD()实际上返回的是一个DImp2
         //对象,同时它也是接口D的子对象,这里涉及到了向上转型为private接口
         //D,Java中是禁止的。
         //下面的代码不能执行
         //A.DImp2 di2 = a.getD();
         //因为方法getD()只能返回A.D类型
         //下面的代码不能执行
         //a.getD().f()
         //因为A.D中的接口D是private的。
         //只有另一个A对象可以访问getD()
         //创建另一个A对象a2
         A a2 = new A();
         //通过receiveD()方法访问
         //因为方法receiveD()将方法getD()的使用控制在了
         //类A的内部(a.getD()传入的是类A的内部方法)。
         a2.receiveD(a.getD());
      }
   }

执行情况如图：

以上代码示例从权限修饰词的角度和内部类的角度全面地说明了嵌套接口的使用情况。
在类中嵌套接口的语法是相当显而易见的，就像非嵌套接口一样，可以拥有public和"包访问"两种可视性。
作为一种新添加的方式，接口也可以被实现为private的，就现在类A中的接口D那样(相同的语法既适合嵌套接口也适合嵌套类)，那么private的嵌套接口能带来什么好处呢？也需它只能被实现为DImp中的一个private内部类，但是接口A中的类DImp2展示了它同样可以被实现为public类。但是，接口A中的类DImp2只能被其自身使用，你无法说它实现了一个private接口D，因此，实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息(也就是说，不允许向上转型：//A.D ad = a.getD();)。
getD()方法使我们陷入了一个进退两难的境地，这个问题与private接口相关，它是一个返回对private接口的引用的public方法，那我们对这个方法的返回值能做一些什么呢?在上面示例代码的main()方法中，可以看到数次阐释使用返回值的行为都报错了，只有一种方式可以成功，那就是将返回值交给有权使用它的对象，通过了另一个A对象外加receiveD()方法来实现的。
接口E说明接口彼此之间也可以嵌套的，然而，作用于接口的各种规则，特别是所有的接口元素都必须是public的，在此都会被严格的执行，因此，嵌套在另一个接口中的接口自动是public的，而不能声明为private的。
NestingInterface展示了嵌套接口的各种实现方式，特别要注意的是，当实现某个接口时，并不需要实现嵌套在其内部的任何接口，而且，private接口不能在定义它的类之外被实现。
添加了这些特性的最初原因可能是出于对严格的语法一致性的考虑，但是从某种角度出发，一旦你了解了某种特性，就总能够找到它的用武之地。
PS：时间有限，有关Java SE的内容会持续更新！今天就先写这么多，如果有疑问或者有兴趣，可以加QQ：2649160693，并注明CSDN，我会就博文中有疑义的问题做出解答。同时希望博文中不正确的地方各位加以指正。