枚举
引入
编写季节类(Season),该类只有四个对象(spring,summer,autumn,winter)
Season类
package com.dream.test01;
public class Season {
private static Season spring = new Season("春天", "春暖花开");
private static Season summer = new Season("夏天", "汗如雨下");
private static Season autumn = new Season("秋天", "秋高气爽");
private static Season winter = new Season("冬天", "白雪皑皑");
private String name;
private String info;
//私有化构造方法:在外界不能new对象
private Season() {
}
private Season(String name,String info) {
this.name = name;
this.info = info;
}
public static Season getSpring() {
return spring;
}
public static Season getSummer() {
return summer;
}
public static Season getAutumn() {
return autumn;
}
public static Season getWinter() {
return winter;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Season [name=" + name + ", info=" + info + "]";
}
}
测试类
package com.dream.test01;
public class Test01 {
public static void main(String[] args) {
/**
* 编写季节类(Season),该类只有四个对象(spring,summer,autumn,winter)
*/
System.out.println(Season.getSpring());
System.out.println(Season.getSummer());
System.out.println(Season.getAutumn());
System.out.println(Season.getWinter());
}
}
概念
枚举(enum)全称为 enumeration, 是 JDK 1.5 中引入的新特性。
语法
public enum Color{
//默认添加 public static final Color
RED,GREEN,BLUE;
}
使用枚举编写季节类(Season),该类只有四个对象(spring,summer,autumn,winter)
Season类
package com.dream.test02;
public enum Season implements I1{
//默认添加:public static final Season
spring("春天","万物复苏"),
summer("夏天","烈日炎炎"),
autumn("秋天","秋高气爽"),
winter("冬天","银装素裹");
private String name;
private String info;
private Season() {
}
private Season(String name,String info) {
this.name = name;
this.info = info;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return name + " -- " + info;
}
@Override
public void method() {
// TODO Auto-generated method stub
}
}
测试类
package com.dream.test02;
public class Test01 {
public static void main(String[] args) {
/**
* 编写季节类(Season),该类只有四个对象(spring,summer,autumn,winter)
*
* 使用枚举
*/
System.out.println(Season.spring);
System.out.println(Season.summer);
System.out.println(Season.autumn);
System.out.println(Season.winter);
}
}
本质
尽管枚举看起来像是一种新的数据类型,实际上,枚举就是一种受限制的类,并且具有自己的方法。创建自己的enum类时,这个类继承自 java.lang.Enum。
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable{
...
}
特点
- 枚举就是一个受限制的类,默认继承Enum
- 枚举的第一行必须定义该枚举类型的对象
- 枚举类型对象默认添加: public static final 类型
- 枚举没有继承明确类(自定义枚举类默认继承Enum,Enum默认继承Object)
- 枚举类不能被继承
- 枚举里可以有构造方法、成员方法、静态方法、抽象方法
- 枚举可以实现接口
- 枚举里没有定义方法,可以在最后一个对象后面加逗号、分号或什么都不加
优势
增强代码可读性
枚举型可直接与数据库交互
switch语句优势
编译优势
(枚举类编译时,没有把常量值编译到代码中,即使常量值发生改变,也不会影响引用常量的类 )
将常量组织起来,统一管理
去除equals两者判断 由于常量值地址唯一,使用枚举可以直接通过“==”进行两个值之间的对比,性能会有所提高
枚举的方法
方法名 | 解释 |
---|---|
Enum.valueOf(Class enumType, String name) | 根据字符串找到该枚举类中的对象 |
public static void values() | 获取该枚举类对象数组 |
public static void valueOf(String args0) | 根据字符串获取该枚举类中的对象 |
public final String name() | 获取该枚举对象名字 |
public final Class getDeclaringClass() | 获取枚举对象的枚举类型相对应的Class对象 |
public final int hashCode() | 获取该枚举对象的hash值 |
public final int compareTo(E o) | 两个枚举对象进行比较 |
public final boolean equals(Object other) | 比较两个枚举对象是否相同 |
Color枚举
package com.dream.test03;
public enum Color {
RED,GREEN,BLUE;
}
测试类
package com.dream.test03;
import java.util.Arrays;
public class Test01 {
public static void main(String[] args) {
/**
* 枚举的常用方法
*/
//通过字符串获取枚举类中的对象
Color color1 = Enum.valueOf(Color.class, "RED");
System.out.println(color1);
//通过字符串获取枚举类中的对象
Color color2 = Color.valueOf("RED");
System.out.println(color2);
//获取该枚举类中所有的对象
Color[] values = Color.values();
System.out.println(Arrays.toString(values));
//获取该枚举对象的名字
System.out.println(Color.GREEN.name());
//获取到该枚举类的字节码文件对象
System.out.println(Color.GREEN.getDeclaringClass());
}
}
枚举案例 - 状态机
enum Signal{RED, YELLOW, GREEN}
public class EnumTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入信号灯:RED,YELLOW,GREEN");
Signal signal = Signal.valueOf(scan.next());
String instruct = getTrafficInstruct(signal);
System.out.println(instruct);
scan.close();
}
public static String getTrafficInstruct(Signal signal) {
String instruct = "信号灯故障";
switch (signal) {
case RED:
instruct = "红灯停";
break;
case YELLOW:
instruct = "黄灯请注意";
break;
case GREEN:
instruct = "绿灯行";
break;
default:
break;
}
return instruct;
}
}
枚举案例 - 错误码
public enum ErrorCodeEn {
Ok(1,"成功"),ERROR_A(2,"错误A"),ERROR_B(3,"错误B");
private int code;//状态码
private String description;//状态信息
ErrorCodeEn(){}
ErrorCodeEn(int code,String description){
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
}
枚举案例 - 组织枚举
含义:可以将类型相近的枚举通过接口或类组织起来(但是一般用接口方式进行组织)
原因是:
Java接口在编译时会自动为enum类型加上public static修饰符;
Java类在编译时会自动为 enum 类型加上static修饰符;
就是说,在类中组织 enum,如果你不给它修饰为 public,那么只能在本包中进行访问。
IErrorCodeEn接口
package com.dream.test06;
//存放错误码的接口
public interface IErrorCodeEn {
//登录的错误码
enum LoginErrorCodeEn {
LOGIN_OK(1,"登录成功"),LOGIN_CODE_ERROR(-1,"验证码错误"),LOGIN_USERNAMEORPASSWORD_ERROR(-2,"账号或密码错误");
private int code;//状态码
private String description;//状态信息
LoginErrorCodeEn(){}
LoginErrorCodeEn(int code,String description){
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
@Override
public String toString() {
return code + " -- " + description;
}
}
//注册的错误码
enum RegisterErrorCodeEn {
REGISTER_OK(1,"注册成功"),
REGISTER_REUSERNAME_ERROR(-1,"账号已重复错误"),
REGISTER_BIND_PHONE_ERROR(-2,"绑定手机号错误"),
REGISTER_PASSWORD_REPASSWORD_ERROR(-2,"密码与确认密码不一致错误");
private int code;//状态码
private String description;//状态信息
RegisterErrorCodeEn(){}
RegisterErrorCodeEn(int code,String description){
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
@Override
public String toString() {
return code + " -- " + description;
}
}
}
测试类
package com.dream.test06;
import com.dream.test06.IErrorCodeEn.LoginErrorCodeEn;
import com.dream.test06.IErrorCodeEn.RegisterErrorCodeEn;
public class Test01 {
public static void main(String[] args) {
/**
* 枚举案例 - 组织枚举
*/
LoginErrorCodeEn[] loginValues = IErrorCodeEn.LoginErrorCodeEn.values();
for (LoginErrorCodeEn loginErrorCodeEn : loginValues) {
System.out.println(loginErrorCodeEn);
}
System.out.println("---------------");
RegisterErrorCodeEn[] registerValues = IErrorCodeEn.RegisterErrorCodeEn.values();
for (RegisterErrorCodeEn registerErrorCodeEn : registerValues) {
System.out.println(registerErrorCodeEn);
}
}
}
public interface IErrorCode {
enum LoginErrorCodeEn implements INumberEnum{
OK(1,"登录成功"),ERROR_A(-1,"验证码错误"),ERROR_B(-2,"密码错误"),ERROR_C(-3,"用户已登录");
private int code;
private String description;
LoginErrorCodeEn(int code,String description){
this.code = code;
this.description = description;
}
@Override
public int getCode() {
return code;
}
@Override
public String getDescription() {
return description;
}
}
enum RigsterErrorCodeEn implements INumberEnum{
OK(1,"注册成功"),ERROR_A(-1,"账号已存在");
private int code;
private String description;
RigsterErrorCodeEn(int code,String description){
this.code = code;
this.description = description;
}
@Override
public int getCode() {
return code;
}
@Override
public String getDescription() {
return description;
}
}
}
interface INumberEnum {
int getCode();
String getDescription();
}
枚举案例 - 策略枚举
优点:这种枚举通过枚举嵌套枚举的方式,将枚举常量分类处理。
这种做法虽然没有switch语句简洁,但是更加安全、灵活。
Salary类
public enum Salary {
JAVA(SalaryType.TEACHER),
HTML(SalaryType.TEACHER),
PYTHON(SalaryType.TEACHER),
PRINCIPAL(SalaryType.ADMINISTRATION);//校长
private final SalaryType salaryType;
Salary(SalaryType salaryType){
this.salaryType = salaryType;
}
//baseSalary-底薪 classHour-课时 teachingHourSubsidy-课时费 achievements-绩效
double getSalary(double baseSalary,int classHour,double teachingHourSubsidy,double achievements){
return salaryType.getSalary(baseSalary, classHour, teachingHourSubsidy, achievements);
}
//策略枚举
private enum SalaryType {
TEACHER {//老师
@Override
double getSalary(double baseSalary, int classHour, double teachingHourSubsidy,
double achievements) {
return baseSalary + classHour*teachingHourSubsidy + achievements;
}
},
ADMINISTRATION {//行政人员
@Override
double getSalary(double baseSalary, int classHour, double teachingHourSubsidy,
double achievements) {
return baseSalary + achievements;
}
};
abstract double getSalary(double baseSalary,int classHour,double teachingHourSubsidy,double achievements);
}
}
测试类
package com.dream.test07;
public class Test01 {
public static void main(String[] args) {
/**
* 枚举案例 - 策略枚举
*/
double salary1 = Salary.JAVA.getSalary(2000, 60, 25, 300);
System.out.println(salary1);
double salary2 = Salary.PRINCIPAL.getSalary(10000, 0, 0, 5000);
System.out.println(salary2);
}
}
枚举工具类 - EnumSet 和 EnumMap
Java 中提供了两个方便操作enum的工具类——EnumSet 和 EnumMap。
EnumSet :枚举类型的高性能 Set实现。它要求放入它的枚举常量必须属于同一枚举类型。
EnumMap :专门为枚举类型量身定做的 Map 实现。虽然使用其它的 Map 实现(如HashMap)也能完成枚举类型实例到值得映射,但是使用 EnumMap 会更加高效,因为它只能接收同一枚举类型的实例作为键值,并且由于枚举类型实例的数量相对固定并且有限,所以 EnumMap 使用数组来存放与枚举类型对应的值。这使得 EnumMap 的效率非常高。
public class EnumTest {
public static void main(String[] args) {
//EnumSet的使用
//把Signal枚举中所有对象抽取到Set集合中
EnumSet<Signal> signalSet = EnumSet.allOf(Signal.class);
for (Enum<Signal> en : signalSet) {
System.out.println(en);
}
//EnumMap的使用
EnumMap<Signal,Object> enumMap = new EnumMap<>(Signal.class);
enumMap.put(Signal.RED, "红灯");
enumMap.put(Signal.YELLOW, "黄灯");
enumMap.put(Signal.GREEN, "绿灯");
//把所有的映射关系对象抽取到Set集合中
Set<Entry<Signal, Object>> entrySet = enumMap.entrySet();
for (Entry<Signal, Object> entry : entrySet) {
Signal key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + " -- " + value);
}
}
}
enum Signal{RED, YELLOW, GREEN}