什么是java枚举

当我们定义的类的对象有限、确定，那么可以考虑使用枚举类

        例如：星期类：周一、二...日

                   季节类：春、夏、秋、冬

当需要定义一组常量时，强烈建议使用枚举类

当枚举类中只有一个实现对象时，可以作为单例模式的实现

---

如何定义枚举类？

        1、jdk5.0之前，自定义枚举类，例如下面代码

/**
 *创建一个季节类 
*/
public class Season {
    //id和name属性 定义成私有的和final属性
    private final int id;
    private final String name;
    //私有的构造方法
    private Season(int id, String name) {
        this.id = id;
        this.name = name;
    }
    //get方法
    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
    //toString方法
    @Override
    public String toString() {
        return "Season{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    //定义season对象，static和final属性
    public static final Season SPRING = new Season(1,"春");
    public static final Season SUMMER = new Season(2,"夏");
    public static final Season AUTUMN = new Season(3,"秋");
    public static final Season WINTER = new Season(4,"冬");

    public static Season get(int id) {
        if (id==SPRING.getId()) {
            return SPRING;
        }
        if (id==SUMMER.getId()) {
            return SUMMER;
        }
        if (id==AUTUMN.getId()) {
            return AUTUMN;
        }
        if (id==SPRING.getId()) {
            return WINTER;
        }
        return null;
    }
}

        2、jdk5.0之后，使用enum关键字定义

public enum  Season1 {
    /**
     * 提供枚举类的对象，用“，”隔开，最后用分号结尾
     * 实际上就是把自定义类的静态不可变的对象定义给简写了，把共同的部分去掉了
     *继承自class java.lang.Enum，重写了toString方法，我们也可以继续重写
     */
    SPRING(1,"春"),
    SUMMER(2,"夏"),
    AUTUMN(3,"秋"),
    WINTER(4,"冬");

    private final int id;
    private final String name;

    private Season1(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    //@Override
    //public String toString() {
    //    return "Season{" +
    //            "id=" + id +
    //            ", name='" + name + '\'' +
    //            '}';
    //}


    public static Season1 get(int id) {
        if (id==SPRING.getId()) {
            return SPRING;
        }
        if (id==SUMMER.getId()) {
            return SUMMER;
        }
        if (id==AUTUMN.getId()) {
            return AUTUMN;
        }
        if (id==SPRING.getId()) {
            return WINTER;
        }
        return null;
    }
}

     *提供枚举类的对象，用“，”隔开，最后用分号结尾
     * 实际上就是把自定义类的静态不可变的对象定义给简写了，把共同的部分去掉了
     *继承自class java.lang.Enum，重写了toString方法，我们也可以继续重写

---

如果枚举类实现一个接口，但是他的常量对象都有对这个接口有不同的实现，这样该怎么办呢？

public enum  Season1 implements Info{
    /**
     * 提供枚举类的对象，用“，”隔开，最后用分号结尾
     * 实际上就是把自定义类的静态不可变的对象定义给简写了，把共同的部分去掉了
     *继承自class java.lang.Enum，重写了toString方法，我们也可以继续重写
     */
    SPRING(1,"春"){
        @Override
        public void show() {
            System.out.println("春天在哪里");
        }
    },
    SUMMER(2,"夏"){
        @Override
        public void show() {
            System.out.println("夏天在哪里");
        }
    },
    AUTUMN(3,"秋"){
        @Override
        public void show() {
            System.out.println("秋天在哪里");
        }
    },
    WINTER(4,"冬"){
        @Override
        public void show() {
            System.out.println("冬天在哪里");
        }
    };

    private final int id;
    private final String name;

    private Season1(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    //@Override
    //public String toString() {
    //    return "Season{" +
    //            "id=" + id +
    //            ", name='" + name + '\'' +
    //            '}';
    //}


    public static Season1 get(int id) {
        if (id==SPRING.getId()) {
            return SPRING;
        }
        if (id==SUMMER.getId()) {
            return SUMMER;
        }
        if (id==AUTUMN.getId()) {
            return AUTUMN;
        }
        if (id==SPRING.getId()) {
            return WINTER;
        }
        return null;
    }
}

每一个枚举对象都各自实现其方法，有点类似于匿名内部类