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

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 {
    private T data;

    public MyGenericClass(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

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

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

MyGenericClass integerGeneric = new MyGenericClass<>(42);
int intValue = integerGeneric.getData();
System.out.println("Integer Value: " + intValue);

MyGenericClass 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 stringList = new ArrayList<>();
   Map intToStringMap = new HashMap<>();
   

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

   public class Pair {
       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 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 numbers) {
       double sum = 0;
       for (Number number : numbers) {
           sum += number.doubleValue();
       }
       return sum;
   }
   

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

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

2.3泛型的高级用法

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

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

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

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

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

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

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

   enum Result {
       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;
   }