Java基础之枚举

Java 枚举

enum

enum

• Java枚举（enum）是特殊的类
  • 使用关键字enum定义，一般表示一组常量
    • 比如：一年的四季，一周的七天
• 默认继承Enum类，且为final类
  • 无法再继承其他类，也无法被其它类继承
  • 可以实现接口
  • 定义的常量默认为public static final
    • 常量为实例化对象
    • 各常量使用逗号,来分隔
• 使用步骤
  1. 使用时先定义常量对象
     • 无参构造实例化：对象可以省略实参列表和括号
     • 有参构造：追加参数
     • 构造函数必须是 private 权限
  2. 再定义枚举中的属性、构造方法、方法等
     • 若定义了抽象方法，创建对象（常量）时需要重写该方法

// 枚举颜色常量
enum Color{
    // 默认为 public static final RED, GREEN, BLUE;
    RED{												// 无参构造
        public void set(){}							
    },								
    GREEN{												// 无参构造
        public void set(){}
    },								
    BLUE(1, 冬天){									  // 有参构造
        public void set(){}
    };								
    // 常量（实例化对象）必须在最前面
    private int month;									// 字段：月份
    private String name;								// 字段：季节
    private Color(){}									// 无参构造；构造函数必须私有
    private Color(int month, String name){}				// 有参构造；构造函数必须私有
    public abstract void set();							// 抽象方法；定义常量对象时必须实现该方法
}	
public class Test{
    public static void main(String[] args){
        Color color = Color.RED;
        System.out.println(color);						// 等价于 System.out.ptintln(Color.RED)
    }
}
运行结果：
RED	 // RED实际为实例化对象后的对象名

Enum

• enum：JDK1.5 之后提供的关键字，用于定义枚举类
• Enum：抽象类，即使用enum 默认继承Enum 类

迭代

• 可使用for语句迭代枚举元素

enum Color{
    RED,GREEN,BLUE;
}
public class MyClass{
    public static void main(String[] args){
        for(Color myVar : Color.values()){		// Color.values()：得到enum中所有的常量元素，返回一个数组
            System.out.println(myVar);
        }
    }
}
运行结果：
RED
GREEN
BlUE

内部类使用

// 枚举可声明在内部类中
public class Test{
    enum Color{
        RED, GREEN, BIUE;
    }
    public static void main(String[] args){
        COlor c = Color.RED;
        System.out.println(c);
    }
}
运行结果：
RED

• 每个枚举都是通过 Class 在内部实现的
  • 所有枚举值都是public static final
  • 枚举类Color转化在内部类实现

class color{
    public static final Color RED = new Color();
    public static final Color BLUE = new Color();
    public static final Color GREEN = new Color();
}

switch使用

// 枚举类常应用于 switch 语句
enum Color{
    RED,GREEN,BLUE;
}
public class Test{
	public static void main(String[] args){
    	Color c = Color.BLUE;
        switch(c){
            case RED:
                System.out.println("红色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
            case BLUE:
                System.out.println("蓝色");
                break;
        }
    }
}
运行结果：
蓝色

方法

enum 定义的枚举类默认继承了java.lang.Seriablizable和java.lang.Comparable两个接口

• java.lang.Enum类中有三个方法

  • value()：返回枚举中的所有值

  • ordinal()：找到每个枚举常量的索引，类似于数组索引

    • 枚举类中实例对象根据定义顺序编号

  • valueOf()：返回指定字符串值的枚举常量

enum Color{
    RED, GREEN, BLUE;
}
 
public class Test{
    public static void main(String[] args){
        for (Color c : Color.values()) {  									// 迭代枚举   
            System.out.println(c + " 在第 " + c.ordinal() + " 位");		 // 查看枚举索引
        }
        System.out.println(Color.valueOf("RED"));			// valueOf() 返回枚举常量   
        // System.out.println(Color.valueOf("WHITE"));		// 常量不存在时发生异常 IllegalArgumentException
    }
}
运行结果：
RED 在第 0 位
GREEN 在第 1 位
BlUE 在第 2 位
RED

枚举类成员

• 枚举跟普通类一样可以拥有变量、方法和构造函数

  • 构造函数只能使用private 访问修饰``符，外部无法使用

• 枚举即可以包含具体方法，也可以包含抽象方法

  • 若枚举中定义有抽象方法，则枚举的每个实例都必须实现它

enum Color{
// 枚举类中定义了抽象方法，需要每个对象都对其进行实现
    RED{
        public String getColor(){				//枚举对象实现抽象方法
            return "红色";
        }
    },
    GREEN{
        public String getColor(){				//枚举对象实现抽象方法
            return "绿色";
        }
    },
    BLUE{
        public String getColor(){				//枚举对象实现抽象方法
            return "蓝色";
        }
    };
    
    public abstract String getColor();			//定义抽象方法

    private Color(){    						// 构造函数
        System.out.println("要求：" + 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();
    }
}
运行结果：
要求：RED
要求：GREEN
要求：BLUE											// 每个常量都调用无参构造进行实例化
RED
Universal Color