Java语法——内部类（JDK 1.1）

Java语法——内部类（JDK 1.1）

内部类概念

  Java类中的组成有：构造器、字段（成员变量）、方法（成员方法）、内部类（成员内部类、匿名内部类和局部内部类）、语句块。除了构造器外，其他四种组成都有静态的（又称“类的”）和非静态的（又称“实例的”）两类。相应地，使用一个类的成员有两种方式，一是类名.静态成员（操作类），二是new 构造器().实例成员（操作对象）。
  类的成员（member）指成员变量（memberVariable）、成员方法（memberMethod）和成员内部类（memberInner）。静态成员是对类的初始化，构造器是对类的对象的初始化。实例成员中可以使用静态成员，但静态成员中不可以直接使用实例成员（通过构造器new出对象后才可使用）。
  Java类之间的交互：
  一个类中使用到其他类的地方有：构造器、成员方法、语句块。
  一个类中可以被其他类使用的组成有：成员变量、成员方法、成员内部类。

  一般情况，我们把类定义成独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，称为内部类(innerclasses)。内部类具体分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。成员内部类是静态的还是实例的，取决于外部类以外的地方使用成员内部类时，是否需要通过外部类对象，若需要则是实例的，若不需要则是静态的。

  内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰。

  内部类只是一个编译时概念，一旦我们编译成功，就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为Inner的内部类。编译完成后会出现Outer.class和Outer$Inner.class两个类的字节码文件。

代码说明

非静态内部类

/**
 * 外部类以外的类
 */
class Test{
    public static void main(String[] args) {
        // 外部类以外的地方 访问 非静态内部类的实例成员
        Outer.Inner inner = new Outer().new Inner();
        inner.innerInstanceMethod();
        int a = inner.innerInstanceField;
    }
}


/**
 * 外部类
 */
class Outer {
    private int outerInstanceField;
    private static int outerStaticField;

    public void outerInstanceMethod(){
        // 外部类实例成员中 访问 非静态内部类的实例成员
        Inner inner = new Inner();
        inner.innerInstanceMethod();
        int b = inner.innerInstanceField;
    }

    public static void outerStaticMethod(){
        // 外部类静态成员中 不能访问 非静态内部类的实例成员！
        // 非静态内部类对象的创建，依赖外部类的对象，因此非静态内部类的对象不能在外部类的静态成员中创建
//        Inner inner = new Inner();
//        inner.innerInstanceMethod();
//        int b = inner.innerInstanceField;
    }


    /**
     * 非静态内部类
     */
    public class Inner {
        public int innerInstanceField;

        public void innerInstanceMethod(){
            // 非静态内部类实例成员中 访问 外部类静态成员
            outerStaticMethod();
            int a = outerStaticField;

            // 非静态内部类实例成员中 访问 外部类实例成员
            Outer outer = new Outer();
            outer.outerInstanceMethod();
            int b = outer.outerInstanceField;
        }

    }  // end Inner{}

}  // end Outer{}

静态内部类

/**
 * 外部类以外的类
 */
class Test{
    public static void main(String[] args) {
        // 外部类以外的地方 访问 静态内部类的静态成员
        Outer.Inner.innerStaticMethod();
        int b = Outer.Inner.innerStaticField;

        // 外部类以外的地方 访问 静态内部类的实例成员
        Outer.Inner inner = new Outer.Inner();
        inner.innerInstanceMethod();
        int a = inner.innerInstanceField;
    }
}

/**
 * 外部类
 */
class Outer {
    private int outerInstanceField;
    private static int outerStaticField;

    public void outerInstanceMethod(){
        // 外部类实例成员中 访问 静态内部类的静态成员
        Inner.innerStaticMethod();
        int a = Inner.innerStaticField;

        // 外部类实例成员中 访问 静态内部类的实例成员
        Inner inner = new Inner();
        inner.innerInstanceMethod();
        int b = inner.innerInstanceField;
    }

    public static void outerStaticMethod(){
        // 外部类静态成员中 访问 静态内部类的静态成员
        Inner.innerStaticMethod();
        int a = Inner.innerStaticField;

        // 外部类静态成员中 访问 静态内部类的实例成员
        Inner inner = new Inner();
        inner.innerInstanceMethod();
        int b = inner.innerInstanceField;
    }

    /**
     * 静态内部类
     */
    public static class Inner {
        public int innerInstanceField;
        public static int innerStaticField;

        public void innerInstanceMethod(){
            // 静态内部类实例成员中 访问 外部类静态成员
            outerStaticMethod();
            int a = outerStaticField;

            // 静态内部类实例成员中 访问 外部类实例成员
            Outer outer = new Outer();
            outer.outerInstanceMethod();
            int b = outer.outerInstanceField;
        }

        public static void innerStaticMethod(){
            // 静态内部类静态成员中 访问 外部类静态成员
            outerStaticMethod();
            int a = outerStaticField;

            // 静态内部类静态成员中 访问 外部类实例成员
            Outer outer = new Outer();
            outer.outerInstanceMethod();
            int b = outer.outerInstanceField;
        }
    }  // end Inner{}

}  // end Outer{}

匿名内部类

/**
 * 外部类以外的类
 */
class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.inner.greet();
        outer.inner.greetSomeone("cty");
    }
}  // end Test{}


/**
 * 匿名内部类接口
 */
interface HelloWorld {
    void greet();
    void greetSomeone(String name);
}  // end HelloWorld{}

/**
 * 外部类
 */
class Outer {

    /**
     * 匿名内部类
     *      通过实现接口来创建，适用于类只使用一次的场景
	 *      匿名内部类没有访问修饰符，没有构造方法（类名都没有，何来构造方法）
     */
    HelloWorld inner = new HelloWorld() {
        String name = "world";

        @Override
        public void greet() {
            greetSomeone(name);
        }

        @Override
        public void greetSomeone(String name) {
            this.name = name;
            System.out.println("Hello " + name);
        }
    };  // 不要忘记分号！

}  // end Outer{}

/**
 * Hello world
 * Hello cty
 */

局部内部类

/**
 * 外部类以外的类
 */
class Test {
    public static void main(String[] args) {
        new Outer().greet();
    }
}  // end Test{}

/**
 * Hello World
 */


/**
 * 外部类
 */
class Outer {

    public void greet(){

        /**
         * 局部内部类
         *      仅在greet方法的作用域下有效
         */
        class Inner {
            public void helloWorld(){
                System.out.println("Hello World");
            }
        }  // end Inner{}

        new Inner().helloWorld();
    }  // end greet()

}  // end Outer{}

运行环境

1. jdk-1.7
2. Intellij IDEA 2019.3

参考

[1] 内部类的分类