第8周 枚举 泛型 常用类(西南交大)

枚举类上用泛型枚举类是一种特殊的类，它可以定义一组固定的常量，每个常量都可以有自己的属性和方法。

然而，有时候我们可能需要在枚举类上使用泛型，以便更灵活地处理不同类型的数据。

使用泛型在枚举类上可以用于许多场景，例如在处理不同数据类型的集合时，或者为枚举常量添加不同类型的属性。

下面是一些使用泛型在枚举类上的常见参考内容：1. 泛型枚举常量的定义可以在枚举类中使用泛型来定义不同类型的枚举常量。

例如，我们可以定义一个枚举类来表示不同类型的图形：```javapublic enum Shape<T> {CIRCLE(T radius),RECTANGLE(T length, T width),TRIANGLE(T base, T height);private T[] properties;Shape(T... properties) {this.properties = properties;}public T[] getProperties() {return properties;}}```在上面的例子中，我们使用泛型 `T` 来表示图形的属性，然后在每个枚举常量中定义不同类型的属性。

这样，我们就可以在创建枚举常量时传入不同类型的属性。

2. 泛型方法的定义可以在枚举类中定义泛型方法，以处理不同类型的数据。

例如，如果我们希望枚举常量能够比较它们的属性值，我们可以定义一个泛型方法来比较属性：```javapublic enum Shape<T> {CIRCLE(T radius),RECTANGLE(T length, T width),TRIANGLE(T base, T height);private T[] properties;Shape(T... properties) {this.properties = properties;}public T[] getProperties() {return properties;}public <U extends Comparable<U>> boolean compareProperty(U property) {// 比较属性值的逻辑}}```在上面的例子中，我们在枚举类中定义了一个泛型方法`compareProperty()`，该方法使用泛型`U` 来表示属性的类型，并使用泛型约束 `U extends Comparable<U>` 来保证可以进行比较操作。

第4章枚举和泛型---6.1 枚举---6.2 泛型1 知识点1.1 上次内容1.Java异常处理1.2 习题讲解1.求int型数组元素的平均值。

（提示：存在空对象异常和除数为0等潜在错误，要求使用异常进行处理。

（参考教材128页）1.3 本次内容〖知识点〗1.枚举2.泛型〖了解〗1.枚举扩展【重点】1.泛型2.枚举〖难点〗1.泛型2.枚举2 具体内容6.1 枚举在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。

例如：星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。

在java中如何更好的使用这些“数据集”呢？因此枚举便派上了用场。

6.1.1 枚举简介在JDK 1.5之前，JA V A可以有两种方式定义新类型：类和接口。

对于大部分面向对象编程来说，这两种方法看起来似乎足够了。

但是在一些特殊情况下，这些方法就不适合。

例如，想定义一个Color类，它只能有Red、Green、Blue三种值，其他的任何值都是非法的，那么JDK 1.5之前虽然可以构造这样的代码，但是要做很多的工作，也有可能带来各种不安全的问题。

而JDK 1.5之后引入的枚举类型（Enum）就能避免这些问题。

枚举就是规定好了指定的取值范围，所有的内容只能从指定的范围中取得，也就是一个类只能产生固定的几个对象。

范例：使用定义类实现枚举操作。

范例：使用接口表示一组范围6.1.2 定义一个枚举类型在JDK 1.5之后，引入了一个新的关键字类型—— enum，可以直接定义枚举类型，格式如下：范例：定义一个Color的枚举类型。

范例：枚举操作。

6.1.3 Enum使用enum关键字可以定义一个枚举。

实际上此关键字表示的是ng.Enum类型，即：使用enum 声明的枚举类型，就相当于定义一个类，而此类默认继承ng.Enum类。

ng.Enum类的定义如下：枚举类的主要操作方法：6.1.4 取得枚举的信息枚举类的构造方法：protected Enum(String name,int ordinal);在枚举类建立完成之后，实际上都会为其调用枚举类中的构造方法，为其赋值，在Enum类的构造方法中的第一个参数name就是定义的枚举的名称，第二个参数ordinal则会从0开始依次进行编号。

