浅聊java中的枚举以及关于枚举的常见面试问题

基本概念：

什么是枚举？

枚举（Enum）是一种特殊的类，它用于表示一组固定的常量。枚举从Java 5（也称为Java 1.5）开始引入，提供了一种比传统常量（如使用public static final定义的变量）更类型安全、更易读和更易维护的方式来定义一组常量。

如何定义枚举？

枚举是通过关键字enum来定义的。枚举的每一个实例都是该枚举类型的一个对象，这些对象在编译时就已经被创建，并且不能被实例化。枚举类默认继承自java.lang.Enum类，但不能显式继承其他类（也不能被继承，因为当枚举被编译为类时会被final修饰，但它可以实现接口）。

public enum Color {  
    RED, GREEN, BLUE;  
}

枚举的特性有哪些？

1. 类型安全：枚举提供了一种类型安全的方式来表示一组常量，避免了使用整数或字符串表示常量时可能发生的错误。
2. 自动序列化：枚举实现了java.io.Serializable接口，因此它们可以自动序列化。
3. 单例实现：枚举是实现单例模式的最佳方式之一，因为它保证了线程安全和实例的唯一性。
4. 包含方法和属性：枚举可以包含构造方法（必须是私有的）、字段、方法和抽象方法。

枚举的常用方法有哪些？

• values()：返回包含枚举中所有元素的数组。
• valueOf(String name)：根据枚举常量的名称返回对应的枚举常量。
• ordinal()：返回枚举常量在枚举声明中的位置（从0开始）。
• compareTo(E o)：在枚举类型上实现自然排序。这个方法允许枚举常量按照它们在枚举声明中出现的顺序进行比较。
• name()：返回枚举常量的名称，这个名称就是声明枚举常量时所用的标识符。
• toString()：默认情况下，枚举的toString()方法返回枚举常量的名称。但你也可以重写这个方法以返回更有意义的字符串表示。

枚举的日常使用示例 ：

定义

枚举类是通过enum关键字来定义的。枚举类的声明类似于类，但关键字是enum而不是class。

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

 使用

你可以像使用其他任何类型的变量一样使用枚举常量。枚举常量在编译时就被解析为对应的枚举类型对象。

Day day = Day.MONDAY;  
System.out.println(day); // 输出 MONDAY

方法

枚举可以包含字段、方法和构造函数。但是，枚举的构造函数默认是私有的，以防止外部代码实例化枚举。 

public enum Color {  
    RED("红色"), GREEN("绿色"), BLUE("蓝色");  
  
    private final String description;  
  
    Color(String description) {  
        this.description = description;  
    }  
  
    public String getDescription() {  
        return this.description;  
    }  
}  
  
System.out.println(Color.RED.getDescription()); // 输出 红色
//
// 在这个例子中，Color枚举类有一个私有字段description和一个接受字符串参数的构造函数。每个枚举常量在声明时都通过调用构造函数来初始化其description字段。

遍历

你可以使用values()方法遍历枚举的所有值。 

for (Day d : Day.values()) {  
    System.out.println(d);  
}

枚举与switch

枚举与switch语句配合使用非常方便，因为switch语句可以接受枚举类型作为条件表达式。 

Day day = Day.MONDAY;  
  
switch (day) {  
    case MONDAY:  
        System.out.println("星期一");  
        break;  
    case FRIDAY:  
        System.out.println("星期五");  
        break;  
    default:  
        System.out.println("其他日子");  
}

实现接口

枚举类可以实现一个或多个接口，并定义实现这些接口所需的方法。 

interface Describable {  
    String describe();  
}  
  
public enum Planet implements Describable {  
    MERCURY, VENUS, EARTH;  
  
    @Override  
    public String describe() {  
        // 这里只是一个简单的实现，实际上你可以根据枚举常量的不同返回不同的描述  
        return this.name().toLowerCase() + " is a planet";  
    }  
}  
  
