【JavaSE 第二十一天】

【JavaSE 第二十一天】

一、枚举

1. 学习目标

• 了解枚举的概念
• 掌握枚举的格式
• 掌握枚举的应用场景
• 掌握枚举的使用

2. 内容讲解

（1） 枚举的概述

枚举是 Java 中一种特殊的类，它可以定义固定数量的枚举实例，例如：性别、交通信号灯、季节等等

（2） 为什么要使用枚举

假设我们要定义一个人类，人类中包含姓名和性别。通常会将性别定义成字符串类型，效果如下：

public class Person {
   
    private String name;
    private String sex;

    public Person() {
   
    }

    public Person(String name, String sex) {
   
        this.name = name;
        this.sex = sex;
    }
	
    // 省略 get/set/toString 方法
}

public class Demo01 {
   
    public static void main(String[] args) {
   
        Person p1 = new Person("张三", "男");
        Person p2 = new Person("张三", "abc"); // 因为性别是字符串，所以我们可以传入任意字符串
    }
}

不使用枚举存在的问题：可以给性别传入任意的字符串，导致性别是非法的数据，不安全。

（3） 作用

一个方法接收的参数是固定范围之内的时候，那么即可使用枚举类型

（4） 格式

enum 枚举名 {
   
    第一行都是罗列枚举实例,这些枚举实例直接写大写名字即可。
}

（5） 入门案例

1. 定义枚举：MALE 表示男，FEMALE 表示女

enum Gender {
   
    MALE, FEMALE; // 男，女
}

2. Perosn 中的性别由 String 类型改为 Gender 枚举类型

public class Person {
   
    private String name;
    private Gender gender;

    public Person() {
   
    }

    public Person(String name, Gender gender) {
   
        this.name = name;
        this.gender = gender;
    }
    // 省略 get/set/toString 方法
}

3. 使用时只能传入枚举中的固定值

public class Demo {
   
    public static void main(String[] args) {
   
        Person p1 = new Person("张三", Gender.MALE);
        Person p2 = new Person("张三", Gender.FEMALE);
        // Person p3 = new Person("张三", "abc"); // 没有定义该数据就会报错
    }
}

（6） 枚举中添加成员变量和成员方法

枚举的本质是一个类，所以枚举中还可以有成员变量，成员方法等。

public enum Gender {
   
    MALE("male"), FEMALE("female"); // 就相当于 new 一个对象，需要传入参数
    public String tag; // tag 表示某一种性别的标识

	// 重写枚举的构造方法（有参构造） 理论上可以拥有无参构造器，但是实际需求不需要用到，所以不用写
    Gender(String tag) {
   
        this.tag = tag;
    }
    
    // 可以使用 get 方法获取 tag
    public String getTag() {
   
        return tag;
    }
    
    public void showTag() {
   
        System.out.println("它的性别标志是: " + tag);
    }
}

public class Demo {
   
    public static void main(String[] args) {
   
        Person p1 = new Person("张三", Gender.MALE);
        Person p2 = new Person("张三", Gender.FEMALE);

        Gender.MALE.showTag();
        Gender.FEMALE.showTag();
    }
}

（7）枚举的红绿灯案例：

public enum Color {
   
    RED("红"),YELLOW("黄"),GREEN("绿");
    private String colorTag; // 颜色标识

    public String getColorTag() {
   
        return colorTag;
    }

    Color(String colorTag){
   
        this.colorTag=colorTag;
    }
}

二、反射

1. 学习目标

• 了解类的加载过程
• 理解类初始化过程
• 了解类加载器
• 掌握获取 Class 对象的四种方式
• 能够运用反射获取类型的详细信息
• 能够运用反射动态创建对象
• 能够运用反射动态获取成员变量并使用
• 能够运用反射动态获取成员方法并使用
• 能够运用反射获取泛型父类的类型参数

2. 内容讲解

（1） 类加载(了解)

类在内存中的生命周期：加载 → 使用 → 卸载

① 类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、连接、初始化三个步骤来对该类进行初始化，如果没有意外，JVM 将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载。

类的加载又分为三个阶段：

（1）加载：load

就是指将类型的 class 字节码数据读入内存 （得到一个Class 对象）

（2）连接：link

①验证：校验合法性等

②准备：准备对应的内存（方法区），创建 Class 对象，为类变量赋默认值，为静态常量赋初始值。

③解析：把字节码中的符号引用替换为对应的直接地址引用

（3）初始化：initialize（类初始化）即执行 < clinit > 类初始化方法，会给类的静态变量赋初始值

② 类初始化

Ⅰ、哪些操作会导致类的初始化(加载)？

1. 运行主方法所在的类，要先完成类初始化，再执行 main 方法
2. 第一次使用某个类型就是在 new 它的对象，此时这个类没有初始化的话，先完成类初始化再做实例初始化
3. 调用某个类的静态成员（类变量和类方法），此时这个类没有初始化的话，先完成类初始化
4. 子类初始化时，发现它的父类还没有初始化的话，那么先初始化父类
5. 通过反射操作某个类时，如果这个类没有初始化，也会导致该类先初始化

• 测试案例：（了解）

// 父类
class Father{
   
	static{
   
		System.out.println("main方法所在的类的父类(1)"); // 初始化子类时，会初始化父类
	}
}

// 继承类
public class TestClinit1 extends Father{
   
	static{
   
		System.out.println("main方法所在的类(2)"); // 主方法所在的类会初始化
	}
	
	// main 方法
	public static void main(String[] args) throws ClassNotFoundException {
   
		new A(); // 第一次使用 A 就是创建它的对象，会初始化 A 类
		B.test(); // 直接使用 B 类的静态成员会初始化 B 类
		Class clazz = Class.forName("包名.C"); // 通过反射（获取字节码对象）操作 C 类，会初始化 C 类
	}
}

// A 类
class A{
   
	static{
   
		System.out.println("A 类初始化");
	}
}

// B 类
class B{
   
	static{
   
		System.out.println("B 类初始化");
	}
	public static void test(){
   
		System.out.println("B 类的静态方法");
	}
}

// C 类
class C{
   
	static{
   
		System.out.println("C 类初始化");
	}
}

Ⅱ、哪些使用类的操作，但是不会导致类的初始化(加载)？

1. 使用某个类的静态的常量（static final）
2. 通过子类调用父类的静态变量，静态方法，只会导致父类初始化，不会导致子类初始化，即只有声明静态成员的类才会初始化
3. 用某个类型声明数组并创建数组对象时，不会导致这个类初始化

• 测试案例：（了解）

public class TestClinit2 {
   
	// main 方法
	public static void main(String[] args) {
   
		System.out.println(D.NUM); // 调用 D 类的常量 D 类不加载
		System.out.println(F.num); // 调用 F 类继承 E 类的静态变量，F 类不加载，E 类会加载（父类加载）
		F.test(); // 调用 F 类继承 E 类的静态方法，上面 E 类已经加载了，不会再加载一遍（一个类只会加载一次）
		G[] arr = new G[5]; // new 这个类的数组，G 类不会加载
	}
}

// D 类
class D{
   
	public static final int NUM = 10;
	static{
   
		System.out.println("D类的初始化");
	}
}

// E 类
class E{
   
	static int num = 10;
	static{
   
		System.out.println("E父类的初始化");
	}
	public static void test(){
   
		System.out.println(