Java语言基础类的嵌套

　　类和接口可以在其他的类和接口的内部进行声明，它们要么声明为成员，要么声明在代码块内部。因为嵌套类是包围类的一个成员，所以嵌套类可以访问包围类的所有其他成员，包括包围类继承而来的所有成员。

1.静态嵌套

　　嵌套类被声明为其包围类的静态成员，作用于它们的可访问性规则和作用于包围类的其他成员的规则是相同的，可以具有private，package，protected，public的访问权限。2.内部类

　　非静态嵌套类称作内部类（inner class）。内部类的实例总是与其包围类的实例相关联的。

　　

public class CreateInnerClass {
    class InnerClass {
    }
    class InnerClass2{
    }
    
    public void outerMethod() {
        InnerClass ic = new InnerClass();
        InnerClass2 ic2 = new InnerClass2();
        System.out.println(ic.getClass().getName() + " " +ic2.getClass().getName());
    }
    
    public static void main(String[] args) {
        CreateInnerClass cic = new CreateInnerClass();
        cic.outerMethod();
    }
}

　　通常，内部类对象是在其包围类的实例方法内部创建的。如果想再包围类的非静态方法之外的地方创建内部类对象，必须指明这个对象的完全类型名：OuterClassName.InnerClassName。

public class CreateInnerClass {
    class InnerClass {
    }
    
    public InnerClass outerMethod() {
        InnerClass ic = new InnerClass();
        return ic;
    }
    
    public static void main(String[] args) {
        CreateInnerClass cic = new CreateInnerClass();
        CreateInnerClass.InnerClass cicic = cic.outerMethod();
        System.out.println(cicic.getClass().getName());
    }
}

　　也可以不通过外围类的方法而直接创建一个内部类对象，需要使用.new语法。

public class DotNew {
    public class InnerClass {
    }

    public static void main(String[] args) {
        DotNew dn = new DotNew();
        DotNew.InnerClass dni = dn.new InnerClass();
    }
}

　　当某个外围类对象创建了一个内部类对象时，此内部类对象会秘密捕获一个指向那个外围类对象的引用。在你访问外围类的成员时，就是那个引用来选择外围类的成员。如果你的内部类需要生成对外围类对象的引用，可以使用外围类的类名后面紧跟圆点加this。

public class DotThis {
    public class InnerClass {
        public DotThis getOuterRef() {
            return DotThis.this;
        }
    }
    
    void test() {
        System.out.println("DotThis.test()");
    }
    
    public InnerClass outMethod() {
        return new InnerClass();
    }
    
    public static void main(String[] args) {
        DotThis dt = new DotThis();
        DotThis.InnerClass dtic = dt.outMethod();
        dtic.getOuterRef().test();
    }
}

3.局部内部类

　　可以在代码块中定义内部类，这种局部内部类并不是声明它们的代码所在类的成员，而是像局部变量一样。局部内部类在定义它们的代码块外是无法访问的，但是这些类的实例是普通的对象。

public class LocalInnerClass {
    public void outerMethod() {
        class LocalInner {
        }
        LocalInner li = new LocalInner();
        System.out.println(li.getClass().getName());
    }
    
    public static void main(String[] args) {
        LocalInnerClass lic = new LocalInnerClass();
        lic.outerMethod();
    }
}

其中，LocalInner类的可见性仅在outerMethod()方法内部。

4.匿名类

　　

class Test {
    public void show() {
        System.out.println("Test.show()");
    }
}

public class AnonymousInnerClass {
    public void outerMethod() {
        Test t = new Test() {
                        public void show() {
                            System.out.println("Anonymous.show()");
                        }
                    };
                }
                    
    public static void main(String[] args) {
        AnonymousInnerClass aic = new AnonymousInnerClass();
        aic.outerMethod();
    }
}