第8章1.泛型、枚举和内部类一个泛型类，其泛型参数在编译期是什么类型？在编译此类时，可以不必确定此参数的具体类型，就好比一个方法的形参一样，编译时 没有值，只有在具体调用时，才有实参将值传进来。

2. 定义一个泛型参数的上界和下界有什么区别？ (1)通过使用 extends 关键字，可以限定泛型参数的类型的上界，如下面的声明：public class NumberGenericPool< T extends Number>上述方式的声明规定了 NumberGenericPool 类所能处理的参数其类型和 Number 有继承 关系，这样程序中就会利用这种关系，将 T 声明的变量视为 Number 类型，从而可以利用 Number 类型的特征进行工作，如类型转换和数值计算。

(2)定义参数的下界 通过使用 super 关键字可以固定泛型参数的类型为某种类型或者其超类，例如下面的语 句在声明一个集合时，指明集合元素的类型为 CashCard 或者他的某个超类。

List<? super CashCard> cards=new ArrayList<T>();3.一个内部类在编译之后会产生独立的字节码文件吗？如果是独立的， 其类名有什么 样的特点？对于内部类，Java 编译器也会产生一个独立的字节码文件，其字节码文件的命名方式 为“外部类名$内部类名.class” 。

创建一个 static 修饰的内部类和一个不带 static 修饰的内部类有何不同？4.对于没有 static 属性的内部类，由于 InnerClass 是 OuterClass 的内部类，因此，在需要 创建一个 InnerClass 的实例时，需要通过一个 OuterClass 的实例来创建，如上面的语句中在 new 运算符前添加了 outer 实例名，例如：OuterClass.InnerClass inner = outer.new InnerClass();具有 static 的属性 InnerClass，可以直接实例化一个对象，而无须先创建一个外部类的 对象，例如：OuterClass.InnerClass inner=new OuterClass.InnerClass();5.模仿程序 8-5，利用匿名内部类实现对 Account 数组进行按照属性 id 的大小进行排 序。

C语言定义枚举类型1. 什么是枚举类型在C语言中，枚举类型是一种用户自定义的数据类型，用于定义一组具有相同类型的常数。

枚举类型允许我们为常见的取值范围定义一个有意义的名字，从而提高代码的可读性和可维护性。

2. 枚举类型的定义枚举类型的定义使用关键字enum，后面跟着枚举类型的名称，然后是一对大括号{}，括号内是枚举常量的列表。

enum枚举类型名称 {枚举常量1,枚举常量2,...};3. 枚举常量的定义枚举常量是枚举类型中的每个取值，可以是整数、字符或浮点数。

默认情况下，第一个枚举常量的值为0，后续的枚举常量的值依次递增。

enum Weekday {MON,TUE,WED,THU,FRI,SAT,SUN};在上面的例子中，我们定义了一个名为Weekday的枚举类型，并定义了七个枚举常量，分别代表一周的每一天。

4. 枚举类型的使用4.1 声明枚举变量要声明一个枚举变量，需要使用枚举类型名称，后面跟着变量名称。

enum Weekday today;上面的代码声明了一个名为today的枚举变量，它的类型是Weekday。

4.2 给枚举变量赋值要给枚举变量赋值，可以使用枚举常量的名称。

today = MON;上面的代码将枚举变量today赋值为MON，即星期一。

4.3 使用枚举变量可以像使用其他类型的变量一样使用枚举变量。

if (today == SAT || today == SUN) {printf("It's the weekend!\n");} else {printf("It's a weekday.\n");}上面的代码根据枚举变量today的值输出不同的消息。

5. 枚举常量的值5.1 默认值如果没有给枚举常量赋值，那么它的值将会自动递增。

enum Numbers {ONE,TWO,THREE};在上面的例子中，枚举常量ONE的值为0，TWO的值为1，THREE的值为2。

枚举类上用泛型枚举类是一种特殊类型的类，在Java中，可以看作是一组固定的常量集合。

使用枚举类可以为代码增加可读性，让代码更加易于理解和维护。

Java SE 5以后的版本中，Java引入了泛型概念，这也使得枚举类的使用更加灵活。

在枚举类上使用泛型可以让我们更加精确地定义枚举类型，避免类型转换错误和不必要的代码，提高程序的可读性和可维护性。

