java内部类 & java作用域修饰符

JAVA作用域修饰符，不写时默认为default：

外部类修饰符只能是public和default(默认值)

结合java编程思想来理解，即public体现java面向接口编程，private体现java的对象封装，protected体现java的对象继承

内部类修饰符：
○ 成员内部类：跟成员变量一样没有作用域修饰符限制（创建依赖于外部类，即在外部类中如果要访问成员内部类成员时，需要先创建外部类对象，通过外部类对象引用来访问内部类对象），创建成员内部类方式：new OutterClass().new InnerClass();
○ 静态内部类：跟静态变量一样没有作用域修饰符限制，创建静态内部类方式：new OutterClass.InnerClass();
○ 局部内部类：跟局部变量一样不能有作用域修饰符
○ 匿名内部类：无修饰符

代码如下：

/**
 * @author longe
 *    内部类作用：
 *        1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，
 *        2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
 *        3.方便编写事件驱动程序
 *        4.方便编写线程代码
 *        内部类的存在使得Java的多继承机制变得更加完善。
 *
 */
public class Test {

    private int a = 1;

    public static void main(String[] args) {
        Test test = new Test();
        test.print();
//        成员内部类的创建，依赖于外部类对象，即必须先创建外部类对象，再通过该对象引用来创建成员内部类
        Test.T testT = test.new T();
        testT.print();
//        静态内部类的创建
        Test.TT testTT = new Test.TT();
        testTT.print();
        
        TestIF teIf = new TestIF() {
            /* (non-Javadoc)
             *     匿名内部类，常用于时间监听调用
             */
            @Override
            public void print() {
                System.out.println("anonymity inner class -  " + 5);
            }
        };
        teIf.print();
    }

    /**
     *    局部内部类，作用范围在方法内部 
     */
    public void print() {
        class T {
            private int a = 4;
        }
        T t = new T();
        System.out.println("method inner class -  " + t.a);
    }

    /**
     * @author longe
     *    成员内部类，可以随意访问外部类变量和方法
     *    当内部类成员变量与外部类重复时，注意引用方式
     */
    class T {
        private int a = 2;
        public void print() {
            System.out.println("member inner class -  " + this.a);
//            引用外部类成员变量
            System.out.println("member inner class -  " + Test.this.a);
        }
    }

    /**
     * @author longe
     *    静态内部类，可以随意访问外部类变量和方法
     */
    static class TT {
        private int a = 3;

        public void print() {
            System.out.println("static inner class -  " + this.a);
        }
    }
}

关于继承内部类需要注意的地方，见代码注释：

/**
 * @author longe
 * 内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：
 *    1）成员内部类的引用方式必须为 Test.T.
 *    2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()
 *    这段代码摘自《Java编程思想》
 */
public class InheritInner extends Test.T{
    
    /**
     * @param test
     *     InheritInner不能通过编译，必须加上此构造函数，参数为父类的外部类形参
     */
    public InheritInner(Test test) {
//        必须加上外部类的构造调用，否则编译不通过，因为成员内部类T依赖于它的外部类Test
//        创建InheritInner时会先初始化父类，所以在此需要显示的构造父类的外部类Test
        test.super();
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        InheritInner inner = new InheritInner(test);
        inner.print();
    }
}