java基础 - 枚举

精选原创

生而为人我很遗憾 2022-10-10 15:03:25 博主文章分类：java ©著作权

©著作权归作者所有：来自51CTO博客作者生而为人我很遗憾的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、基础用法

枚举类型自动继承java.lang.Enum。它的ordinal()方法返回一个Int值，指向enum实例在声明时的次序，从0开始。可以使用==来比较enum实例，编译器会自动为你提供equals()和hashCode()方法。Enum类实现了Comparable接口，所以具有compareTo()方法，同时它还实现了Serializable接口。

1.1、遍历

public class EnumClass {
    public static void main(String[] args) {
        //遍历枚举

        /*
        GROUND ordinal: 0 
        -1
        false
        false
        class com.zd.thread.Shrubbery
        GROUND
        */
        for(Shrubbery s : Shrubbery.values()) {
            System.out.println(s + " ordinal: " + s.ordinal()); // 枚举的位置
            System.out.println(s.compareTo(Shrubbery.CRAWLING) + " "); //比较返回-1，0，1
            System.out.println(s.equals(Shrubbery.CRAWLING) + " "); //比较值回bool
            System.out.println(s == Shrubbery.CRAWLING); //如果只有一个值则和equals一样的效果
            System.out.println(s.getDeclaringClass()); //
            System.out.println(s.name());
        }
        System.out.println("----------------------");
        EnumClass.ite();
    }

    public static void ite(){
        for(String s : "HANGING CRAWLING GROUND".split(" ")) {
            Shrubbery shrub = Enum.valueOf(Shrubbery.class, s);//注意valueOf的使用
            System.out.println(shrub); //HANGING CRAWLING GROUND
        }
    }
}
enum Shrubbery { GROUND, CRAWLING, HANGING

1.2、添加方法

这种写法有两点需要注意：1、构造函数（必须）；2、getter方法是可选的，但一般也要写上，不然没法调用

/**
 * @Title: com.zd.thread.GoodsCommandEnum 
 * @Description 这种方式不是太可取，会形成大量的枚举类，建议可以通过接口的方式来实现
 * @author liudong
 * @date 2022-10-10 3:18 p.m.
 */
public enum GoodsCommandEnum {
    Pass("pass", "通过"),
    Hidden("hidden", "隐藏"),
    Delete("delete", "删除"),
    Descend("descend", "降权"),
    Unknown("unknown","未知");

    private String commandName;

    private String btnName;

    GoodsCommandEnum(String commandName, String btnName) {
        this.commandName = commandName;
        this.btnName = btnName;
    }
    //GoodsCommandEnum.Pass.commandCode();
    public String commandCode() {
        return this.commandName;
    }

    //GoodsCommandEnum.Pass.commandName();
    public String commandName(){
        return this.btnName;
    }
}

1.3、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 GREEN:
                color = Signal.YELLOW;
                break;
            case YELLOW:
                color = Signal.RED;
                break;
        }
    }

}

二、枚举的组织

2.1、泛型

这种用法可以在接口中多定义几个泛型方法，这样就可以实现一个类工厂的效果。在一定程度上可以取代模板方法的设计模式。

//接口定义
public interface Generator<T> {
    T next();
} 

//接口实现，也可以把CartoonCharacter做为一个接口的内部类实现，这样更有利于组织接口
enum CartoonCharacter implements Generator<CartoonCharacter> {
    SLAPPY, SPANKY, PUNCHY, SILLY, BOUNCY, NUTTY, BOB;
    private Random rand = new Random(47);

    @Override
    public CartoonCharacter next() {
        return values()[rand.nextInt(values().length)];
    }
}

class EnumImplementation {
    public static <T> void printNext(Generator<T> rg) {
        System.out.print(rg.next() + ", ");
    }

    public static void main(String[] args) {
        // Choose any instance:
        CartoonCharacter cc = CartoonCharacter.BOB;
        for (int i = 0; i < 10; i++) {
            printNext(cc);
        }

    }
}

实现一个枚举泛型随机器

public class Enums {
    private static Random rand = new Random(47);
    public static <T extends Enum<T>> T random(Class<T> ec) {
        return random(ec.getEnumConstants());
    }
    public static <T> T random(T[] values) {
        return values[rand.nextInt(values.length)];
    }
}
enum Activity { SITTING, LYING, STANDING, HOPPING,
    RUNNING, DODGING, JUMPING, FALLING, FLYING }

public class RandomTest {
    public static void main(String[] args) {
        for(int i = 0; i < 20; i++)
            System.out.print(Enums.random(Activity.class) + " ");
    }
}

2.2、包装器

2.2.1、接口包装枚举

