从零学大数据系列之Java篇---第九章:内部类

课程重点:

• 成员内部类(会基本创建,概念)
• 静态内部类(会基本创建,概念)
• 局部内部类(会基本创建,概念)
• 匿名内部类,属于内部类的综合,有些难度,可以暂时理解下即可,后面学习lambda表达式再对比着看

9.1. 内部类的概述

9.1.1. 内部类的概念

内部类，即定义在类内的类。在Java中，可以在类的内部在定义一个完整的类。

• 内部类编译后，可以生成独立的字节码文件。
• 内部类可以直接访问外部类的私有成员，而不用破坏封装。
• 可为外部类提供必要的内部功能组件。

9.1.2. 内部类的分类

内部类，按照定义的位置和修饰符不同，可以分为:

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

9.2. 成员内部类

9.2.1. 概念

在类的内部定义，与实例变量、实例方法同级别的类。

9.2.2. 使用

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
• Outer outer = new Outer();
• Inner inner = outer.new Inner();

9.2.3. 特点

• 书写位置：与属性、方法平级别，且没有使用static*修饰的类。
• 访问权限：内部类可以是任意的访问权限。
• 成员内部类中，不能写静态属性、静态方法。
• 编译之后生成的字节码文件格式：外部类$内部类.class
• 实例化对象，需要借助外部类的对象完成。

9.2.4. 示例代码

/**
 * @Description 成员内部类
 */
class OuterClass {
    public String name;
    public class InnerClass {
        public String name;
        public void show(String name) {
            System.out.println(name);					// 访问参数 name	
            System.out.println(this.name);				// 访问内部类属性 name
            System.out.println(OuterClass.this.name);	// 访问外部类属性 name
        }
    }
}
class Program {
    public static void main(String[] args) {
        // 1. 实例化外部类对象
        OuterClass outer = new OuterClass();
        // 2. 借助外部类对象，实例化内部类对象
        OuterClass.InnerClass inner = outer.new OuterClass.InnerClass();
    }
}

9.3. 静态内部类

9.3.1. 概念

在类的内部定义，与实例变量、实例方法同级别的，使用static修饰的类。

9.3.2. 使用

• 不依赖外部类对象，可以直接创建或通过类名访问。
• Outer.Inner inner = new Outer.Inner();

9.3.3. 特点

• 书写位置：和类中的属性、方法平级，且使用关键字 static 修饰
• 静态内部类中，可以写属性、方法、构造方法...
• 静态内部类中，可以写静态属性、方法
• 编译之后生成的字节码文件，格式：外部类$内部类.class
• 对象的实例化，不需要借助外部类对象。

9.3.4. 实例代码

/**
 * @Description 静态内部类
 */
public class OuterClass {
    static class InnerClass {
        String name;
        public void show(String name) {
            System.out.println(name);
            System.out.println(this.name);
        }
    }
}
class Test {
    public static void main(String[] args) {
        // 1. 实例化静态内部类的对象
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        // 2. 可以通过导包的形式，
        //    先导包 import 包.OuterClass.InnerClass
        // InnerClass innerClass = new InnerClass();
        innerClass.show("aaa");
    }
}

9.4. 成员内部类

9.4.1. 概念

定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。

9.4.2. 特点

• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 不能使用访问权限修饰符修饰。
• 书写位置：写在一个类的方法内部，作用域仅限于当前方法。
• 局部内部类，编译后生成的字节码文件格式：外部类$序号内部类名.class

9.4.3. 示例代码

/**
 * @Description 局部内部类
 */
public class Program {
    private static int b = 10;
    public static void main(String[] args) {
        // 定义一个局部变量
        // 如果这个局部变量，被包裹在了一个局部代码段中（比如局部内部类、匿名内部类），此时这个局部变量会被隐式的定义为final
        int a = 10;
        // 在一个类的方法中，直接定义一个内部类
        class InnerClass {
            String name;
            public void show() {
                System.out.println(a);
                System.out.println(b++);
            }
        }
    }
}

9.5. 匿名内部类

9.5.1. 概念

没有类名的局部内部类。

9.5.2. 特点

• 一切特征与局部内部类相同。
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。

9.5.3. 示例代码

/**
 * @Description 匿名内部类
 */
public class Program {
    public static void main(String[] args) {
        // 1. 借助Person类，写一个匿名内部类
        //    这里实例化的是Person类的一个匿名子类的对象，并完成了向上转型
        Person xiaoming = new Person() {
            @Override
            public void walk() {
                System.out.println("sub walk");
            }
        };
        xiaoming.walk();
        // 2. 借助接口，写一个匿名内部类
        //    这里，其实实例化的是一个接口的匿名实现类的对象，并且完成了向上转型
        Calculate calculate = new Calculate() {
            @Override
            public int calculate(int a, int b) {
                return a + b;
            }
        };
    }
}

interface Calculate {
    int calculate(int a, int b);
}

abstract class Person {
    public void walk() {
        System.out.println("super walk");
    }
}