1、什么是枚举类
实例（也叫对象）有限且固定不变的类，在Java里被称为枚举类。 枚举类是一种特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或多个接口，也可以有自己的构造器。
个人理解：其实就是枚举类内部已经创建好我们已经确定的对象，私有构造器就是不允许修改和创建，用到枚举类说明这些对象就已经确定下来了。
例如，季节类，它只有4个实例（春、夏、秋、冬），并且这4个实例不会改变。可以用枚举类来表示：
public enum SeasonEnum{
SPRING,SUMMER,FALL,WINTER;
}1.1、枚举类的使用
- 枚举类的理解: 类的对象只有有限个,确定的,我们称此类为枚举类
- 当需要定义一组常量时,强烈建议使用枚举类
- 如果枚举类中只有一个对象,则可以作为单例模式的实现方式
自定义枚举类
属性：private final
对象：private static final
注意事项：
- a：构造器私有化。
- b：本类内部，创建一组对象。
- c：对外暴露对象。（通过 为对象添加 public static final 修饰符）
- d：可以提供 get 方法，但是不提供 set 方法。防止修改。
package com.ly.business.test;
/**
* 一、枚举类的使用
* 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
* 2.当需要定义一组常量时，强烈建议使用枚举类
* 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。
*
* 二、如何定义枚举类
* 方式一：jdk5.0之前，自定义枚举类
* 方式二：jdk5.0，可以使用enum关键字定义枚举类
*
* 三、Enum类中的常用方法：
* values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
* valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
* toString()：返回当前枚举类对象常量的名称
*
* 四、使用enum关键字定义的枚举类实现接口的情况
* 情况一：实现接口，在enum类中实现抽象方法
* 情况二：让枚举类的对象分别实现接口中的抽象方法
*
*/
public class EnumDemo {
public static void main(String[] args) {
Season autumn = Season.AUTUMN;
System.out.println(autumn);
}
}
//自定义枚举类
class Season{
//1、声明Season对象的属性：private final修饰
private final String seasonName;
private final String seasonDesc;
//2、要私有化构造函数，并给对象属性赋值
private Season(String seasonName,String seasonDesc){
this.seasonName=seasonName;
this.seasonDesc=seasonDesc;
}
//3、提供当前枚举类的多个对象：public static final的
public static final Season SPRING=new Season("春天","春暖花开");
public static final Season SUMMER=new Season("夏天","夏日炎炎");
public static final Season AUTUMN=new Season("秋天","秋高气爽");
public static final Season WINTER=new Season("冬天","冰天雪地");
public String getSeasonName(){
return seasonName;
}
public String getSeasonDesc(){
return seasonDesc;
}
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
使用关键字enum定义枚举类
JDK 1.5 之后，如何使用 关键字 Enum 关键字 定义枚举类：
-1.使用关键字 enum ，替代 class。
-2.public static final AA spring = new AA(“春天”, 10); –简化成-> spring(“春天”, 10);
-3.提供当前 枚举类的对象，多个对象之间用 “，” 隔开，末尾对象 “；” 结束
-4.如果使用 enum，要求将 定义的常量对象，（spring(“春天”, 10)；）
public enum SeasonEnum {
SPRING,SUMMER,AUTUMN,WINTER;
private String name;
private String desc;
SeasonEnum(){}
SeasonEnum(String name, String desc) {
this.name = name;
this.desc = desc;
}
public static void main(String[] args) {
SeasonEnum spring = SeasonEnum.SPRING;
System.out.println(spring);
}
}Color枚举类：
package com;
public enum Color {
RED, GREEN, BLANK, YELLOW
}Switch的使用
package com;
public class B {
public static void main(String[] args) {
showColor( Color.RED );
}
static void showColor(Color color){
switch ( color ) {
case BLANK:
System.out.println( color );
break;
case RED :
System.out.println( color );
break;
default:
System.out.println( color );
break;
}
}
}1.2、实现接口的枚举类
所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。
1、实现接口，在enum类中实现抽象方法
package enumTest;
public interface DayInterface {
public String getDay();
}package enumTest;
public enum MyDay implements DayInterface{
MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号
private int code;
private String name;
private MyDay(int code,String name) {
this.code = code;
this.name = name;
}
public int getCode() {
return code;
}
public String getName() {
return name;
}
public void setCode(int code) {
this.code = code;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.getName()+"---"+this.getCode();
}
@Override
public String getDay() {
return this.getName();
}
}package enumTest;
public class Test {
public static void main(String[] args) {
System.out.println(MyDay.THUSDAY.getDay());
}
//结果：星期二
}
2、让枚举类的对象分别实现接口中的抽象方法
public class SeasonTest1 {
public static void main(String[] args) {
Season1 summer=Season1.SUMMER;
//toString():返回枚举类对象的名称
System.out.println(summer.toString());
//不重写tostring方法，返回对象名称：SUMMER
System.out.println(Season1.class.getSuperclass());
//class java.lang.Enum
System.out.println("****************");
//values():返回所有的枚举类对象构成的数组
Season1[] values=Season1.values();
for (int i = 0; i <values.length ; i++) {
System.out.println(values[i]);
values[i].show();
}
System.out.println("****************");
//valueOf(String objName):返回枚举类中对象名是objName的对象。
Season1 winter=Season1.valueOf("WINTER");
//如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
//Season1 winter=Season1.valueOf("WINTER1");
System.out.println(winter);//WINTER
winter.show();//这是冬天
}
}
interface Info{
void show();
}
enum Season1 implements Info{
//1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
SPRING("春天","春暖花开"){
@Override
public void show() {
System.out.println("这是春天");
}
},
SUMMER("夏天","夏日炎炎"){
@Override
public void show() {
System.out.println("这是夏天");
}
},
AUTUMN("秋天","秋高气爽"){
@Override
public void show() {
System.out.println("这是秋天");
}
},
WINTER("冬天","冰天雪地"){
@Override
public void show() {
System.out.println("这是冬天");
}
};
//2.声明Season对象的属性:private final修饰
private final String seasonName;
private final String seasonDesc;
//3.私有化类的构造器,并给对象属性赋值
private Season1(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他诉求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
}
总结：
1、枚举的本质是类，在没有枚举之前，仍然可以按照java最基本的编程手段来解决需要用到枚举的地方。枚举屏蔽了枚举值的类型信息，不像在用public static final定义变量必须指定类型。枚举是用来构建常量数据结构的模板，这个模板可扩展。枚举的使用增强了程序的健壮性，比如在引用一个不存在的枚举值的时候，编译器会报错。枚举的更多用法还需要在开发中去研究创造，Java5、Java6增加了不少新的特性，技术在升级，对程序员来说就要学习，如果你热爱java的话。否则别人用到新特性的代码你看不懂，那才叫郁闷。