System.out.println(Planet.EARTH.describe()); // 输出 earth is a planet

另一种写法：

 

interface Behaviour {  
    void show();  
}  
  
public enum Animal implements Behaviour {  
    DOG {  
        @Override  
        public void show() {  
            System.out.println("Woof!");  
        }  
    },  
    CAT {  
        @Override  
        public void show() {  
            System.out.println("Meow!");  
        }  
    },  
    BIRD {  
        @Override  
        public void show() {  
            System.out.println("Tweet!");  
        }  
    };  
  
    // 示例：一个静态方法，遍历所有动物并显示它们的行为  
    public static void showAllAnimals() {  
        for (Animal animal : Animal.values()) {  
            animal.show();  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        showAllAnimals();  
    }  
}

 带构造器和方法的枚举

public enum Season {  
    SPRING("Spring"), SUMMER("Summer"), AUTUMN("Autumn"), WINTER("Winter");  
  
    private final String description;  
  
    // 私有构造器  
    Season(String description) {  
        this.description = description;  
    }  
  
    // 公开方法  
    public String getDescription() {  
        return description;  
    }  
  
    // 示例方法，根据季节返回活动建议  
    public String getActivitySuggestion() {  
        switch (this) {  
            case SPRING:  
                return "Go for a hike or plant a garden.";  
            case SUMMER:  
                return "Go swimming or have a picnic.";  
            case AUTUMN:  
                return "Go apple picking or take a scenic drive.";  
            case WINTER:  
                return "Go skiing or build a snowman.";  
            default:  
                return "Enjoy the season!";  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        Season season = Season.SUMMER;  
        System.out.println(season.getDescription() + ": " + season.getActivitySuggestion());  
    }  
}

 使用枚举作为Map的键

import java.util.EnumMap;  
import java.util.Map;  
  
public enum Day {  
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY  
}  
  
public class WorkHours {  
    public static void main(String[] args) {  
        Map workHours = new EnumMap<>(Day.class);  
  
        workHours.put(Day.MONDAY, 8);  
        workHours.put(Day.TUESDAY, 8);  
        workHours.put(Day.WEDNESDAY, 8);  
        workHours.put(Day.THURSDAY, 8);  
        workHours.put(Day.FRIDAY, 6); // 假设周五早些下班  
        // 周末不工作，所以不需要设置  
  
        for (Map.Entry entry : workHours.entrySet()) {  
            System.out.println(entry.getKey() + ": " + entry.getValue() + " hours");  
        }  
    }  
}

枚举中的抽象方法

 

public enum Operation {  
    PLUS {  
        @Override  
        public double apply(double x, double y) {  
            return x + y;  
        }  
    },  
    MINUS {  
        @Override  
        public double apply(double x, double y) {  
            return x - y;  
        }  
    },  
    MULTIPLY {  
        @Override  
        public double apply(double x, double y) {  
            return x * y;  
        }  
    },  
    DIVIDE {  
        @Override  
        public double apply(double x, double y) {  
            if (y == 0) throw new IllegalArgumentException("Cannot divide by zero");  
            return x / y;  
        }  
    };  
  
    // 抽象方法  
    public abstract double apply(double x, double y);  
  
