C12-Java中的枚举与泛型

12.1 枚举

枚举的产生背景

• 在推出枚举之前，Java使用常量来表达“状态参数”。但常量的一个问题是，它们必须是特定的值，这可能会带来一些麻烦。
• 因为我们可以直接传递常量值的具体数值给需要状态参数的方法，而不是用常量本身。
• 换言之，开发者可以跳过使用设定好的常量属性，直接用具体数值作为参数，改变程序的结果，而不影响程序运行。
• 为了避免这种设计漏洞，JDK1.5引入了枚举。枚举中的常量（也称为枚举项、枚举值）是独一无二的，不会与其他值冲突，也不会被其他常量替代。

枚举的内涵与特点

枚举是一种特殊的数据类型，用于定义包含固定常量集合的数据结构。
它允许在代码中以一种易于理解和使用的方式表示一组固定的值。特点如下：

1. 类型安全： 枚举提供了一种类型安全的方式来表示固定常量集合。
2. 紧凑有效的数据定义： 枚举能够以简明的方式定义一组固定的常量。
3. 与程序其他部分完美交互： 枚举类型可以作为方法的参数或返回值，与程序的其他部分完美交互。
4. 运行效率高： 枚举通常在编译时会被优化，因此具有高效的运行效率。

定义枚举

定义枚举的语法格式如下：

enum Weekday {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

• enum: 关键字用于定义枚举类型。
• Weekday: 枚举类型的名称。
• {}: 用于定义枚举常量集合。
• MONDAY, TUESDAY, ...: 枚举常量，表示枚举类型的可能取值。

举个例子：

Weekday today = Weekday.MONDAY;
if (today == Weekday.MONDAY) {
    System.out.println("It's Monday!");
}

另外，枚举类型也可以拥有构造方法、成员变量和方法：

enum TrafficSignal {
    RED("Stop"), GREEN("Go"), YELLOW("Wait");

    private String action;

    TrafficSignal(String action) {
        this.action = action;
    }

    public String getAction() {
        return action;
    }
}

12.2 泛型

泛型的产生背景

• 泛型的出现源于在使用集合类（例如Object ）时，缺乏对集合中元素类型的指定。这会导致类型不确定，编译器无法及时发现错误，还需手动进行类型转换，带来不少问题。
• 另外。在泛型出现之前，我们使用Object 类表示任何对象。但这本质上是向上转型，而将任何类型的值赋给变量容易导致 强制转换错误。
• 这也意味着在使用Object 变量进行转换之前，需要使用instanceof 进行类型判断，这样会导致代码量庞大。
• 鉴于这些问题，JDK1.5推出了泛型，旨在解决这些类型不确定和转换的繁琐问题。

泛型的内涵与特点

泛型简单来说，就是一个模糊的类型，可以代表任何类型。其特点如下：

1. 类型安全： 泛型提供了编译时的类型检查，避免在运行时发生类型转换错误。
2. 代码重用： 泛型允许开发者编写通用的类和方法，以处理各种数据类型，增加代码的可重用性。
3. 增强代码可读性： 通过在代码中指定类型，可以使代码更清晰易懂，更容易维护。

需要注意，泛型通常用一个大写字母表示：

T t；
T t[]；

另外，用泛型定义的变量不能直接初始化，例如下面的代码是错误的：

T t1 = 1;
T t2 = "字符串"；
T t3 = new T()；
T t4[] = new T[10]；

并且，用泛型声明的变量不能使用static关键字，例如下面的代码是错误的：

static T t；

泛型有两个声明场景：泛型类和泛型方法，具体如下：

12.2.1 泛型类

泛型类是指在定义类的同时还定义了泛型。泛型的数量可以是多个，但名称不能重复。

定义泛型类

定义泛型类的语法格式如下：

class 类名 <T1, T2, T3, ...>

泛型可以用来定义成员变量，创建一个Demo类，同时定义两个泛型T和B，分别为这两个泛型创建变量：

class Demo<T, B>{
    T t;
    B b;
}

泛型除了可以用来定义成员变量外，还可以用来定义成员方法的参数和返回值：

class Demo<T>{
    T t;
    void set(T t){
        this.t = t
    }
    
    T get(){
        return t;
    }
}

泛型类创建对象

泛型类创建对象时可以指定泛型的类型，语法格式如下：

类<泛型> 变量名 = new 类<和前面一样的泛型>();

例如，为Demo<T>类创建对象时，为不同的对象设定不同泛型，以下代码都是正确的：

// 指定T为String类型
Demo<String> d1 = new Demo<String>();

// 指定T为Integer类型
Demo<Integer> d2 = new Demo<Integer>();

// 指定T为java.util.Date类型
Demo<java.util.Date> d3 = new Demo<java.util.Date>();

注意，从JDK7开始，可以忽略第二个<>中的泛型，JVM可以自动识别。

此外，泛型类在创建对象时也可以不指定任何泛型，这样泛型T就会被默指为Object类型，例如：

// 不指定泛型，其效果等价于下面的代码
Demo d = new Demo();

// T被指定为Object类型
Demo<Object> d = new Demo<Object>();

另外，泛型仅支持类类型和接口类型，不支持基本类型。如果想要将泛型设置为基本类型，需要使用对应的包装类型。以下是示范：

// 这是错误的
Demo<int> d1 = new Demo<int>(); 

// 这才是正确的
Demo<Integer> d1 = new Demo<Integer>();

泛型还支持数组类型，例如：

Demo<Integer[]> d = new Demo<Integer[]>();

需要注意的是，当泛型被指定为具体类型之后，泛型对象、泛型参数就不能被赋予其他类型的值了。

12.2.2 泛型方法

泛型方法是指单独定义了泛型的方法。

定义泛型方法

定义泛型方法的语法格式如下：

<T1, T2, T3, ...>返回值 方法名（）

例如，创建一个无返回值的method()方法，为该方法定义一个泛型T，代码如下：

<T> void method(){}

另外，定义泛型方法其实非常灵活：

// 泛型可以直接用来定义方法的参数
<T> void method(T t){}

// 泛型也可以用来定义方法的返回值类型
<T> T method(T t){
    return t;
}

// 泛型方法可以是静态方法
static <T> T method(T t){
    return t;
}

// 还可以同时定义多个泛型
<A, B, C> void method(A a, B b, C c){}

// 虽然泛型方法定义的泛型只能在本方法内使用，但泛型方法却可以出现在没有泛型的普通类中
class Demo{
    <T> T method(T t){
        return t;
    }
}

调用泛型方法

调用泛型方法的语法比较特殊，需要在方法名之前指定泛型类型。如果不指定泛型类型，泛型就会默认为Object类型。

调用泛型方法的语法格式如下：

对象.<泛型> 方法名();

调用静态泛型方法的语法格式如下：

类名.<泛型> 方法名();

举个例子，先在Demo中定义普通泛型方法method1与静态泛型方法method2，调用如下：

Demo demo = new Demo();

Integer a = demo.<Integer> method1(1);
String b = demo.<String> method1("Java");
Object c = demo.method1(new Object());

Double d = Demo.<Double> method2(1.1);
Object e = Demo.method2(new Object());

总之，泛型提供了一种通用的数据类型，它允许程序员在编写类、方法或接口时使用参数化类型。而通过使用泛型，可以在编译时提供更好的类型检查，并支持更好的代码复用，最终为程序员带来更多的便利！