初学Java中的内部类(一)

首先看一下书中的例子：
//: c08:Destination.java
public interface Destination
{
        String readLabel();
} ///:~

//: c08:Contents.java
public interface Contents
{
        int value();
} ///:~

//: c08:Parcel3.java
// Returning a reference to an inner class.
public class Parcel3
{
        private class PContents implements Contents
        {
                private int i = 11;

                public int value() { return i; }
        }
       
        protected class PDestination implements Destination
        {
                private String label;

                private PDestination(String whereTo)  { label = whereTo; }
                public String readLabel() {  return label;  }
        }

        public Destination dest(String s) {  return new PDestination(s);  }

        public Contents cont() {  return new PContents(); }
}

class Test
{
        public static void main(String[] args)
        {
                Parcel3 p = new Parcel3();
                Contents c = p.cont();
                Destination d = p.dest("Tanzania");
                // Illegal -- can't access private class:
                //! Parcel3.PContents pc = p.new PContents();
        }
} ///:~

看到 p.new PContents()时我感到很惊讶，在我的潜意识里应该是这样写的new Parcel3.PContents(),这当然是C++的思维了，呵呵。由此我又试了试发现Java与C++在这样快的不同，C++中我们可以这样写代码:
class A
{
public:
    class B
    {
    };

private:
    int i;
};

int main()
{
    A::B *b = new A::B();
    return 0;
}

我发现了二者的不同：
1， C++中的内部类（我不知道是否可以这么说）与其外部类没有什么从属关系，这是两个独立的类，外部类只不过像名字空间的机制一样将内部类包了起来，我们用外部类名::内部类名就可以获取其类型定义了。
2，Java中的内部类与其外部类之间并不是独立的，其内部类就像外部类的其他方法，成员变量一样都是外部类的一个属性，除非其被声明为static的，否则必须通过外部类的对象才能访问
       下面的代码可以验证我的说法：
public class InnerClassTest
{
    private void f() {}
    private static void sf() {}

    public class InnerClass1
    {
        public InnerClass1()
        {
            f();         //can access to the private member method
        }
    }
   
    private class InnerClass2{    }
   
    public static class StaticInnerClass
    {
        public StaticInnerClass()
        {
            sf();  //can access to the static private member method
        }
    }
   
}

class Test
{
    public static void main(String[] args)
    {
        InnerClassTest test = new InnerClassTest();
        InnerClassTest.InnerClass1 i1 = test.new InnerClass1();

        //illegal: The type InnerClassTest.InnerClass2 is not visible
        //but if this main() is in InnerClassTest, it turns to be legal, I'am a little trouble about what can be
        //seen in static method?
        InnerClassTest.InnerClass2 i2 = test.new InnerClass2();

        //static inner class
        InnerClassTest.StaticInnerClass s = new InnerClassTest.StaticInnerClass();
    }
}