    // 测试方法  
    public static void main(String[] args) {  
        System.out.println(Operation.PLUS.apply(10, 5));  // 输出 15.0  
        System.out.println(Operation.DIVIDE.apply(10, 2)); // 输出 5.0  
    }  
}

EnumSet与EnumMap:

EnumSet 和 EnumMap 是 Java 集合框架中专门为枚举（enum）类型设计的两个类。它们提供了比标准集合（如 HashSet 和 HashMap）更高的性能，特别是当集合中的元素是枚举类型时。这是因为它们内部利用了枚举的固有顺序和唯一性进行优化。

EnumSet

EnumSet 是一个不包含重复元素的集合，它专门为枚举类型设计。与普通的 Set 接口实现（如 HashSet）相比，EnumSet 在空间和时间上都有显著的优势，因为它内部使用位向量来表示集合中的元素，这种表示方法非常紧凑且高效。

主要特点：

• 类型安全：由于 EnumSet 的元素是枚举类型，因此在编译时就能保证类型安全。
• 性能高效：内部使用位向量存储元素，因此集合的创建、遍历和查找等操作都非常快。
• 丰富的构造函数：EnumSet 提供了多种构造函数，包括从类型（Class）创建空集合、从现有集合创建新集合等。
• 迭代顺序：EnumSet 遍历元素的顺序是枚举的自然顺序（除非指定了另一种顺序），这对于需要按特定顺序处理枚举值的场景非常有用。

示例代码：

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }  
  
public class EnumSetExample {  
    public static void main(String[] args) {  
        EnumSet weekdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);  
        for (Day day : weekdays) {  
            System.out.println(day);  
        }  
    }  
}

EnumMap

EnumMap 是一个映射（Map），其键是枚举类型。与普通的 Map 接口实现（如 HashMap）相比，EnumMap 提供了更高的性能，因为它内部使用数组来存储键值对，并利用枚举的索引作为数组的下标。

主要特点：

• 类型安全：由于 EnumMap 的键是枚举类型，因此在编译时就能保证类型安全。
• 性能高效：内部使用数组存储键值对，使得查找、插入和删除操作都非常快。
• 自然顺序：EnumMap 遍历键的顺序是枚举的自然顺序（除非指定了另一种顺序）。
• 内存紧凑：由于内部使用数组，且数组的大小固定为枚举类型的常量数，因此 EnumMap 的内存使用非常紧凑。

示例代码：

enum Color { RED, GREEN, BLUE }  
  
public class EnumMapExample {  
    public static void main(String[] args) {  
        EnumMap count = new EnumMap<>(Color.class);  
        count.put(Color.RED, 1);  
        count.put(Color.GREEN, 2);  
        count.put(Color.BLUE, 3);  
  
        for (Map.Entry entry : count.entrySet()) {  
            System.out.println(entry.getKey() + ": " + entry.getValue());  
        }  
    }  
}

总之，EnumSet 和 EnumMap 是 Java 集合框架中针对枚举类型优化的两个类，它们提供了类型安全、性能高效和内存紧凑的集合操作，是处理枚举类型数据时的首选集合类型。 

关于枚举的常见面试问题：

枚举如何实现单例模式？

• 通过枚举的实例在JVM中唯一性，枚举天然就是单例的。例如，public enum Singleton { INSTANCE; }。这种方式实现单例模式既简单又安全，因为JVM保证了枚举实例的唯一性，并且枚举的构造方法是私有的，不能被外部实例化。

枚举可以继承其他类吗？

• 枚举默认继承自java.lang.Enum类，因此不能显式继承其他类。

枚举的默认构造函数是怎样的？

• 枚举的默认构造函数是私有的，不能显式定义访问修饰符（默认为private），且不能被外部实例化。

 枚举中的方法和属性是如何定义的？

• 枚举中的方法和属性与普通类中的定义方式相同，但构造方法必须是私有的。

 values()和valueOf(String name)方法的作用是什么？

• values()方法返回包含枚举中所有元素的数组。
• valueOf(String name)方法根据枚举常量的名称返回对应的枚举常量。

 枚举中的ordinal()方法有什么作用？

• ordinal()方法返回枚举常量在枚举声明中的位置（从0开始）。

 为什么推荐使用枚举而不是静态常量？

• 枚举提供了类型安全、自动序列化、单例实现等特性，而静态常量则不具备这些特性。此外，枚举的语义更清晰，易于理解和维护。

 这些问题涵盖了枚举的基本概念、特性、用法以及相关的设计模式，是Java枚举面试中常见的问题。在回答这些问题时，可以结合具体的代码示例和场景来解释，以增强回答的说服力和清晰度。