Java 枚举类型与泛型-第13章

1.枚举类型

枚举类型是一种特殊的数据类型，用于表示一组有限的命名常量。枚举类型可以帮助您更清晰地定义和管理相关常量，并提供类型安全性。

1.1使用枚举类型设置常量

枚举类型是一种非常方便的方式来设置常量。我们可以创建一个枚举类型，其中包含需要的常量，然后在代码中使用这些常量。以下是如何使用枚举类型来设置常量的示例：

public class ConstantsExample {// 定义一个枚举类型来表示颜色常量enum Color {RED, GREEN, BLUE}public static void main(String[] args) {// 使用枚举常量Color myColor = Color.BLUE;System.out.println("我的颜色是：" + myColor);// 使用switch语句根据不同的颜色执行不同的操作switch (myColor) {case RED:System.out.println("我喜欢红色！");break;case GREEN:System.out.println("绿色也不错！");break;case BLUE:System.out.println("蓝色是我的最爱！");break;default:System.out.println("我不确定我的颜色是什么。");}}
}

在上述示例中，我们首先定义了一个名为Color的枚举类型，其中包含了三个颜色常量：RED、GREEN和BLUE。然后，我们在main方法中使用枚举常量Color.BLUE来表示颜色，以及使用switch语句根据不同的颜色执行不同的操作。

枚举类型使得代码更具可读性和可维护性，因为它将相关的常量组织在一起，并提供了一种类型安全的方式来处理它们。这在需要使用常量的情况下非常有用，因为它可以减少错误和提高代码的清晰度。

1.2深入了解枚举类型

1.枚举类型的常用方法

枚举类型在Java中有一些常用的方法，这些方法使得操作和管理枚举常量更加方便。以下是一些常用的枚举类型方法：

1. values(): 这个方法返回枚举类型的常量数组，允许您遍历所有的枚举常量。例如：Season.values()将返回包含所有季节的Season[]数组。
2. valueOf(String name): 这个方法返回与给定名称匹配的枚举常量。通常用于将字符串转换为枚举常量。例如：Season.valueOf("SUMMER")将返回Season.SUMMER。
3. name(): 这个方法返回枚举常量的名称作为字符串。例如：Season.SUMMER.name()将返回字符串 “SUMMER”。
4. ordinal(): 这个方法返回枚举常量在枚举类型中的位置（从0开始）。例如：Season.SUMMER.ordinal()将返回2，因为它是Season枚举中的第三个常量。

这些方法可以帮助我们在处理枚举类型时执行各种操作，如遍历常量、根据名称查找常量或获取常量的位置。以下是一个示例：

public class EnumMethodsExample {enum Day {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}public static void main(String[] args) {// 使用values方法遍历所有常量Day[] days = Day.values();for (Day day : days) {System.out.println("Day: " + day.name() + ", Ordinal: " + day.ordinal());}// 使用valueOf方法根据名称查找常量Day tuesday = Day.valueOf("TUESDAY");System.out.println("Tuesday is " + tuesday);// 使用name方法获取常量的名称String fridayName = Day.FRIDAY.name();System.out.println("Friday's name is " + fridayName);}
}

上示例演示了如何使用这些常用的枚举方法来操作枚举常量。这些方法使得在处理枚举类型时更加便捷和有用。

2.枚举类型中的构造方法

枚举类型可以具有自定义构造方法，但这些构造方法在使用时有一些限制和特殊的用法。通常情况下，枚举类型的构造方法应该是私有的，以确保只有枚举常量内部可以调用它们。

以下是一个示例，演示如何在枚举类型中定义和使用构造方法：

enum Color {RED(255, 0, 0), // 枚举常量，每个常量都可以传入参数GREEN(0, 255, 0),BLUE(0, 0, 255);// 枚举类型的构造方法private int red;private int green;private int blue;private Color(int red, int green, int blue) {this.red = red;this.green = green;this.blue = blue;}public int getRed() {return red;}public int getGreen() {return green;}public int getBlue() {return blue;}
}public class EnumConstructorExample {public static void main(String[] args) {Color myColor = Color.RED;System.out.println("My color is " + myColor);System.out.println("Red: " + myColor.getRed() + ", Green: " + myColor.getGreen() + ", Blue: " + myColor.getBlue());}
}

在上述示例中，我们定义了一个名为Color的枚举类型，其中包含了三个颜色常量：RED、GREEN和BLUE。每个常量都有一个构造方法，用于初始化red、green和blue成员变量。这些构造方法是私有的，只能在枚举内部访问。我们还定义了getter方法来获取颜色的RGB值。

当我们使用枚举常量时，可以看到它们的构造方法被调用，并且可以使用getter方法来获取颜色的RGB值。这样，枚举类型允许您将自定义数据与每个枚举常量相关联。

需要注意，枚举类型的构造方法在定义时是私有的，并且只能在枚举内部使用。这是因为枚举常量通常在定义时就被实例化，所以不允许外部代码创建新的枚举常量。

2.泛型

回顾向上转型与向下转型

泛型是一种Java编程语言的特性，它允许您编写通用的、类型安全的代码，以便在不同的数据类型上工作。泛型允许您在编写类、接口和方法时使用类型参数，这样您可以编写一次代码，然后在多种数据类型上重复使用，而不必为每种数据类型都编写新的代码。

2.1定义泛型类

要定义一个泛型类，我们需要在类名后面添加类型参数，并在类的内部使用这个类型参数来代表泛型类型。以下是一个简单的泛型类的示例：

public class MyGenericClass<T> {private T data;public MyGenericClass(T data) {this.data = data;}public T getData() {return data;}
}

在上述示例中，MyGenericClass 是一个泛型类，它具有一个类型参数 <T>，该参数代表一个泛型类型。构造方法 MyGenericClass(T data) 接受一个泛型类型的参数，并将其存储在私有成员变量 data 中。getData 方法返回存储在 data 中的泛型数据。

还可以在创建泛型类的实例时指定具体的数据类型。例如：

MyGenericClass<Integer> integerGeneric = new MyGenericClass<>(42);
int intValue = integerGeneric.getData();
System.out.println("Integer Value: " + intValue);MyGenericClass<String> stringGeneric = new MyGenericClass<>("Hello, Generics!");
String stringValue = stringGeneric.getData();
System.out.println("String Value: " + stringValue);

在上述示例中，我们创建了两个 MyGenericClass 的实例，一个使用整数类型 (Integer)，另一个使用字符串类型 (String) 作为泛型类型。这允许我们在不同的数据类型上使用相同的泛型类，提高了代码的重用性和类型安全性。

2.2泛型的常规用法

泛型在Java中有许多常规用法，它们有助于提高代码的可读性、类型安全性和重用性。以下是一些常见的泛型用法：

1. 集合类使用泛型：Java标准库中的集合类如ArrayList、HashMap等都使用泛型来存储元素，以确保集合中的元素是一种特定类型。这提供了类型安全性，避免了在编译时和运行时出现不合适的数据类型。

