Java枚举(enum)-蒲公英云

在这里插入图片描述

?wei_shuo的个人主页

?wei_shuo的学习社区

?Hello World ！

Java 枚举(enum)

Java中的枚举类是一种特殊的类，它用于定义一组具有固定值的常量；枚举类在Java中是一种更好的替代方案，可以代替使用整数或字符串表示的固定值

public enum Day {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
}

内部类枚举

public class Test
{
    enum Color
    {
        RED, GREEN, BLUE;
    }
    // 执行输出结果
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

迭代枚举元素

enum Color
{
    RED, GREEN, BLUE;
}
public class MyClass {
  public static void main(String[] args) {
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  }
}

switch 中使用枚举类

enum Color
{
    RED, GREEN, BLUE;
}
public class MyClass {
  public static void main(String[] args) {
    Color myVar = Color.BLUE;
    switch(myVar) {
      case RED:
        System.out.println("红色");
        break;
      case GREEN:
         System.out.println("绿色");
        break;
      case BLUE:
        System.out.println("蓝色");
        break;
    }
  }
}

枚举类方法

values() ：返回枚举类中所有的值
ordinal()：找到每个枚举常量的索引，像数组索引一样
valueOf()：返回指定字符串值的枚举常量

enum Color
{
    RED, GREEN, BLUE;
}
public class Test
{
    public static void main(String[] args)
    {
        // 调用 values()
        Color[] arr = Color.values();
        // 迭代枚举
        for (Color col : arr)
        {
            // 查看索引
            System.out.println(col + " at index " + col.ordinal());
        }
        // 使用 valueOf() 返回枚举常量，不存在的会报错 IllegalArgumentException
        System.out.println(Color.valueOf("RED"));
        // System.out.println(Color.valueOf("WHITE"));
    }
}

枚举类成员

枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用

枚举既可以包含具体方法，也可以包含抽象方法；如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它

enum Color
{
    RED, GREEN, BLUE;
    // 构造函数
    private Color()
    {
        System.out.println("Constructor called for : " + this.toString());
    }
    public void colorInfo()
    {
        System.out.println("Universal Color");
    }
}
public class Test
{
    // 输出
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}

Java 泛型（Generics）

Java中的泛型（Generics）是一种在编译时提供类型安全的机制，允许在定义类、接口或方法时使用参数化类型

泛型方法

定义泛型方法：在方法的返回类型之前使用尖括号<>来声明一个或多个类型参数；例如，<T>表示一个泛型方法，其中的T是类型参数
使用类型参数：在方法的参数列表、返回类型或方法体中可以使用类型参数；类型参数可以用作参数的类型、返回类型或局部变量的类型
类型推断：Java编译器通常可以根据上下文推断泛型方法的类型参数。这意味着在某些情况下，可以省略类型参数的显式声明

E - Element (在集合中使用，因为集合中存放的是元素)

T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 Java 类型

public class GenericMethodExample {
    public static <T> boolean isEqual(T obj1, T obj2) {
        return obj1.equals(obj2);
    }
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        boolean isEqualStrings = isEqual(str1, str2);
        System.out.println("Are the strings equal? " + isEqualStrings);
        Integer num1 = 10;
        Integer num2 = 20;
        boolean isEqualNumbers = isEqual(num1, num2);
        System.out.println("Are the numbers equal? " + isEqualNumbers);
    }
}

泛型类

泛型类（Generic Class）指在类定义中使用泛型类型参数的类；它可以接受不同类型的参数化类型，并在类内部使用这些参数化类型来定义字段、方法和其他成员

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;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public void setSecond(U second) {
        this.second = second;
    }
    public static void main(String[] args) {
        Pair<String, Integer> pair1 = new Pair<>("Hello", 42);
        System.out.println("First: " + pair1.getFirst());
        System.out.println("Second: " + pair1.getSecond());
        Pair<Double, String> pair2 = new Pair<>(3.14, "World");
        System.out.println("First: " + pair2.getFirst());
        System.out.println("Second: " + pair2.getSecond());
    }
}

类型通配符

类型通配符（Wildcard）是Java泛型中的一种特殊语法，用于表示未知类型或限定类型范围；通配符使用?符号表示，并可以与泛型类、泛型方法和通配符上限等结合使用

import java.util.ArrayList;
import java.util.List;
public class TypeWildcardExample {
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);
        integerList.add(3);
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");
        System.out.println("Printing integerList:");
        printList(integerList);
        System.out.println("Printing stringList:");
        printList(stringList);
    }
}