java 内部类

内部类分类

静态内部类
1、静态内部类可以包含静态成员，非静态成员
2、静态内部类可以直接调用外部类的静态属性，静态方法。但不能调用外部类的普通属性，普通方法
3、在不相关的类中，可以直接创建静态内部类的对象

/**
 * 静态内部类
 * @author L J
 */
public class StaticClassTest {
    public static void main(String[] args) {
        //Outer.InnerClass oic = new Outer.InnerClass();
        //在不相关的类中，可以直接创建静态内部类的对象
        InnerClass inner = new InnerClass();
    }
}

class Outer {
    //静态内部类可以包含静态成员，非静态成员
    int a = 5;
    static int b = 10;

    InnerClass inner = new InnerClass();

    //静态内部类
    static class InnerClass {
        int c = 15;
        static int d = 20;

        //静态内部类可以直接调用外部类的静态属性，静态方法
        public void test() {
            System.out.println(d);
        }
    }
}

非静态内部类
1、普通内部类（也称成员内部类）

• 成员内部类就像一个成员变量一样存在于外部类中
• 成员内部类可以访问外部类的所有成员（包含：private的）
• 成员内部类的this指向内部类对象本身。要拿到外部类对象可以使用：外部类名+.this
• 成员内部类不能有静态成员，除非声明为final的常量

/**
 * 普通内部类
 * @author L J
 */
public class PlainInnerClassTest {
    public static void main(String[] args) {
        Outer02.InnerClass02 oic = new Outer02().new InnerClass02();
        oic.test();
    }
}

class Outer02 {
    private int a = 3;
    int b = 5;
    InnerClass02 inner = new InnerClass02();

    //成员内部类
    class InnerClass02 {

        final static int x = 6;

        void test() {
            System.out.println(a);
            System.out.println("内部类对象：" + this);
            System.out.println("外部类对象：" + Outer02.this);
        }
    }
}

2、匿名内部类

• 继承式
• 接口式
• 参数式

/**
 * 匿名内部类
 * @author L J
 */
public class EncryptInnerClassTest {
    public static void main(String[] args) {
        Outer04 out = new Outer04();
        out.test();
    }
}

class Outer04 {
    public void test() {
        //1、接口式匿名内部类，同时也是方法内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {

            }
        };

        //2、继承式匿名内部类
        Car car = new Car() {
            @Override
            public void run() {
                System.out.println("快上车");
            }
        };
        car.run();

        //3、参数式匿名内部类
        test02(new Car() {
            @Override
            public void run() {
                System.out.println("参数式匿名内部类");
            }
        });
    }

    public void test02(Car c) {
        c.run();
    }
}

//汽车类
class Car {
    public void run() {
        System.out.println("老司机开车");
    }
}

3、方法内部类（在一个外部类的方法或代码块中定义的内部类）

• 方法内部类的地位和方法内的局部变量的位置类似，所以不能用private、public、protected、static、transient等修饰
• 方法内部类只能是在声明的方法中可见
• 方法内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final。因为局部变量和方法内部类生命周期不一致
• 方法内部类只能包含非静态成员

/**
 * 方法内部类(局部内部类)
 * @author L J
 */
public class Outer03 {
    public void test() {
        int a = 1;

        //不能用private、public、protected、static、transient等修饰
        class Inner {
            //方法内部类只能包含非静态成员
            int b = 10;
            void test() {
                //方法内部类不能访问定义它的方法内的局部变量
                //System.out.println(a);
            }
        }

        //方法内部类只能是在声明的方法中可见
        Inner i = new Inner();
    }
}