1、对于non-static inner class的对象初始化,请看下面程序段:
public class Outer {
private int i = 34;
private class Inner {
private void setP() {
i += 23;
System.out.println("Inner.setP().i = " + i);
}
private class InnerInner {
private void setPP() {
i += 53;
System.out.println("InnerInner.setPP().i = " + i);
}
}
}
public static void main(String[] args) {
Outer o = new Outer();
Outer.Inner inner = o.new Inner();
inner.setP();
Outer.Inner.InnerInner iinner = inner.new InnerInner();
iinner.setPP();
}
}
在main函数中,对第一层inner class的调用采用Outer.Inner inner = o.new Inner();方法,对象Ref标识符需要用“外覆类.内隐类”格式来表示,在new的时候,需要有外覆类的对象Ref在前面;对于第二层inner class的调用同第一层类似,对象Ref标识符需要用“外覆类.内隐类.内隐类”格式来表示(外面有几层“包装”的类都要写在前面),在new的时候同样需要直属“包装”类的对象Ref在前面,对于多层的嵌套,原理同上,可以自己亲自编写尝试。
2、对于static inner class的对象初始化,请看下面程序段:
public class Outer1 {
private int i = 23;
static private class Inner1 {
private void p1() {
System.out.println("Inner1.p1().");
}
static private class Inner2 {
private void p2() {
System.out.println("Inner2.p2().");
}
}
}
public static void main(String[] args) {
Outer1 o = new Outer1();
Outer1.Inner1 inner1 = new Inner1();
inner1.p1();
Outer1.Inner1.Inner2 inner2 = new Inner1.Inner2();
inner2.p2();
}
}
在main函数中,对第一层static inner class的调用采用Outer1.Inner1 inner1 = new Inner1();
方法,对象Ref标识符表示方法与non-static inner class相同,需要用“外覆类.内隐类”格式来表示,在new的时候,可以直接对static inner class进行new操作;对于第二层static inner class的调用,对象Ref标识符表示方法与上面同理,即“外覆类.内隐类.内隐类”格式来表示(有几层外覆类都要写在前面),在new的时候需要在第二层静态类名称前面加上第一层静态类的名称(对于多层嵌套,需要用外包的静态类名称作引用,逐层引用),static inner class可以看作是外覆类的一个静态函数,不需外覆类的Ref;static inner class与non-static inner class相比少了一些访问权限,对于外覆类的field没有了访问权限,这是因为static inner class与outer class 之间没有隐藏的reference关系,所以无法调用隐藏reference进行访问。对于static inner class的多层嵌套,原理同上,可以自己亲自编写尝试。