Java面向对象_23 枚举

---

枚举类型定义

枚举其实就是有固定实例个数的类。

当我们定义枚举类型时，其实就是定义了一个类，只不过很多细节都由编译器自动补齐了。定义枚举类型时使用enum关键字，定义的枚举类型默认继承于java.lang.Enum类。每个枚举成员都是这个枚举类型的实例，它们都默认由public static final修饰，也就是说，这些成员都是常量，无法被修改，可以通过 类名.成员名的方式直接使用。

所以，枚举的定义为：
枚举类型（enum type）是指由一组固定的常量组成合法的类型，Java 中由关键字 enum 来定义一个枚举类型。

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

上面就是定义枚举类型的写法，由于其中的成员是常量，所以规范大写字母，成员之间用逗号分隔，结尾用分号。

枚举的使用

定义枚举类

public enum Season {
	//枚举必须写在最前面，否则会报编译错误
    SPRING("春"), SUMMER("夏"), AUTUMN("秋"), WINTER("冬");

    public static final String str = "季";

    private String name;

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

    public void show(){
        System.out.println(this.name + str);
    }
}

对于枚举的定义，有以下几点注意：

1. 对于赋值，要么都赋值，要么都不赋值，否则报编译错误；
2. 通过括号赋值，赋值必须都是同一种类型，否则报编译错误；
3. 若通过括号赋值，必须带有一个有参构造器，否则会有编译错误；若不赋值则不能写构造器，否则也会报编译错误。
4. 构造器默认只能是private，从而保证构造函数只能在内部使用，这样这个类也就不能够通过new的方式去创建实例了。

使用枚举对象

    public static void main(String[] args) {
        Season s1 = Season.SPRING;
        Season s2 = Season.SUMMER;
        Season s3 = Season.AUTUMN;
        Season s4 = Season.WINTER;
        s1.show();
        s2.show();
        s3.show();
        s4.show();
    }
}

直接通过 类名.枚举常量名的方式获取对象。

我们还可以设计带抽象方法的枚举，这样所有的枚举对象都需要实现该抽象方法。

public enum Season {
    SPRING{
        @Override
        public String getName() {
            return "春天";
        }
    }, SUMMER{
        @Override
        public String getName() {
            return "夏天";
        }
    }, AUTUMN{
        @Override
        public String getName() {
            return "秋天";
        }
    }, WINTER{
        @Override
        public String getName() {
            return "冬天";
        }
    };
    
    public abstract String getName();//此枚举的抽象方法
}

    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring.getName());
    }

枚举类常用API的使用

方法	说明
values()	取得所有的枚举成员实例，并以数组方式返回
compareTo()	比较两个对象在枚举时的顺序。
ordinal()	根据枚举顺序得到索引位置，默认从0开始

	//values()的使用
    public static void main(String[] args) {
        Season[] seasons = Season.values();
        for (int i = 0; i < seasons.length; i++) {
            seasons[i].show();
        }
    }

	//ordinal()
    public static void main(String[] args) {
        Season[] seasons = Season.values();
        for (int i = 0; i < seasons.length; i++) {
            System.out.println(seasons[i].ordinal());
        }
    }

	//compareTo()
    public static void main(String[] args) {
        Season s1 = Season.SPRING;
        Season s2 = Season.SUMMER;
        Season s3 = Season.AUTUMN;
        Season s4 = Season.WINTER;
        System.out.println(s1.compareTo(s4));
        System.out.println(s4.compareTo(s1));
    }

枚举的应用场景

以下摘自Hollis的《Java工程师成神之路》基础篇

用法一：用于作为常量

public enum Color { RED, GREEN, BLANK, YELLOW }

用法二：用于switch选项

    enum Signal {GREEN, YELLOW, RED}

    public class TrafficLight {
        Signal color = Signal.RED;

        public void change() {
            switch (color) {
                case RED:
                    color = Signal.GREEN;
                    break;
                case YELLOW:
                    color = Signal.RED;
                    break;
                case GREEN:
                    color = Signal.YELLOW;
                    break;
            }
        }
    }

用法三：向枚举中添加新方法

public enum Color {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量
        private String name;
        private int index;

        // 构造方法
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }

        // 普通方法 
        public static String getName(int index) {
            for (Color c : Color.values()) {
                if (c.getIndex() == index) {
                    return c.name;
                }
            }
            return null;
        }

        // get set 方法 
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }
    }

用法四：覆盖枚举的方法

   public enum Color {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量 
        private String name;
        private int index;

        // 构造方法 
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }

        //覆盖方法
        @Override
        public String toString() {
            return this.index + "_" + this.name;
        }
    }

用法五：实现接口

public interface Behaviour {
        void print();

        String getInfo();
    }

    public enum Color implements Behaviour {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量 
        private String name;
        private int index;

        // 构造方法
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }

        //接口方法
        @Override
        public String getInfo() {
            return this.name;
        }

        //接口方法 
        @Override
        public void print() {
            System.out.println(this.index + ":" + this.name);
        }
    }

用法六：使用接口组织枚举

    public interface Food {
        enum Coffee implements Food {BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO}

        enum Dessert implements Food {FRUIT, CAKE, GELATO}
    }