一般来说，我们可以在定义枚举类时使用泛型，也可以在枚举类的方法中使用泛型。

在定义枚举类时使用泛型的时候，需要在枚举名后面加上泛型类型。

例如：```public enum Color<T> {RED("Red"),GREEN("Green"),BLUE("Blue");private String label;private Color(String label){bel = label;}public String getLabel(){return bel;}}```在上面的代码中，枚举类的名字是Color，我们使用了泛型类型T，通过T来定义枚举的类型。

在枚举常量中，我们可以通过构造函数来传入对应的枚举类型。

在枚举类的方法中使用泛型同样很常见，这样可以让我们更加灵活地处理枚举类型。

例如，我们可以编写一个方法，接收任意类型的枚举，并按照字母顺序输出：```public static <T extends Enum<T>> voidprintEnumValues(Class<T> enumClass){for(T enumValue : enumClass.getEnumConstants()){System.out.println(enumValue.toString());}}```上面的代码中，我们使用了泛型类型T，并通过Class对象来获取对应的枚举常量。

枚举得泛型上限摘要：1.枚举得泛型的概念2.枚举得泛型的应用场景3.枚举得泛型的局限性4.如何解决枚举得泛型的问题5.总结正文：1.枚举得泛型的概念枚举得泛型是一种在编程中常用的数据类型，它可以让我们在编译时检查数据的合法性。

通过预先定义一组具有代表性的数据，我们可以将这组数据作为模板来生成其他合法的数据。

这种数据类型在某些场景下可以极大地提高程序的健壮性，降低出错的概率。

2.枚举得泛型的应用场景枚举得泛型在许多编程语言中都有应用，例如C++、Java 等。

它主要应用于以下场景：- 状态管理：通过枚举得泛型可以方便地表示一个对象的状态，例如表示一个按钮的状态（按下、弹起等）。

- 错误处理：通过枚举得泛型可以定义一组错误码，方便程序员处理各种错误情况。

- 数据类型限制：枚举得泛型可以限制数据的取值范围，提高程序的健壮性。

3.枚举得泛型的局限性尽管枚举得泛型在某些场景下非常有用，但它也存在一些局限性：- 数据量过大时，枚举得泛型的维护成本会显著增加。

- 当需要添加新的数据时，可能需要修改已有的代码，违反了“开闭原则”。

- 枚举得泛型无法表示一些复杂的数据关系，例如树形结构等。

4.如何解决枚举得泛型的问题为了解决枚举得泛型的局限性，我们可以采取以下方法：- 使用预处理器：预处理器可以在编译前对代码进行处理，降低枚举得泛型的维护成本。

- 使用实体类：通过定义实体类来表示枚举得泛型，可以提高代码的可扩展性和可维护性。

- 使用其他数据结构：在合适的场景下，可以考虑使用其他数据结构，如结构体、类等，来代替枚举得泛型。

5.总结枚举得泛型是一种在编程中常用的数据类型，它可以提高程序的健壮性，降低出错的概率。

然而，它也存在一些局限性，如数据量过大时的维护成本、新增数据时的代码修改等。

详解Java中的枚举与泛型详解Java中的枚举与泛型⼀：⾸先从枚举开始说起枚举类型是JDK5.0的新特征。

Sun引进了⼀个全新的关键字enum来定义⼀个枚举类。

下⾯就是⼀个典型枚举类型的定义：public enum Color{RED，BLUE，BLACK，YELLOW，GREEN} 显然，enum很像特殊的class，实际上enum声明定义的类型就是⼀个类。

⽽这些类都是类库中Enum类的⼦类（ng.Enum）。

它们继承了这个Enum中的许多有⽤的⽅法。

我们对代码编译之后发现，编译器将 enum类型单独编译成了⼀个字节码⽂件：Color.class。

