Enum_java enum属于object-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43711676/article/details/111599897

本文详细介绍了Java中的枚举类型，包括枚举的定义、特性、方法以及枚举在switch语句中的使用。枚举可以表示一组常量，如季节、月份等，并且枚举类默认继承Enum类，支持实现接口。示例展示了如何定义带有抽象方法的枚举、添加新方法、实现接口以及使用EnumSet和EnumMap。枚举在提高代码可读性和安全性方面具有显著优势。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java 枚举(enum)

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。
枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾). 列出的实例系统会自动添加 public static final 修饰

Enum抽象类常见方法

Enum是所有 Java 语言枚举类型的公共基本类（注意Enum是抽象类），以下是它的常见方法：

返回类型	方法名称	方法说明
int	compareTo(E o)	比较此枚举与指定对象的顺序
boolean	equals(Object other)	当指定对象等于此枚举常量时，返回 true。
Class<?>	getDeclaringClass()	返回与此枚举常量的枚举类型相对应的 Class 对象
String	name()	返回此枚举常量的名称，在其枚举声明中对其进行声明
int	ordinal()	返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）
String	toString()	返回枚举常量的名称，它包含在声明中
static<T extends Enum> T	static valueOf(Class enumType, String name)	返回带指定名称的指定枚举类型的枚举常量。

常量定义实例

enum Color{
    RED, GREEN, BLUE;
}
public class Test{
    // 执行输出结果
    public static void main(String[] args) {
        Color c1 = Color.RED;
        System.out.println(c1);		//输出 RED;
        //迭代枚举元素
        for (Color myVar : Color.values()) {
	      	System.out.println(myVar);
	    }
    }
}

enum和class、interface的地位一样
使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。枚举类可以实现一个或多个接口。
枚举类的所有实例都必须放在第一行展示，不需使用new 关键字，不需显式调用构造器。自动添加public static final修饰。
使用enum定义、非抽象的枚举类默认使用final修饰，不可以被继承。
枚举类的构造器只能是私有的。

switch语句里的表达式可以是枚举值

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。
case表达式中直接写入枚举值，不需加入枚举类作为限定。

enum Signal {  
    GREEN, BLUE, RED  
}  
public class TrafficLight {  
public static void main(String[] args) {
       Signal color = Signal.RED;
    switch(color) {
      case RED:
        System.out.println(" Signal.RED");
        break;
      case GREEN:
         System.out.println("Signal.GREEN");
        break;
      case BLUE:
        System.out.println("Signal.BLUE");
        break;
    }
  }  
}

通过定义抽象方法的方式定义枚举

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;
        }   
    },
    TIMES{
      	 @Override
        public double eval(double x, double y) {
            return x * y;
        }      
    },
    DIVIDE{
        @Override
        public double eval(double x, double y) {
            return x / y;
        }   
    };
    /**
     * 抽象方法，由不同的枚举值提供不同的实现。
     * @param x
     * @param y
     * @return
     */
    public abstract double eval(double x, double y);
    public static void main(String[] args) {
        System.out.println(Operation.PLUS.eval(10, 2));
        System.out.println(Operation.MINUS.eval(10, 2));
        System.out.println(Operation.TIMES.eval(10, 2));
        System.out.println(Operation.DIVIDE.eval(10, 2));
    }
}

向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

public enum ColorEnum {
    RED("red", "红色"),
    GREEN("green", "绿色"),
    BLANK("blank", "白色"),
    YELLO("yello", "黄色");
    // 成员变量
    private String name;
    private String value;
    // 私有构造,防止被外部调用
    private ColorEnum(String name, String value) {
        this.name = name;
        this.value = value;
    }
    public String getName() {
        return name;
    }
    public String getValue() {
        return value;
    }
    // 将数据缓存到map中
    private static final Map<String, String> map = new HashMap<String, String>();
    static {
        for (ColorEnum color : ColorEnum.values()) {
            map.put(color.getName(), color.getValue());
        }
    }
    // 根据name查询value值
    public static String getValueByName(String name) {
        return map.get(name);
    }   
	 public static void main(String[] args) {
		 String string =getValueByName("red");
		 System.out.println(string);
	}
}

覆盖枚举的方法

下面给出一个toString()方法覆盖的例子

