Java面向对象编程（枚举）

枚举

1.描述：

1）枚举是一组常量的集合。
2）枚举属于一种特殊的类，里面只包含一组有限的特定的对象。

2.枚举的二种实现方式：

1) 自定义类实现枚举

2) 使用 enum 关键字实现枚举

自定义实现枚举：

//自定义枚举
//1.构造器私有化
//2.去掉set相关方法（防止属性被修改）
//3.在类内部直接创建固定的对象
//4.优化加入 final 防止修改
class Season{
    //属性
    private String name;
    private String desc;
    //对象属性
    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("冬天","寒冷");
    //私有构造器
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    //只有get方法
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }

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

使用 enum 关键字实现枚举：

//关键字实现枚举enum
enum Season2 {
    //先创建对象
    spring("春天", "温暖"), summer("夏天", "炎热"),
    autumn("秋天", "凉爽"), winter("冬天", "寒冷"),
    /* noSeason();//也可以写成 noSeason */;

    //属性
    private String name;
    private String desc;
    //私有构造器
    private Season2(){}//无参
    private Season2(String name, String desc) {//构造器默认为私有的
        this.name = name;
        this.desc = desc;
    }
    //只有get方法
    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

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

enum 关键字实现枚举注意事项：

（1）当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类, 而且是一个 final 类，在使用doc命令，javac编译时可以看出 是 extends java.long.Enum 。

（2）传统的 public static final Season2 SPRING = new Season2("春天", "温暖"); 简化成 SPRING("春天", "温暖")， 这里必须知道，它调用的是哪个构造器.

（3）如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略

（4）当有多个枚举对象时，使用  , 间隔，最后有一个分号结尾

（5）枚举对象必须放在枚举类的行首.

枚举常用方法：

1) toString:Enum 类已经重写过了，返回的是当前对象

名,子类可以重写该方法，用于返回对象的属性信息

2) name：返回当前对象名（常量名），子类中不能重写

3) ordinal：返回当前对象的位置号，默认从 0 开始

4) values：返回当前枚举类中所有的常量

5) valueOf：将字符串转换成枚举对象，要求字符串必须

为已有的常量名，否则报异常！

6) compareTo：比较两个枚举常量，比较的就是编号！

public class EnumMethod {
    public static void main(String[] args) {
        Season2 season01 = Season2.spring;
        Season2 season02 = Season2.summer;
        Season2 season03 = Season2.autumn;
        Season2 season04 = Season2.winter;
        //toString:Enum 类已经重写过了，返回的是当前对象 名,子类可以重写该方法，用于返回对象的属性信息
        //name：返回当前对象名（常量名），子类中不能重写
        System.out.println(season01.name());
        System.out.println("===============================");
        //ordinal：返回当前对象的位置号，默认从 0 开始
        System.out.println(season03.ordinal());
        System.out.println(season02.ordinal());
        System.out.println("===============================");
        //values：返回当前枚举类中所有的常量  (被隐藏，在反编译中可找到)
        Season2 [] values = Season2.values();
        for(Season2 season2 : values){
            System.out.println(season2);
        }
        /*
         *int nums[] = {1,3,9}
         *
         * 普通for循环:
         * for(int i = 0; i < numss.length;i++){
         *    System.out.println(nums[i]);
         *  }
         *
         *
         * 增强for循环:
         * for(int i : nums){
         *    System.out.println(i)
         */
        System.out.println("===============================");
        //valueOf：将字符串转换成枚举对象，要求字符串必须 为已有的常量名，否则报异常！
        Season2 voSeason = Season2.valueOf("summer");
        System.out.println(voSeason);
        System.out.println("===============================");
        //compareTo：比较两个枚举常量，比较的就是编号！
        System.out.println(season01.compareTo(season04));
        /*
        compareTo源码:
        public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }
         */
    }
}