1.使用.this与.new

如果需要生成对外部类对象的引用,可以使用外部类的名字后面紧跟圆点和this。

public class Test3 {
    void f() {
        System.out.println("f()");
    }

    public class A {
        public Test3 outer() {
            return Test3.this;
        }
    }

    public A inner() {
        return new A();
    }

    public static void main(String[] args) {
        Test3 t = new Test3();
        Test3.A ta = t.inner();
        ta.outer().f();
    }
}

创建某个内部类的对象,必须在new表达式中提供其他外部类对象的引用,这就需要.new语法,必须使用外部类的对象来创建内部类。创建的是静态内部类，就不需要对外部类对象的引用。

public class Test4 {
    public class Inner {
    }

    public static void main(String[] args) {
        Test4 t = new Test4();
        Test4.Inner ti = t.new Inner();
    }
}

2.内部类与向上转型：内部类向上转型为一个接口的时候，实现了某个接口的对象，得到了对此接口的引用，将内部类向上转型为父类。使用内部类去继承类，或是实现接口，可以很好的阻止外部的访问。

interface A1 {
    void a();
}

class B {
    private class C implements A1 {
        public void a() {
            System.out.println("a()");
        }
    }

    public C getC() {
        return new C();
    }
}

public class Test5 {
    public static void main(String[] args) {
        B b = new B();
        A1 a1 = b.getC();
        a1.a();
    }
}

3.在方法和作用域内的内部类：可以在一个方法里，或者任意的作用域内定义内部类：实现了某类型的接口,就可以创建并返回对其的引用。定义内部类的方式：①一个定义在方法中的类。②一个定义在作用域的类。③一个实现了接口的匿名类(匿名类不能有构造器)。

public class Test6 {
    public static void main(String[] args) {
        class A2 {
            int x;
        }
        class B2 extends A2 {
            int y;
        }
        B2 b = new B2();
        b.x = 1;
        b.y = 2;
        System.out.println("x=" + b.x);
        System.out.println("y=" + b.y);
    }
}