public class Test {
    public enum Color {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量
        private String name;
        private int index;
        // 构造方法
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }
        // 覆盖方法
        @Override
        public String toString() {
            return this.index + "_" + this.name;
        }
    }
    public static void main(String[] args) {
        System.out.println(Color.RED.toString());
    }
}

枚举类实现接口

public class enum1 {
	public static void main(String[] args) {
		 Season[] season = Season.values();
		 for(int i = 0;i<season.length;i++) {
			 System.out.println(season[i]);
			 season[i].show();
		 }
	}
}
interface Info{
	void show();
}
enum Season implements Info{
	// 1.提供当前枚举类的对象，多个对象之间用“，”隔开，末尾对象“；”结束
	SPRING("春天", "春来花开"){
		public void show() {
			System.out.println("春天在哪里");
		}
	},
	SUMMER("夏天", "夏日炎炎"){
		public void show() {
			System.out.println("夏天在哪里");
		}
	}, 
	AUTUMN("秋天", "秋风萧瑟"){
		public void show() {
			System.out.println("秋天在哪里");
		}
	},
	WINTER("冬天", "寒风凛凛"){
		public void show() {
			System.out.println("冬天在哪里");
		}
	};
}

使用接口组织枚举

public enum Meal{
  APPETIZER(Food.Appetizer.class),
  MAINCOURSE(Food.MainCourse.class),
  DESSERT(Food.Dessert.class),
  COFFEE(Food.Coffee.class);
  private Food[] values;
  private Meal(Class<? extends Food> kind) {
    //通过class对象获取枚举实例
    values = kind.getEnumConstants();
  }
  public interface Food {
    enum Appetizer implements Food {
      SALAD, SOUP, SPRING_ROLLS;
    }
    enum MainCourse implements Food {
      LASAGNE, BURRITO, PAD_THAI,
      LENTILS, HUMMOUS, VINDALOO;
    }
    enum Dessert implements Food {
      TIRAMISU, GELATO, BLACK_FOREST_CAKE,
      FRUIT, CREME_CARAMEL;
    }
    enum Coffee implements Food {
      BLACK_COFFEE, DECAF_COFFEE, ESPRESSO,
      LATTE, CAPPUCCINO, TEA, HERB_TEA;
    }
  }
}

枚举集合

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

public class LightTest {
    // 1.定义枚举类型
    public enum Light {
        // 利用构造函数传参
        RED(1), GREEN(3), YELLOW(2);
        // 定义私有变量
        private int nCode;
        // 构造函数，枚举类型只能为私有
        private Light(int _nCode) {
           this.nCode = _nCode;
        }
        @Override
        public String toString() {
            return String.valueOf(this.nCode);
        }
    }
    /**
     * 
     * @param args
     */
    public static void main(String[] args) {
        // 1.遍历枚举类型
        System.out.println("演示枚举类型的遍历 ......");
        testTraversalEnum();
        // 2.演示EnumMap对象的使用
        System.out.println("演示EnmuMap对象的使用和遍历.....");
        testEnumMap();
        // 3.演示EnmuSet的使用
        System.out.println("演示EnmuSet对象的使用和遍历.....");
        testEnumSet();

    }

    /**
     * 
      * 演示枚举类型的遍历
     */
    private static void testTraversalEnum() {
        Light[] allLight = Light.values();
        for (Light aLight : allLight) {
            System.out.println("当前灯name：" + aLight.name());
            System.out.println("当前灯ordinal：" + aLight.ordinal());
            System.out.println("当前灯：" + aLight);
        }
    }
    /**
     * 
     * 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型
     */
    private static void testEnumMap() {
        // 1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型
        EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(Light.class);
        currEnumMap.put(Light.RED, "红灯");
        currEnumMap.put(Light.GREEN, "绿灯");
        currEnumMap.put(Light.YELLOW, "黄灯");
        // 2.遍历对象
        for (Light aLight : Light.values()) {
            System.out.println("[key=" + aLight.name() + ",value="+ currEnumMap.get(aLight) + "]");
        }
    }
    /**
     * 
     * 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容<BR/>
     * 
     * 可以使用allOf方法
     */
    private static void testEnumSet() {
        EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
        for (Light aLightSetElement : currEnumSet) {
            System.out.println("当前EnumSet中数据为：" + aLightSetElement);
        }
    }
}