Color字节码代码final enum hr.test.Color {// 所有的枚举值都是类静态常量public static final enum hr.test.Color RED;public static final enum hr.test.Color BLUE;public static final enum hr.test.Color BLACK;public static final enum hr.test.Color YELLOW;public static final enum hr.test.Color GREEN;private static final synthetic hr.test.Color［］ ENUM$VALUES;}下⾯我们就详细介绍enum定义的枚举类的特征及其⽤法。

（后⾯均⽤Color举例）1、Color枚举类就是class，⽽且是⼀个不可以被继承的final类。

其枚举值（RED，BLUE.。

.）都是Color类型的类静态常量，我们可以通过下⾯的⽅式来得到Color枚举类的⼀个实例：Color c=Color.RED;注意：这些枚举值都是public static final的，也就是我们经常所定义的常量⽅式，因此枚举类中的枚举值最好全部⼤写。

规范必备：枚举类型1、这是个啥？ 枚举类型在C#或C++,java,VB等⼀些计算机编程语⾔中是⼀种基本数据类型⽽不是构造数据类型，⽽在C语⾔等计算机编程语⾔中是⼀种构造数据类型，它⽤于声明⼀组命名的常数，当⼀个变量有⼏种可能的取值时，可以将它定义为枚举类型。

枚举可以根据Integer、Long、Short或Byte中的任意⼀种数据类型来创建⼀种新型变量。

这种变量能设置为已经定义的⼀组之中的⼀个，有效地防⽌⽤户提供⽆效值。

该变量可使代码更加清晰，因为它可以描述特定的值。

2、单独建⼀个类定义枚举类型，代码：package mon.util;@Name("EnumerationTypeConstant")@Scope(ScopeType.EVENT)public class EnumerationTypeConstant {/*** 1和0常量*/public static final String CONSTANT_STR_ONE = "1";public static final String CONSTANT_STR_ZERO = "0";public static final int CONSTANT_INT_ONE = 1;public static final int CONSTANT_INT_ZERO = 0;/*** 事件状态*/public static final int SHIJIAN_STATUS_DTJ = 8;// 事件待提交public static final int SHIJIAN_STATUS_YTJ = 10;// 事件已提交public static final int SHIJIAN_STATUS_SHTG = 12;// 事件审核通过public static final int SHIJIAN_STATUS_TH = 14;// 事件退回}3、定义成员变量时为啥是public static final修饰？public: 其他模块的其他类都可以调⽤使⽤这个常量static：static修饰就表⽰它属于类的，随类的加载⽽存在的，如果是⾮static的话， 就表⽰属于对象的，只有建⽴对象时才有它，final：final修饰就是保证不能被实现类去修改，如果没有final的话， 由⼦类随意去修改的话，建⽴这个常量就没有意义了，就⼜不规范了！代码不规范，同事两⾏泪；。

枚举和泛型枚举： ⽼师给我们讲过⼀句话，枚举类型的作⽤就是使程序更加接近⾃然语⾔。

在java1.5之前都是将常量设置为final static类型，在java1.5之后，出现了枚举类型，通常将常量设置为枚举常量。

1//定义⼀个枚举2public enum Sex {3 FEMALE,MALE;4 }5//定义学⽣类，学⽣类性别⽤枚举类型6public class Student {7private String name;8//定义枚举类型变量9private Sex sex;10public String getName() {11return name;12 }13public void setName(String name) { = name;15 }16public Sex getSex() {17return sex;18 }19public void setSex(Sex sex) {20this.sex = sex;21 }22 }23//调⽤枚举变量24public class Test {2526public static void main(String[] args) {27 Student zhangsan = new Student();28//为性别赋值，性别值必须为枚举常量，若赋其他值则报错。

29 zhangsan.setSex(Sex.FEMALE);30 }31 }泛型： 泛型的出现时为了解决多态中向上转型和向下转型出现的错误。

⼀般情况下向上转型不会出现错误，但是向下转型如果忘记⽽忽略就会出现异常，这个异常在编译时是不会出现的，但是在运⾏时则会出现ClassCastException异常。

1类名<T>2 类名<T, E extends F>1//定义宠物类2public class Pet {3 }4//定义猫类继承宠物类5public class Cat extends Pet{6 }7//定义狗类继承宠物类8public class Dog extends Pet {9 }10//定义男⼠⾐服11public class ManCloth {12 }13//定义⼥⼠⾐服14public class WomanColth {15 }16//定义学⽣类17public class Student<T, E extends Pet> {18private String name;19//定义⾐服类型为泛型。

枚举类上用泛型枚举类是一种特殊的类，它限定了一个对象只能有有限个可能的值。

