枚举和注解_17

枚举类

枚举类（Enum Class）是Java中一种特殊的类，用于定义一组固定的常量。枚举类在Java 5中引入，它提供了一种更安全、更灵活的方式来定义常量，并且可以包含方法、字段和构造函数。枚举类的每个常量都是枚举类的一个实例

枚举类的定义

枚举类使用enum关键字定义，枚举常量通常用大写字母表示，多个常量之间用逗号分隔

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

其中Day是一个枚举类。SUNDAY, MONDAY, ..., SATURDAY是Day枚举类的常量

枚举类的特点

每个枚举常量都是枚举类的一个实例，枚举类在加载时会自动创建这些实例

枚举类可以像普通类一样包含字段、方法和构造函数。枚举常量可以调用这些方法和访问这些字段

public enum Day {
    SUNDAY("Sun"), MONDAY("Mon"), TUESDAY("Tue"), WEDNESDAY("Wed"),
    THURSDAY("Thu"), FRIDAY("Fri"), SATURDAY("Sat");

    private String abbreviation;

    // 构造函数
    private Day(String abbreviation) {
        this.abbreviation = abbreviation;
    }

    // 方法
    public String getAbbreviation() {
        return abbreviation;
    }
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is " + today + ", abbreviation: " + today.getAbbreviation());
        // 输出: Today is MONDAY, abbreviation: Mon
    }
}

枚举类默认是final的，因此不能被继承。但是，枚举类可以实现接口
枚举类默认继承java.lang.Enum类，所以sout输出枚举类默认输出该枚举类的名称（比如MONDAY）

枚举类可以实现一个或多个接口，并且每个枚举常量可以实现接口的方法

public interface Animal {
    void makeSound();
}

public enum AnimalType implements Animal {
    DOG {
        @Override
        public void makeSound() {
            System.out.println("Woof!");
        }
    },
    CAT {
        @Override
        public void makeSound() {
            System.out.println("Meow!");
        }
    }
    // 可以添加其他方法或字段
}

也可以在枚举类的内部实现重写方法

public interface Animal {
    void makeSound();
}

public enum AnimalType implements Animal {
    DOG,
    CAT;

    // 通用的 makeSound 方法
    @Override
    public void makeSound() {
        switch (this) {
            case DOG:
                System.out.println("Woof!");
                break;
            case CAT:
                System.out.println("Meow!");
                break;
            default:
                throw new AssertionError("Unknown animal: " + this);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        AnimalType.DOG.makeSound();  // 输出: Woof!
        AnimalType.CAT.makeSound();  // 输出: Meow!
    }
}

枚举类中可以直接声明抽象方法，无需显式添加 abstract 关键字到类定义上

public enum Operation {
    PLUS {
        @Override public double eval(double x, double y) { return x + y; }
    },
    MINUS {
        @Override public double eval(double x, double y) { return x - y; }
    };
    // 抽象方法声明 
    public abstract double eval(double x, double y);
}

枚举类的常用方法

Java中的枚举类（enum）本质上是一个特殊的类，它继承自java.lang.Enum类。java.lang.Enum是一个抽象类，它为所有枚举类提供了基础实现。枚举类的这些常用方法（如name()、ordinal()、valueOf()等）都是在java.lang.Enum中定义的

values() 方法

values() 方法是枚举类隐式提供的一个静态方法，它返回一个包含所有枚举常量的数组

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

public class Main {
    public static void main(String[] args) {
        // 使用 values() 方法获取所有枚举常量
        Day[] days = Day.values();
        for (Day day : days) {
            System.out.println(day);
        }
        // 输出:
        // SUNDAY
        // MONDAY
        // TUESDAY
        // WEDNESDAY
        // THURSDAY
        // FRIDAY
        // SATURDAY
    }
}

valueOf(String name) 方法

valueOf(String name) 方法是一个静态方法，用于根据枚举常量的名称获取对应的枚举常量。如果指定的名称与枚举常量不匹配，会抛出IllegalArgumentException

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

public class Main {
    public static void main(String[] args) {
        // 使用 valueOf() 方法获取枚举常量
        Day day = Day.valueOf("MONDAY");
        System.out.println("Today is " + day);  // 输出: Today is MONDAY
    }
}

name() 方法

name() 方法返回枚举常量的名称（即定义时的名称），返回值类型为String

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

public class Main {
    public static void main(String[] args) {
        Day day = Day.MONDAY;
        System.out.println("Today is " + day.name());  // 输出: Today is MONDAY
    }
}

ordinal() 方法

ordinal() 方法返回枚举常量在枚举类中的序号（从0开始）。序号是根据枚举常量定义的顺序决定的

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

public class Main {
    public static void main(String[] args) {
        Day day = Day.WEDNESDAY;
        System.out.println("Ordinal of WEDNESDAY: " + day.ordinal());  // 输出: Ordinal of WEDNESDAY: 3
    }
}

toString() 方法
- toString() 方法返回枚举常量的名称（与name()方法类似），但可以被重写以返回自定义的字符串表示。
compareTo(E o) 方法
- compareTo(E o) 方法用于比较两个枚举常量的序号。如果当前枚举常量的序号小于参数枚举常量的序号，则返回负数；如果相等，则返回0；如果大于，则返回正数。
equals(Object o) 方法
- equals(Object o) 方法用于比较两个枚举常量是否相等。枚举常量的比较是基于它们的引用（即==），因为枚举常量是单例的

枚举类可以像普通类一样包含字段、方法和构造函数

字段

枚举类可以定义字段（成员变量），这些字段可以是任何数据类型（如int、String等）。每个枚举常量可以有自己的字段值

枚举类的成员变量不一定要是private的，但通常建议将枚举类的成员变量声明为private，并通过公共的getter方法提供访问。这是因为枚举类的成员变量通常是枚举常量的属性，而这些属性应该是不可变的（immutable），以确保枚举常量的状态不会被意外修改

public enum Day {
    // 枚举常量，每个常量可以有自己的字段值
    SUNDAY("Sun", 1),
    MONDAY("Mon", 2),
    TUESDAY("Tue", 3),
    WEDNESDAY("Wed", 4),
    THURSDAY("Thu", 5),
    FRIDAY("Fri", 6),
    SATURDAY("Sat", 7);

