JAVA核心：枚举类型与泛型_寒夜的博客-CSDN博客

安宇雨 - 随手采集
2021-07-26 16:54:22
随手采集
0000-未整理-等待研究

文章目录

1. 枚举类型
2. 泛型

1. 枚举类型

使用枚举类型，可以取代前面学习过的定义常量的方式，同时枚举类型还赋予程序在编译时进行检查的功能。

1.1 使用枚举类型设置常量

使用枚举类型定义常量的语法如下：

public enum Constants{
    Constants_A,
    Constants_B,
    Constants_C
}

其中，enum是定义枚举类型关键字。当需要在程序中使用该常量时，可以使用Constants.Constants_A来表示。

我们可以实例进行比较。首先，创建Seasons接口：

public interface Seasons {
     public static final int SPRING = 1;
     public static final int SUMMER = 2;
     public static final int AUTUMN = 3;
     public static final int WINTER = 4;
}

然后，创建Enum：

public enum Seasons2 {
    SPRING,    SUMMER,    AUTUMN,    WINTER;
}

然后，创建Demo类：

public class Demo {
    public static void doit(int c) {
        switch(c) {
        case Seasons.SPRING:
            System.out.println("doit():春天");
            break;
        case Seasons.SUMMER:
            System.out.println("doit():夏天");
            break;
        case Seasons.AUTUMN:
            System.out.println("doit():秋天");
            break;
        case Seasons.WINTER:
            System.out.println("doit():冬天");
            break;
        }
    }
    
    public static void doit2(Seasons2 s) {
        switch(s) {
        case SPRING:
            System.out.println("doit2():春天");
            break;
        case SUMMER:
            System.out.println("doit2():夏天");
            break;
        case AUTUMN:
            System.out.println("doit2():秋天");
            break;
        case WINTER:
            System.out.println("doit2():冬天");
            break;
        }
    }
    
    public static void main(String[] args) {
        doit(Seasons.WINTER);
        doit2(Seasons2.WINTER);
    }
}

运行得到结果：

doit():冬天
doit2():冬天

1.2 深入了解枚举类型

1.2.1 操作枚举类型成员的方法

枚举类型较传统定义常量的方式，除了具有参数类型检测的优势之外，还具有其他方面的优势。

用户可以将一个枚举类型看作是一个类，它继承于java.lang.Enum类，当定义一个枚举类型时，每一个枚举类型成员都可以看作是枚举类型的一个实例，这些枚举类型成员默认都被final、public、static所修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。

在这里插入图片描述
首先，在Enum中输入：

public enum Constants {
    Constants_A,Constants_B,Constants_C,Constants_D,Constants_E,
}

然后，在Demo中输入：

public class Demo {    
    public static void main(String[] args) {
        Constants enumArray[] = Constants.values();
        
        for(Constants tmp:enumArray) {
            System.out.println("枚举类型成员的值："+tmp);
        }
    }
}

运行，得到结果：

枚举类型成员的值：Constants_A
枚举类型成员的值：Constants_B
枚举类型成员的值：Constants_C
枚举类型成员的值：Constants_D
枚举类型成员的值：Constants_E

在这里插入图片描述
继续使用上面例子的Enum：

public enum Constants {
    Constants_A,Constants_B,Constants_C,Constants_D,Constants_E,
}

创建Demo类：

public class Demo {
    public static void main(String[] args) {
        Constants c1 = Constants.Constants_A;
        Constants c2 = Constants.valueOf("Constants_A");
        System.out.println("c1与c2是否相等：" + (c1 == c2));
    }
}

运行得到结果：

c1与c2是否相等：true

在这里插入图片描述
首先，创建Enum：

public enum Constants {
    Constants_A, Constants_B, Constants_C,
}

然后创建Demo类：

public class Demo {
    public static void main(String[] args) {
        Constants c = Constants.Constants_B;
        Constants array[] = Constants.values();

        for (int i = 0; i < array.length; i++) {
            System.out.println(c + "与" + array[i] + "比较的结果为：" + c.compareTo(array[i]));
        }
    }
}

运行结果：

Constants_B与Constants_A比较的结果为：1
Constants_B与Constants_B比较的结果为：0
Constants_B与Constants_C比较的结果为：-1

在这里插入图片描述
首先，创建Enum：

public enum Constants {
    Constants_A, Constants_B, Constants_C,
}

然后创建Demo类：

public class Demo {
    public static void main(String[] args) {
        Constants array[] = Constants.values();

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i] + "在枚举类型中的索引：" + array[i].ordinal());
        }
    }
}

运行结果：

Constants_A在枚举类型中的索引：0
Constants_B在枚举类型中的索引：1
Constants_C在枚举类型中的索引：2

1.3 使用枚举类型的优势

在这里插入图片描述

2. 泛型

泛型实质上就是使程序员定义安全的类型。

2.1 回顾向上转型与向下转型

在这里插入图片描述

2.2 定义泛型类

Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值与返回的值都以Object类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在运行时将会发生ClassCastException异常。

在JDK 1.5版本以后，提出了泛型机制。其语法如下：

类名<T>

其中，T代表一个类型的名称。
在这里插入图片描述
首先创建Demo1类，并使用get和set方法：

public class Demo1 {
    Object over;

    public Object getOver() {
        return over;
    }

    public void setOver(Object over) {
        this.over = over;
    }

    public static void main(String[] args) {
        Demo1 d1 = new Demo1();
        Demo1 d2 = new Demo1();

        d1.setOver(true);
        d2.setOver(12.3F);

        boolean b = (boolean) d1.getOver();
        System.out.println(b);

        int f = (int) d2.getOver();
        System.out.println(f);
    }
}

在这里插入图片描述
运行后，抛出异常：

true
Exception i
n thread "main" java.lang.ClassCastException: class java.lang.Float cannot be cast to class java.lang.Integer (java.lang.Float and java.lang.Integer are in module java.base of loader 'bootstrap') at mr.Demo1.main(Demo1.java:24)

下面使用泛型的方法进行演示。

首先创建Demo2类：

public class Demo2<T> {
    T over;

    public T getOver() {
        return over;
    }

    public void setOver(T over) {
        this.over = over;
    }

    public static void main(String[] args) {
        Demo2<Boolean> d1 = new Demo2<Boolean>();
        d1.setOver(true);
        boolean b = d1.getOver();

        Demo2<Integer> d2 = new Demo2<>();// 第2个尖括号里面可以不填
        d2.setOver(12.3);
        int i = d2.getOver();

    }
}

可以看到，运行前Eclipse就报错了：
在这里插入图片描述