   List<String> stringList = new ArrayList<>();
   Map<Integer, String> intToStringMap = new HashMap<>();
   

2. 自定义数据结构：您可以创建自定义的泛型数据结构，以便处理不同类型的数据。

   public class Pair<T, U> {private T first;private U second;public Pair(T first, U second) {this.first = first;this.second = second;}public T getFirst() {return first;}public U getSecond() {return second;}
   }
   

3. 泛型方法：您可以创建泛型方法，以便在方法内部使用类型参数。

   public <T> T findMax(T[] array) {T max = array[0];for (T element : array) {if (element.compareTo(max) > 0) {max = element;}}return max;
   }
   

4. 通配符和限定通配符：通配符允许您编写灵活的代码，接受不确定的泛型类型，而限定通配符允许您指定通配符类型的范围。

   public void printList(List<?> list) {for (Object element : list) {System.out.print(element + " ");}
   }public double sumOfNumbers(List<? extends Number> numbers) {double sum = 0;for (Number number : numbers) {sum += number.doubleValue();}return sum;
   }
   

5. 泛型接口：您可以创建泛型接口，定义接口中的方法，这些方法可以在不同的实现中使用不同的泛型类型。

   interface ListConverter<T> {List<T> convertToList(T[] array);
   }
   

2.3泛型的高级用法

泛型在Java中有许多高级用法，允许更高度的抽象和灵活性。以下是一些常见的高级泛型用法：

1. 泛型通配符的上下界：通过使用通配符 ? 可以创建更灵活的泛型方法和类。通配符可以指定上限和下限，以便更精确地控制参数的类型。

   • 上限通配符 <? extends T>：表示通配符的类型必须是 T 类型或其子类型。
   • 下限通配符 <? super T>：表示通配符的类型必须是 T 类型或其父类型。

   public double sumOfNumbers(List<? extends Number> numbers) {double sum = 0;for (Number number : numbers) {sum += number.doubleValue();}return sum;
   }public void addIntegers(List<? super Integer> list, int[] integers) {for (int num : integers) {list.add(num);}
   }
   

2. 泛型通配符捕获：有时需要捕获通配符的类型以在方法内部使用。这可以通过将通配符类型存储在一个变量中来实现。

   public static <T> void copy(List<? extends T> source, List<T> destination) {for (T item : source) {destination.add(item);}
   }
   

3. 泛型擦除和反射：在Java中，泛型信息在运行时被擦除，这会导致一些限制。但是，您可以使用反射来获取泛型类型信息。

   Class<?> clazz = myGenericInstance.getClass();
   Type type = clazz.getGenericSuperclass();
   if (type instanceof ParameterizedType) {ParameterizedType paramType = (ParameterizedType) type;Type[] typeArgs = paramType.getActualTypeArguments();Class<?> genericType = (Class<?>) typeArgs[0];System.out.println("Generic type: " + genericType.getName());
   }
   

4. 泛型方法的类型推断：从Java 7开始，编译器可以推断泛型方法的类型参数，无需显式指定。

   public static <T> T getFirst(List<T> list) {return list.get(0);
   }List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
   Integer first = getFirst(integers); // 编译器可以推断类型参数
   

5. 泛型枚举：从Java 5开始，可以将泛型用于枚举，使得每个枚举常量可以有不同的类型参数。

   enum Result<T> {SUCCESS, FAILURE;private T value;public T getValue() {return value;}public void setValue(T value) {this.value = value;}
   }
   

5. **泛型枚举**：从Java 5开始，可以将泛型用于枚举，使得每个枚举常量可以有不同的类型参数。

enum Result {
SUCCESS, FAILURE;

   private T value;public T getValue() {return value;}public void setValue(T value) {this.value = value;}