    // 枚举类的字段
    private String abbreviation;
    private int dayNumber;

    // 构造函数
    private Day(String abbreviation, int dayNumber) {
        this.abbreviation = abbreviation;
        this.dayNumber = dayNumber;
    }

    // 访问字段的方法
    public String getAbbreviation() {
        return abbreviation;
    }

    public int getDayNumber() {
        return dayNumber;
    }
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is " + today + ", abbreviation: " + today.getAbbreviation() + ", day number: " + today.getDayNumber());
        // 输出: Today is MONDAY, abbreviation: Mon, day number: 2
    }
}

方法

枚举类可以定义方法，这些方法可以是实例方法或静态方法。枚举常量可以调用这些方法

public enum Day {
    SUNDAY("Sun"),
    MONDAY("Mon"),
    TUESDAY("Tue"),
    WEDNESDAY("Wed"),
    THURSDAY("Thu"),
    FRIDAY("Fri"),
    SATURDAY("Sat");

    private String abbreviation;

    // 构造函数
    private Day(String abbreviation) {
        this.abbreviation = abbreviation;
    }

    // 实例方法
    public String getAbbreviation() {
        return abbreviation;
    }

    // 静态方法
    public static void printAllDays() {
        for (Day day : Day.values()) {
            System.out.println(day + ": " + day.getAbbreviation());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 调用实例方法
        Day today = Day.MONDAY;
        System.out.println("Today is " + today + ", abbreviation: " + today.getAbbreviation());
        // 输出: Today is MONDAY, abbreviation: Mon

        // 调用静态方法
        Day.printAllDays();
        // 输出:
        // SUNDAY: Sun
        // MONDAY: Mon
        // TUESDAY: Tue
        // WEDNESDAY: Wed
        // THURSDAY: Thu
        // FRIDAY: Fri
        // SATURDAY: Sat
    }
}

构造函数

枚举类可以定义构造函数，用于初始化枚举常量的字段。枚举类的构造函数必须是private的，因为枚举常量是在枚举类内部定义的，外部不能直接实例化枚举类

枚举类的遍历

枚举类型（Enumeration）是一种用于遍历集合的接口，常见于早期的 Java 集合类（如 Vector、Hashtable）和 Servlet API 中。遍历枚举类型通常使用 while 循环结合 hasMoreElements() 和 nextElement() 方法。

基本方法：

boolean hasMoreElements()
- 作用：检查枚举中是否还有更多元素。
- 返回值：如果还有元素则返回 true，否则返回 false。
E nextElement()
- 作用：返回枚举中的下一个元素。
- 返回值：下一个元素。
- 注意：如果没有更多元素，调用此方法会抛出 NoSuchElementException 异常。

步骤：

使用 hasMoreElements() 检查是否还有元素。
使用 nextElement() 获取下一个元素。
在循环中处理每个元素。

import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;

public class HeaderExample {
    public void printHeaders(HttpServletRequest request) {
        // 获取所有请求头的名称
        Enumeration<String> headerNames = request.getHeaderNames();

        // 遍历请求头
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            String headerValue = request.getHeader(headerName);
            System.out.println(headerName + ": " + headerValue);
        }
    }
}

特点：

单向遍历：枚举类型只能从前往后遍历，不能反向遍历或随机访问。
不支持修改：枚举类型是只读的，不能通过枚举对象修改集合中的元素。

注解

注解（Annotation）是Java中的一种元数据（metadata），它提供了一种为代码添加额外信息的方式。注解本身不会直接影响代码的逻辑，但可以被编译器、开发工具或运行时环境读取和处理，从而实现特定的功能
注解可以应用于类、方法、字段、参数等地方。使用注解时，需要为注解的元素赋值（如果元素没有默认值）
在 Java 注解中，如果注解的属性名为 value，那么在赋值时可以省略属性名，直接写值。

posted @ 2025-03-03 21:55 QAQ001 阅读(12) 评论(0) 收藏举报

刷新页面返回顶部

Learn-Review-blog