这种方法建议用在常量的声明上，因为在实际使用上很少用这种方式实现对象的层次结构。

public interface Food {
    enum Appetizer implements Food {
        SALAD, SOUP, SPRING_ROLLS;
    }
    enum MainCourse implements Food {
        LASAGNE, BURRITO, PAD_THAI,
        LENTILS, HUMMOUS, VINDALOO;
    }
    enum Dessert implements Food {
        TIRAMISU, GELATO, BLACK_FOREST_CAKE,
        FRUIT, CREME_CARAMEL;
    }
    enum Coffee implements Food {
        BLACK_COFFEE, DECAF_COFFEE, ESPRESSO,
        LATTE, CAPPUCCINO, TEA, HERB_TEA;
    }
} ///:~

public class TypeOfFood {
    public static void main(String[] args) {
        Food food = Appetizer.SALAD;
        food = MainCourse.LASAGNE;
        food = Dessert.GELATO;
        food = Coffee.CAPPUCCINO;
    }
}

2.2.2、枚举包装枚举

可以和泛型一起使用，实现简单的类层次结构，也可以用于结构化数据的验证功能。

public enum Course {
    APPETIZER(Food.Appetizer.class),
    MAINCOURSE(Food.MainCourse.class),
    DESSERT(Food.Dessert.class),
    COFFEE(Food.Coffee.class);
    private Food[] values;
    private Course(Class<? extends Food> kind) {
        values = kind.getEnumConstants();
    }
    public Food randomSelection() {
        return Enums.random(values);
    }
}

三、高级用法

3.1、EnumSet

属于枚举的一个增强功能吧，因为set集合只允许存放值，所以可扩展性不太多。但可以组织多状态值，类似mysql的in的用法。

enum AlarmPoints {
    STAIR1, STAIR2, LOBBY, OFFICE1, OFFICE2, OFFICE3,
    OFFICE4, BATHROOM, UTILITY, KITCHEN
}
public class EnumSets {
    public static void main(String[] args) {
        // Empty set
        EnumSet<AlarmPoints> points = EnumSet.noneOf(AlarmPoints.class);

        //[BATHROOM]
        points.add(BATHROOM);

        //[STAIR1, STAIR2, BATHROOM, KITCHEN]
        points.addAll(EnumSet.of(STAIR1, STAIR2, KITCHEN));
        
        //[LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY]
        points = EnumSet.allOf(AlarmPoints.class);
        points.removeAll(EnumSet.of(STAIR1, STAIR2, KITCHEN));

        //[LOBBY, BATHROOM, UTILITY]
        points.removeAll(EnumSet.range(OFFICE1, OFFICE4));

        //[STAIR1, STAIR2, OFFICE1, OFFICE2, OFFICE3, OFFICE4, KITCHEN]
        points = EnumSet.complementOf(points);
    }
}

3.2、EnumMap

可以实现命令模式。

enum AlarmPoints {
    STAIR1, STAIR2, LOBBY, OFFICE1, OFFICE2, OFFICE3,
    OFFICE4, BATHROOM, UTILITY, KITCHEN
}

interface Command { void action(); }

public class EnumMaps {
    public static void main(String[] args) {
        EnumMap<AlarmPoints,Command> em = new EnumMap<AlarmPoints,Command>(AlarmPoints.class);
        em.put(AlarmPoints.KITCHEN, new Command() {
            @Override
            public void action() {
                System.out.println("Kitchen fire!"); }
        });
        em.put(AlarmPoints.BATHROOM, new Command() {
            @Override
            public void action() { System.out.println("Bathroom alert!"); }
        });

        for(Map.Entry<AlarmPoints,Command> e : em.entrySet()) {
            e.getValue().action();
        }
    }
}

3.3、常量方法

ENUM允许程序为它的实例编写方法，从而为每个enum实例赋予各不相同的行为。这需要为enum定义一个或多个abstract方法，然后为每个enum实例实现该抽象方法。因为每个枚举值相当于定义的枚举的子类，所以要实现其抽象方法。

public enum ConstantSpecificMethod {
    DATE_TIME {//类为这相当于ConstantSpecificMethod的实例，所以要实现其抽象方法
        @Override
        String getInfo() {
            return DateFormat.getDateInstance().format(new Date());
        }
    },
    CLASSPATH {
        @Override
        String getInfo() {
            return System.getenv("CLASSPATH");
        }
    },
    VERSION {
        @Override
        String getInfo() {
            return System.getProperty("java.version");
        }
    };

    abstract String getInfo();

    public static void main(String[] args) {
        for(ConstantSpecificMethod csm : values()){
            System.out.println(csm.getInfo());
        }
    }
}