Java的内部类

内部类的概念

在一个类的内部定义类被称为java的内部类，内部类提供了更好的封装，可以直接访问外部类的private成员。

通常划分为4种类型的内部类。

成员内部类：

1、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

2、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

3、静态方法不能实例化成员内部类。

4、成员内部类可以直接调用外部静态方法，也可以直接调用：外部成员变量和外部成员方法。

静态嵌套类：

1、静态嵌套内部类，可以直接调用外部类的静态变量和静态方法。

2、静态嵌套内部类，可以有main()方法。

方法内部类：

1、方法内部类，不可以定义静态方法。

2、方法内部类，外部方法不可以访问。

3、方法内部类，不可以是public修饰，只能是默认访问控制修饰。

匿名内部类：

1、匿名内部类，不需要知道具体的类名，只需要实现具体的方法即可。

代码案例

成员内部类：

/**
 * 成员内部类
 */
public class InnerMemberDemo {

    private int i = 100;

    public class Member {

        public void test() {
            System.out.println("test()................");
            // 调用外部类方法
            InnerMemberDemo.this.execute();
            System.out.println(InnerMemberDemo.this.i);
        }

    }

    public void execute() {
        System.out.println("execute()................");
    }

    public void doExecute() {
        Member m = new Member();
        m.test();
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 静态方法不能实例化 成员内部类
        InnerMemberDemo test = new InnerMemberDemo();
        test.doExecute();
    }

}

静态嵌套类：

/**
 * 静态嵌套类
 */
public class InnerStaticDemo {

    private static int i = 0;

    public static class Test {

        public void test() {
            System.out.println(InnerStaticDemo.i);
            execute();
        }

        public static void execute2() {
            System.out.println("Test execute()................");
        }

    }

    public static void execute() {
        System.out.println("execute()................");
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Test t = new Test();
        t.test();
        Test.execute2();
        execute();
    }

}

方法内部类：

public class InnerMethodDemo {

    String carName2 = "奥迪A6L";

    public void method() {
        //局部变量必须是final的，否则无法访问到
        final String carName = "奥迪A8L";
        class Car {
            //局部内部类除了final或者abstract外里面不能有任何修饰符
            public void run() {
                //方法内部类调用方法中的局部变量，对应的局部变量必须是final修饰的
                System.out.println("访问方法中的变量：" + carName);
                //方法内部类调用外部类的方法
                System.out.println("访问外部类的方法：" + getCarName2());
                //方法内部类调用外部类的属性
                System.out.println("访问外部类的变量：" + carName2);
            }
        }
        //创建非静态内部类并调用非静态内部类的方法
        new Car().run();
    }

    public String getCarName2() {
        return carName2;
    }

    public static void main(String[] args) {
        InnerMethodDemo innerMethodDemo = new InnerMethodDemo();
        innerMethodDemo.method();
        System.out.println(innerMethodDemo.getCarName2());
    }

}

匿名内部类：

/**
 * 匿名内部类
 */
public class InnerAnonymousDemo {

    interface Helper {
        public String exe();
    }

    public static String execute() {
        return new Helper() {
            public String exe() {
                System.out.println("exe()...");
                return "hello anonymous ";
            }
        }.exe();
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(execute());
    }
    
}