java 中的内部类学习小记

什么是内部类 

• 一个类的内部又完整的嵌套另外一个类的结构，被嵌套的类就被称为内部类。
• 嵌套其它的类的类被就是外部类。内部类是类的五大成员之一。
• 类的五大成员: 属性、方法、构造器、代码块、内部类。
• 内部类的最大特点就是可以访问外部类的私有属性。
• 其内部类在底层代码中大量应用，了解内部类会让你看源码的内功会更上一层楼。
• java中共四种内部类: 局部内部类、匿名内部类、成员内部类、静态成员内部类。
• 优点1:  方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
• 优点2:  好处内部类可以继承或实现接口，外部类实现或继承接口都对内部类没有影响。

1. 局部内部类

• 局部内部类是存在方法中和代码块内 (静态和普通都可以)
• 可以直接访问外部类的所有成员，包含私有的
• 内部类不能添加修饰符，但是可以用 final 修饰
• 作用域只存在定义的方法体内或者代码块中
• 外部其它的类不能访问这个局部内部类，可以通过外部类的引用调用该内部类所在的方法，从而实现调用该内部类
• 如果内部类和外部类的成员成名是，默认是使用就近原则，在内部类中如果想使用外部类的成员可以通过 (外部类名.this.成员名称), 外部类名.this 就是外部类的对象  

public class External {

    private String schoolName = "家里蹲学院";

    private String phone = "10086";

    /**
     * 局部内部类演示
     */
    public void test() {

        /**
         * 类的特征内部类几乎可以使用, 但是不能使用 static 定义方法和属性
         */
        class Inner {

            private String name;

            public Inner() {
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }

        /**
         * 一个方法中可以存在多个局部内部类
         */
        class Student {

            private String name;
            private String phone = "10010";

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

            public void print() {
                System.out.println("我是来自 " + External.this.schoolName + " 的 " + name + " 同学");
            }

            public void print2() {
                // 内部类和外部类成员重名的时候,默认使用就近原则
                System.out.println("内部类phone : " + phone);
                // 访问外部类的通过 外部类名.this.成员
                System.out.println("外部类phone : " + External.this.phone);
                // External.this 这个对象就是外部类调用 test 方法的对象
                System.out.println(External.this.toString());
            }
        }

        Student student = new Student("佛冷");
        student.print();
        student.print2();
    }
}

class Demo {
    public static void main(String[] args) {
        External external = new External();
        // 调用局部内部类, 通过外部类的引用可以直接调用内部类所在的方法
        external.test();
        System.out.println(external.toString());

    }
}

执行结果

2. 匿名内部类

• 最大特点就是没有类名，只能使用一次
• 语法: new 类或接口(参数列表){  类体 };
• 应用场景: 实际开发中遇到方法参数是用一个类或者接口操作参数时，就可以使用匿名内部类的方式

 public static void main(String[] args) {

        /**
         *  public Thread(Runnable target);
         *  Thread 类中有一个构造方法是以 Runnable 接口为参数的，这种情况就可以使用匿名内部类。
         */
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类开始执行");
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();
    }

3. 成员内部类

• 成员内部类存在外部类中，没有 static 修饰
• 成员内部类可以访问外部类所有成员(包含私有成员)
• 可以添加任意修饰符
• 作用域在外部类中，和其它成员一

public class Demo10 {

    private String name = "佛冷";

    public Integer age = 25;

    /**
     * 成员内部类
     * 1. 成员内部类不能定义静态方法和静态属性
     * 2. 成员内部类成员名称和外部类重名时候，是就近原则，如果内部类想要使用外部类的用 外部类名.this.成员名称
     */
    public class Inner {

        private String name;

        /**
         * 成员内部类使用外部类成员 (静态和普通都可以)
         */
        public void print() {
            System.out.println("外部类名称: " + Demo10.this.name);
            System.out.println("内部类名称: " + name);
            System.out.println(age);
        }

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

    public Inner getInner(String name) {
        return new Inner(name);
    }

}

class Test10 {

    public static void main(String[] args) {
        // 第一种创建成员内部类
        Demo10 demo10 = new Demo10();
        Demo10.Inner inner = demo10.new Inner("第一种");
        inner.print();

        // 第二种创建成员内部类
        demo10 = new Demo10();
        Demo10.Inner inner2 = demo10.getInner("第二种");
        inner2.print();
    }
}

输出结果

4. 静态成员内部类

public class Demo11 {

    private static String name = "佛冷";

    public  Integer age = 25;

    /**
     * 静态成员内部类
     * 1. 使用 static 修饰
     * 2. 只能使用外部类的 静态成员
     */
    public static class Inner {

        private String name;

        public void print() {
            System.out.println("内部类名称: " + name);
            // 访问外部静态成员使用 类名.成员名称
            System.out.println("外部类名称: " + Demo11.name);
            // 访问外部类普通成员 创建外部类对象来访问
            System.out.println(new Demo11().age);
        }

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

}

class Test11 {

    public static void main(String[] args) {
        Demo11.Inner inner = new Demo11.Inner(" 内部类");
        inner.print();
    }
}