javaSE学习：第十九章、枚举

1、定义：

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

2、实现：

1、构造器私有化。
2、本类内部创建一组对象。
3、对外暴露对象（为对象添加public final static修饰符）。
4、不能提供set方法。

1、自定义枚举方法：

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class Enum {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
    }
}

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("冬天","寒冷");

    // 1、构造器私有化。
    // 2、删除set方法。
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

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

2、enum关键字实现枚举：

• 如果使用enum来实现枚举
  * 1、enum关键字代替class。
  * 2、直接写常量名，多个用逗号间隔。
  * 3、要将定义的常量对象写在类最前面。
  * 4、构造器私有化。
  * 5、不用set方法。
  * 6、如果使用无参构造器实现枚举，那么实参列表和小括号都可以省略。

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class Enum {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }
}

enum Season {
    /*
    * 如果使用enum来实现枚举
    * 1、enum关键字代替class。
    * 2、直接写常量名，多个用逗号间隔。
    * 3、要将定义的常量对象写在前面。
    * 4、构造器私有化。
    * 5、不用set方法。
    * */
    SPRING("春天","温暖"),SUMMER("夏天","炎热");
    private String name;
    private String desc;
    
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

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

作业：

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class HomeWork {
    public static void main(String[] args) {
        People people1 = People.BOY;
        People people2 = People.BOY;
        /*
        enum继承了java.lang.Enum类，里面重写了toString方法,直接返回name
        *public String toString() {
            return name;
         }
        *
        System.out.println(people1); 本质是调用它的父类的toString方法。
        */
        System.out.println(people1);  // BOY
        /*
        * 为何两个相等：
        * 以为虽然new了两次，但是因为是static修饰的静态变量，所以地址值是一样的。
        * */
        System.out.println(people1 == people2); // true
    }
}

enum People {
    BOY,GIRL;
}

//class People {
    BOY,GIRL;
//    public static final People BOY = new People();
//}

枚举方法：

因为枚举继承了Enum，因此可以使用里面的方法：

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class EnumMethod {
    public static void main(String[] args) {
        Season season = Season.AUTUMN;
        // 1、name：返回当前对象名。
        System.out.println(season.name());  //AUTUMN

        // 2、ordinal：返回当前对象的位置号，默认从0开始排序。
        System.out.println(season.ordinal());  // 2 AUTUMN拍第三个，因此是2

        // 3、values：返回当前枚举类中所有常量，数组类型
        Season[] values = season.values();
        // 增强for循环：快捷键values.iter
        for (Season value : values) {
            System.out.println(value);
        }

        // 4、valueOf：将字符串转换为枚举对象，但是要求该字符串是枚举类中已有的常量。
        System.out.println(season.valueOf("WINTER"));

        // 5、compareTo：比较两个枚举常量，比较的是编号。
        // 两个常量的序号相减：AUTUMN - SPRING = 2 - 0 = 2
        System.out.println(Season.AUTUMN.compareTo(Season.SPRING));  // 2
    }
}

作业：

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class EnumHomeWork {
    public static void main(String[] args) {
        Week[] weeks = Week.values();
        for (Week week : weeks) {
            System.out.println(week);
        }
    }
}

enum Week {
    MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),THURSDAY("星期四"),
    FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");
    private String name;

    Week(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

enum细节：

1、使用了enum关键字之后，不能再继承其它类了，以为enum会隐式继承Enum，java是单继承机制。
2、枚举类和普通类一样，可以实现接口，但是也要实现接口的方法。

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class Detail {
    public static void main(String[] args) {
        Music.ANCIENT_MUSIC.playing();
    }
}

interface IP {
    void playing();
}

enum Music implements IP {
    ANCIENT_MUSIC;

    @Override
    public void playing() {
        System.out.println("播放好听的音乐");
    }
}

枚举和Switch：

package com.hsf.extends_.enumeration_;/*
 * @author HSF
 * @version 8.0
 */

public class EnumHomeWork2 {
    public static void main(String[] args) {
        Color red = Color.RED;
        red.show();

        switch (red) {
            case RED:
                System.out.println("这是红色");
                break;
            case YELLOW:
                System.out.println("这是黄色");
                break;
            default :
                System.out.println("没有匹配到");
            }

        }
    }


enum Color implements IAColor{

    RED(255,0,0),YELLOW(0,255,0);
    private int redValue;
    private int greenValue;
    private int blueValue;

    Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    @Override
    public void show() {
        System.out.println(redValue + " " + greenValue + " " + blueValue);
    }
}

interface IAColor {
    void show();
}