在Java中，枚举类被用于表示一组常量。

然而，有时候我们希望枚举类能够具有更灵活的使用方式，例如使用不同类型的值作为枚举常量的属性。

这时，我们可以在枚举类上使用泛型来实现这种灵活性。

使用泛型可以让我们在定义枚举常量时，指定不同类型的属性。

通过在枚举类名字后面加上尖括号并指定类型参数，我们可以在枚举类中使用该类型参数。

例如，下面是一个使用泛型的枚举类的示例：```javaenum Color<T> {RED("红色", 1, true),GREEN("绿色", 2, false),BLUE("蓝色", 3, true);private String name;private T value;private boolean active;Color(String name, T value, boolean active) { = name;this.value = value;this.active = active;}public String getName() {return name;}public T getValue() {return value;}public boolean isActive() {return active;}}```在上述示例中，枚举类`Color`使用了一个泛型类型参数`T`。

每个枚举常量都有一个`value`属性，类型为`T`，它可以被用来存储不同类型的值。

例如，当我们使用`Color.RED.getValue()`访问红色枚举常量的值时，返回的类型将会是`Integer`，因为我们在创建枚举常量时指定了`value`的类型为`Integer`。

通过使用泛型，我们可以很方便地在枚举类中定义任意类型的属性，并且在创建枚举常量时，为这些属性指定不同的值。

枚举类上用泛型枚举是Java中一种很特殊的数据类型。

它代表一组有限的常量，通常被用来表示一些具有固定集合的值。

在大多数情况下，使用枚举类的方式也越来越多。

在Java5中，引入了泛型机制，使得我们可以将泛型用于枚举类中，这也为我们带来了更多的代码抽象和灵活性。

枚举和泛型的基础知识在Java中，枚举的定义基本格式如下：```javapublic enum EnumName {ENUM_CONSTANT_1,ENUM_CONSTANT_2,ENUM_CONSTANT_3,// ...}```其中，每个枚举常量都通过逗号分隔开来，它们以大写字母的形式表示，中间可以有下划线。

当我们需要使用枚举常量时，可以直接使用EnumName.ENUM_CONSTANT_1这样的形式进行访问。

泛型则是一种将类型参数化的机制。

可以在类中定义一个类型参数，这个参数在实例化时才被确定其类型。

例如定义一个泛型类：```javapublic class MyClass<T> {private T value;// ...}```在创建实例时，我们可以指定类型参数的类型：```javaMyClass<String> classWithStringValue = new MyClass<>();```这样，classWithStringValue变量就是一个MyClass类的实例，它的类型参数为String。

枚举类中使用泛型在某些情况下，我们需要在枚举中为每个常量定义不同的值，这时我们就可以在枚举的定义中使用构造器和实例字段。

例如：```javapublic enum DayOfWeek {MONDAY(1),TUESDAY(2),WEDNESDAY(3),THURSDAY(4),FRIDAY(5),SATURDAY(6),SUNDAY(7);private int value;private DayOfWeek(int value) {this.value = value;}public int getValue() {return value;}}```在这个例子中，我们为每个星期日定义了一个值。

c语言枚举类型C语言枚举类型（EnumerationTypes）是C语言中最常用的数据类型之一，它可以将一系列值赋予变量。

它的定义方式为：enum号{变量1,变量2,…变量n};一般情况下，枚举变量的值从0开始，每个变量加1，例如： enum color {red, green, blue, purple};这样，每个枚举变量的值分别为0，1，2，3。

枚举类型变量也可以赋值，例如：enum color {red=2, green, blue, purple};这样，枚举变量的值分别为2，3，4，5。

C语言的枚举类型可以应用在不同的场合，它可以有效地管理和控制特定范围内的变量。

它可以让人们更容易地理解代码，同时也可以提升代码的可读性。

例如，C语言的枚举可以用在星期的表示中：enum week{Mon=1,Tue,Wed,Thu,Fri,Sat,Sun};然后，通过索引值就可以得到对应的星期，比如Tue=2，表示星期二。

