Java 内部类

定义在另一个类（外部类）中的类。

package f_oop;

/*
 * 外部类
 */
class Outer {

    private String name;

    int age;

    static String sex;

    /*
     * 成员内部类：定义在成员处的类
     */
    class MInner {

        int age = 20;

        // static String sex = "female"; // 不能有static成员

        public MInner() {
        }

        public MInner(int age) {
            this.age = age;
        }

        public void show() {
            // 能直接访问外部类的所有属性/方法（包括private修饰的）
            System.out.println(name); // 若同名，则访问内部类的
            System.out.println(Outer.this.name);  // 访问外部类的（无论是否同名）

            System.out.println(age);
            System.out.println(Outer.this.age);

            System.out.println(sex);
            System.out.println(Outer.this.sex);
            System.out.println(Outer.sex);
        }

    }

    /*
     * 静态内部类：static修饰的成员内部类
     */
    static class SInner {

        int age = 20;

        static String sex = "female";

        public SInner() {
        }

        public SInner(int age) {
            this.age = age;
        }

        public void show() {
            // 只能直接访问外部类的静态属性/静态方法（包括private修饰的）
            // System.out.println(name);
            // System.out.println(Outer.this.name); // 不能使用外部类的this

            System.out.println(age);

            System.out.println(sex);
            System.out.println(Outer.sex);
        }

    }

    public Outer() {
    }

    public Outer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {

        String hobby = "打球";

        /*
         * 局部内部类：定义在方法中的类
         */
        class LInner {

            String name = "tom";

            // static String sex = "female"; // static成员必须被final修饰
            static final String sex = "female";

            public LInner() {
            }

            public LInner(String name) {
                this.name = name;
            }

            public void show() {
                name = "alice";
                System.out.println(name);
                System.out.println(Outer.this.name);

                age = 9;
                System.out.println(age);
                System.out.println(Outer.this.age);

                System.out.println(sex);
                System.out.println(Outer.sex);

                // hobby = "敲代码"; // 报错，会将所在方法中定义的变量，隐式修饰为final
                System.out.println(hobby);
            }

        }

        // hobby = "female"; // 局部内部类访问hobby报错：已修改值，无法将其修饰为final

        LInner lInner = new LInner();
        lInner.show();

        // 编译后，内部类也会对应生成一个class文件
        System.out.println(lInner.getClass());
    }

    // LInner lInner = new LInner(); // 报错

}

public class R_InnerClass {

    public static void main(String[] args) {
        Plant plant = new Plant() {

            /*
             * 匿名内部类（最常用）：没有名字的内部类
             *
             * 只能在"继承抽象类/实现接口"时定义和使用（只能用一次）
             */

            // static String sex = "female"; // static成员必须被final修饰
            static final String sex = "female";

            // 无构造方法

            public void show() {
                // 能直接访问外部类中，非private修饰的属性/方法
                // System.out.println(name); // 无法访问

                age = 9;
                System.out.println(age);
                // System.out.println(Plant.this.age); // 不能使用外部类的this

                System.out.println(sex);
                System.out.println(Plant.sex);

                System.out.println(getClass());
            }

        }; // 定义继承Plant的匿名内部类，并创建其对象

        plant.show();
        plant.grow();


        // MyInterface m = new MyInterfaceImpl();
        MyInterface m = new MyInterface() {

            public void show(String s) {
                System.out.println(s);

                System.out.println(getClass());
            }

        }; // 定义实现MyInterface的匿名内部类，并创建其对象

        // MyInterface m2 = (s) -> { // lambda表达式（一种语法糖，即语法的简化），条件：匿名内部类只用实现接口的一个方法
        MyInterface m2 = s -> { // 条件：实现的方法只有一个形参
            System.out.println(s);
        };

        MyInterface m3 = s -> System.out.println(s); // 条件：方法体只有一条语句

        m.show("m1");
        m2.show("m2");
        m3.show("m3");

        // Plant plant = () -> { // 不能用lambda
        //     System.out.println("R_InnerClass.main");
        // }

        /*
         * 创建成员内部类对象
         */
        Outer outer = new Outer("陈孝燈", 22);
        Outer.sex = "male";

        Outer.MInner mInner = outer.new MInner();

        mInner.show();

        System.out.println(mInner.getClass());

        /*
         * 创建静态内部类对象
         */
        Outer.SInner sInner = new Outer.SInner();

        sInner.show();

        System.out.println(sInner.getClass());

        /*
         * 只能在局部内部类所在方法中，创建其对象
         */
        outer.show();
    }

}

abstract class Plant {

    private String name = "向日葵";

    int age = 1;

    protected static String sex = "monoecism";

    public abstract void show();

    public void grow() {
        System.out.println("植物正在生长");
    }

}

interface MyInterface {

    void show(String s);

}

class MyInterfaceImpl implements MyInterface {

    public void show(String s) {
        System.out.println(s);
    }

}