Java-InnerClass-02

 Java自带了很好的隐藏机制:只给予某个类"包访问权"(仅在同一个包内可见),而用不着把类创建为内部类.
 当将内部类向上转型为其基类,尤其转型为一个接口的时候,内部类就有了用武之地.
 从实现了某个接口的对象,得到对此接口的引用,与向上转型为这个对象的基类,实质上效果是一样的.
 这是因为此内部类(某个接口的实现)对于其他人来说能够完全不可见(而不只是包外不可见)且不可用.所得到的只是指向基类or接口的引用,所以能够很方便的隐藏实现细节.

class  Parcel_Upcast ... {
    private class Pcontents implements Contents...{
        private int value;
        private Pcontents(int value)...{
            this.value = value;
        }
        public int readValue()...{
            return value;
        }
    }
    private class Pdestination implements Destination...{
        private String label;
        private Pdestination(String toWhere)...{
            label = toWhere;
        }
        public String readLabel()...{
            return label;
        }
    }
    public Contents getContents(int value)...{
        return new Pcontents(value);
    }
    /**//*返回类型最好设置为基类or接口,名称get基类,return的是内部类就ok了.这可以理解为是一种规范.*/
    public Destination getDestination(String label)...{
        return new Pdestination(label);
    }
}

main方法必须在一个独立的类中,才能演示出私有内部类的性质
private内部类给类的设计者提供了一种途径,通过这种方式可以完全阻止任何依赖于类型的编码,并且完全隐藏了实现的细节.
从客户端程序员的角度看,由于不能访问任何新增加的,原来不属于公共接口的方法,所以扩展接口是没有价值的.这给编译器提供了生成更高效代码的机会.
普通的(非内部的)类,不能申明为private和protected,它们只可以被赋予public或者包访问权.

class  TestParcel_Upcast ... {
    public static void main(String[] args) ...{
        Parcel_Upcast par = new Parcel_Upcast();
        Contents con = par.getContents(20);
        Destination des = par.getDestination("NanJing");
    }
}
/**/ /*重名问题*/
class  Outer1 ... {
    private int size;
    class Inner...{
        private int size;
        public void doStuff(int size)...{
            size++;//引用的是doStuff函数的形参
            this.size++;//引用的是Inner类中的成员变量
            Outer1.this.size++;//引用的是Outer1类中的成员变量
        }
    }
}