此外，C语言枚举变量还可以用作布尔类型：enum boolean {FALSE, TRUE};布尔类型可以用于流程控制语句，例如if-else等，枚举变量可以代表真假两种状态：enum boolean {FALSE, TRUE};enum boolean flag;flag = FALSE;if (flag == TRUE){printf(flag is TRUE} else {printf(flag is FALSE}return 0;}C语言的枚举类型也可以用于字符串的输出，例如：enum string{STR1,STR2,STR3};const char *STRING_ARRAY[3] = {string1string2string3}; int main(){enum string str;str = STR2;printf(%sSTRING_ARRAY[str]); //输出string2return 0;}最后，C语言的枚举类型可以用于定义枚举结构，例如：enum color {red, green, blue, purple};int x;int y;enum color c;};int main(){struct Point point;point.x = 0;point.y = 0;point.c = red;printf(Point: x = %d, y = %d, color = %dpoint.x,point.y,point.c);return 0;}以上介绍了C语言枚举类型的基本用法，可以看出它的强大功能。

泛型（generic）无处不在1.为什么需要泛型：避免成员膨胀或者类型膨胀2.泛化数据类型using System;namespace HelloGeneric {class Program {static void Main(string[] args) {Apple apple = new Apple() { Color = "Red" };Book book = new Book() { Name = "New Book" };Box<Apple> box1 = new Box<Apple>() { Cargo = apple }; Box<Book> box2 = new Box<Book>() { Cargo = book }; Console.WriteLine(box1.Cargo.Color);Console.WriteLine();}}class Apple {public string Color { get; set; }}class Book {public string Name { get; set; }}class Box<TCargo> {public TCargo Cargo { get; set; }}}泛型接口using System;namespace HelloGeneric2 {internal class Program {public static void Main(string[] args) {Student stu = new Student();stu.ID = 101; = "Wy";}}interface IUnique<TId> {TId ID { get; set; }}class Student:IUnique<ulong> {public ulong ID { get ; set ; }public string Name { get; set; }}}泛型具有良好的正交性，在.NET Framework中几乎所有常用的数据结构都是泛型的。

泛型枚举方法在编程中，泛型是一种强大的工具，它允许我们在编写代码时使用未知的数据类型。

而枚举则是一种常见的数据类型，用于定义一组有限的可能值。

那么，泛型枚举方法又是什么呢？本文将介绍泛型枚举方法的概念、用法和示例，希望对读者有所帮助。

一、概念泛型枚举方法是指在枚举类型中使用泛型来定义方法的一种技术。

通常情况下，枚举类型的方法是针对特定数据类型进行操作的，而泛型枚举方法可以适用于多种数据类型，提高了代码的灵活性和复用性。

二、用法在定义泛型枚举方法时，需要在方法名之前加上泛型参数，并在方法体中使用该泛型参数进行操作。

泛型参数可以是任意合法的标识符，通常使用大写字母开头的单词表示。

例如，我们定义了一个名为Color的枚举类型，并在其中定义了一个泛型方法getValue，用于获取枚举值对应的数值：```enum Color {RED(0xFF0000),GREEN(0x00FF00),BLUE(0x0000FF);private int value;private <T> T getValue() {return (T) value;}Color(int value) {this.value = value;}}```在上述代码中，枚举类型Color中定义了三个枚举值：RED、GREEN 和BLUE，并为每个枚举值指定了一个整数值。

同时，我们在Color 中定义了一个泛型方法getValue，返回枚举值对应的数值。

在该方法中，我们使用了泛型参数T来表示方法的返回类型，并通过强制类型转换将int类型的value转换为T类型。

三、示例为了更好地理解泛型枚举方法的用法，下面我们通过一个示例来演示它的使用。

假设我们需要定义一个枚举类型Size，用于表示尺寸大小，同时需要为每个尺寸大小指定一个单位。

我们可以使用泛型枚举方法来实现这个需求。

我们定义一个名为Size的枚举类型，并在其中定义了一个泛型方法getUnit，用于获取枚举值对应的单位：```enum Size {SMALL("cm"),MEDIUM("inch"),LARGE("m");private String unit;private <T> T getUnit() {return (T) unit;}Size(String unit) {this.unit = unit;}}```在上述代码中，枚举类型Size中定义了三个枚举值：SMALL、MEDIUM和LARGE，并为每个枚举值指定了一个单位。