Java编程思想---嵌套接口中private接口的理解P186页

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());
    }
}

在类中嵌套接口的语法是相当显而易见的，就像非嵌套接口一样，可以拥有publlic和“包访问”两种可视性。

作为一种新添加的方式，接口也可以被实现为private的。（相同的语法既适用于嵌套接口，也适用于嵌套类）那么private的嵌套接口能带来什么好处呢？读者可能会猜想，它只能够被实现为DImp中的一个private内部类，但是A.DImp2展示了它同样可以被实现为public类。但是，A.DImp2只能被其自身所使用。你无法说它实现了一个private接口D，因此，实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，不允许向上转型）。

getD()方法使我们陷入了一个进退两难的境地，这个问题与private接口相关：它是一个返回对private接口的引用的public方法。你对这个方法的返回值能做什么呢？在main()中，可以看到数次试图使用返回值的行为都失败了。只有一种方式可成功，那就是将返回值交给有权使用它 的对象。在本例中，是另一个A通过receiveD()方法来实现的。

接口E说明接口彼此之间也可以嵌套。然而，作用于接口的各种规则，特别是所有的接口元素都必须是public的，在此都会被严格执行。因此，嵌套在另一个接口中的接口自动就是public的，而不能声明为private。

NestingInterfaces 展示了嵌套接口的各种实现方式。特别需要注意的是，当实现某个接口时，并不需要实现嵌套在其内部的任何接口。而且，private接口不能在定义它的类之外被实现。

 

理解:

1.  因此，实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，不允许向上转型）    怎么理解?

1.1  理解这句话,先理解"可以看到数次试图使用返回值的行为都失败了。只有一种方式可成功，那就是将返回值交给有权使用它 的对象。在本例中，是另一个A通过receiveD()方法来实现的"这句话

 A a = new A();
        //Can't access A.D:   不能访问私有接口A.D
        //! A.D ad = a.getD();
        //Doesn't return anything but A.D:  除了私有接口A.D,不能返回任何东西 
        //! A.DImp2 di2 = a.getD();   //返回回来的私有接口A.D, 不能向下转型为A.DImp2
        //Cannot access a member of the interface:  不能访问私有接口A.D中的成员
        //! a.getD().f();  
        //Only another A can do anything with getD():  只有另一个A才能使用getD()做任何事
        A a2 = new A();
        a2.receiveD(a.getD());    //通过调用类中提前定义好的调用私有接口的方法

结合所给例子,我理解是 A.DImp2不能转型为 private接口D , 在类中getD()方法实现了向上转型,但是转型出来的结果是A.D 私有接口类型,是无法访问和独立使用的(向下转型和访问其中的方法),只能交给在类中定义好的使用该私有接口的方法. 所有总的来看, A.DImp2向上转型是没有任何意义的,也就是说 不允许向上转型.

所以:

1.2  A.DImp2只能被其自身所使用。你无法说它实现了一个private接口D  这句话就好理解了, A.DImp2转型为A.D 用处很小,即,A.DImp2只能自己单独作为一个对象使用, 因为它实现了private接口D,但是转型上去没有太大意义,而接口最大的意义就是向上转型,所以说,你无法说它实现了一个private接口D 

2.  文中用因此作为总结,所以说实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，不允许向上转型）,这句话是对前文A.DImp2只能被其自身所使用。你无法说它实现了一个private接口D  的总结,所以进行如此推断.

 

 

如有不同意见,欢迎大家评论指正!