枚举

最新推荐文章于 2021-09-16 10:24:16 发布
最新推荐文章于 2021-09-16 10:24:16 发布
阅读量428 收藏
点赞数
分类专栏： java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xylyaya/article/details/104992074
版权 
public enum Spiciness {
    NOT,MILD,MEDIUM,HOT,FLAMING
}

这里创建了一个Spiciness的枚举类型，它有5个具名值。枚举类型的实例是常量，用大写字母表示。

 

public class SimpleEnumUse {
    public static void main(String[] args) {
        Spiciness spiciness=Spiciness.HOT;
        System.out.println(spiciness); 

        for(Spiciness s:Spiciness.values()){
            System.out.println(s+" ordinal "+s.ordinal());
        }
    }
}

ordinal()方法表示某个特定的enum常量的声明顺序（从0开始）；

values()方法按照常量的声明顺序，生成由这些常量值构成的数组。

name()方法返回enum实例声明时的名字，这与使用toString()效果相同。

valueOf()是在Enum中定义的static方法，根据给定的名字返回相应的enum实例。

 

public class Burrito {
    Spiciness degree;
    public Burrito(Spiciness degree){
        this.degree=degree;
    }
    public void describe(){
        System.out.println("This burrito is : ");
        switch (degree){
            case NOT:
                System.out.println("NOT");
                break;
            case MILD:
                System.out.println("MILD");
                break;
            case MEDIUM:
                System.out.println("MEDIUM");
                break;
            case HOT:
                System.out.println("HOT");
                break;
            case FLAMING:
                System.out.println("FLAMING");
                break;
        }
    }
    public static void main(String[] args) {
        Burrito
                burrito=new Burrito(Spiciness.HOT),
                burrito1=new Burrito(Spiciness.MILD),
                burrito2=new Burrito(Spiciness.FLAMING);
        burrito.describe();
        burrito1.describe();
        burrito2.describe();
    }
}

由于switch是要在有限的集合中进行选择，所以与enum正式绝佳的组合。

 

public class OzWitchTest {
    public static void main(String[] args) {
        for (OzWitch o:OzWitch.values()){
            System.out.println(o+" : "+o.getDescription());
        }
    }
}

每个枚举实例返回对自身的描述。提供一个构造器，专门负责这个额外的信息，然后提供一个方法，返回这个描述信息。

定义自己的方法，必须在enum实例序列的最后添加一个分号，同时必须先定义enum实例。

enum中的构造器和方法与普通的类没有区别。

 

public enum  SpaceShip {
    AA,BB,CC,DD,EE;

    @Override
    public String toString() {
        String name = name();
        String s = name.substring(1).toLowerCase();
        return name.charAt(0)+s;
    }

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

覆盖enum的toString()方法。通过调用name()方法取得SpaceShip的名字，然后修改为只有首字母大写的格式。

 

public class TrafficLight {
    enum Signal{
        RED,GREEN,YELLOW
    }
    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;
        }
    }

    @Override
    public String toString() {
        return "The trafficLight is "+color;
    }

    public static void main(String[] args) {
        TrafficLight t=new TrafficLight();
        for(int i=0;i<7;i++){
            System.out.println(t);
            t.change();
        }
    }
}

这里构造了一个小型状态机。

 

enum Search{HITHER,YON}

public class UpcastEnum {
    public static void main(String[] args) {
        Search[] vals=Search.values();
        Enum e=Search.HITHER; //Upcast
        //e.values(); Enum没有values()方法
        for(Enum en:e.getClass().getEnumConstants()){
            System.out.println(en);
        }
    }
}

values()方法是由编译器添加的static方法。如果将enum实例向上转型为Enum，那么values()方法则不可访问。

Class中的getEnumConstants()方法可以获取enum所有实例。

 

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)+" ");
        }
    }
}

从枚举实例中进行随机选取。

Enums中将Class<T>作为参数，利用Class对象获得enum实例的数组，然后用重载后的random()方法，从数组中随机选取一个元素。

 

public enum SecurityCategory {
    STOCK(Security.Stock.class),
    BOND(Security.Bond.class);

    Security[] values;
    SecurityCategory(Class<? extends Security> kind){
        values=kind.getEnumConstants(); //获得枚举所有实例
    }

    interface Security{
        enum Stock implements Security {SHORT,LONG,MARGIN}
        enum Bond implements Security {MUNICIPAL,JUNK}
    }

    public Security randomSelection(){
        return Enums.random(values); //随机选取实例
    }

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            SecurityCategory category=Enums.random(SecurityCategory.class); //随机选取实例
            System.out.println(category+" : "+category.randomSelection());
        }
    }
}

枚举中嵌套枚举。对于枚举而言，实现接口是使其子类化的唯一方法。

 

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

EnumSet适用于枚举的集合，其中的元素必须来自一个enum。

 

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!");
            }
        });
        em.put(AlarmPoints.LOBBY, new Command() {
            @Override
            public void action() {
                System.out.println("Lobby run!");
            }
        });
        for(Map.Entry<AlarmPoints,Command> entry:em.entrySet()){
            System.out.println(entry.getKey()+" ："+entry.getValue());
            entry.getValue().action();
        }
        try{
            em.get(AlarmPoints.UTILITY).action();
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

EnumMap其中的key必须来自一个enum。没有为key调用put()方法来存入值得话，其对应值就是null。

 

public enum ConstantSpecificMethod {
    DATE_TIME{
        @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:ConstantSpecificMethod.values()){
            System.out.println(csm.getInfo());
        }
    }
}

为enum实例编写方法，为每个enum实例赋予各自不同的行为。

 

这里编写一个石头剪刀布游戏。

enum Outcome {
    WIN,LOSE,DRAW
}

public interface Item {
    Outcome compete(Item item);
    Outcome eval(Paper paper);
    Outcome eval(Scissors scissors);
    Outcome eval(Rock rock);
}

class Paper implements Item{
    @Override
    public Outcome compete(Item item) {
        return item.eval(this);
    }
    @Override
    public Outcome eval(Paper paper) {
        return Outcome.DRAW;
    }
    @Override
    public Outcome eval(Scissors scissors) {
        return Outcome.WIN;
    }
    @Override
    public Outcome eval(Rock rock) {
        return Outcome.LOSE;
    }

    @Override
    public String toString() {
        return "布";
    }
}

class Scissors implements Item{
    @Override
    public Outcome compete(Item item) {
        return item.eval(this);
    }
    @Override
    public Outcome eval(Paper paper) {
        return Outcome.LOSE;
    }
    @Override
    public Outcome eval(Scissors scissors) {
        return Outcome.DRAW;
    }
    @Override
    public Outcome eval(Rock rock) {
        return Outcome.WIN;
    }

    @Override
    public String toString() {
        return "剪刀";
    }
}

class Rock implements Item{
    @Override
    public Outcome compete(Item item) {
        return item.eval(this);
    }
    @Override
    public Outcome eval(Paper paper) {
        return Outcome.WIN;
    }
    @Override
    public Outcome eval(Scissors scissors) {
        return Outcome.LOSE;
    }
    @Override
    public Outcome eval(Rock rock) {
        return Outcome.DRAW;
    }

    @Override
    public String toString() {
        return "石头";
    }
}
public class RoShamBo1 {
    static final int SIZE=10;
    private static Random random=new Random(66);
    public static Item newItem(){
        switch (random.nextInt(3)){
            default:
            case 0:
                return new Paper();
            case 1:
                return new Scissors();
            case 2:
                return new Rock();
        }
    }
    public static void match(Item a,Item b){
        System.out.println(a+" vs "+b+" : "+a.compete(b));
    }

    public static void main(String[] args) {
        for(int i=0;i<SIZE;i++){
            match(newItem(),newItem());
        }
    }
}

 

public interface Competitor<T extends Competitor<T>> {
    Outcome compete(T competitor);
}
public class RoShamBo {
    public static <T extends Competitor<T>> void match(T a,T b){
        System.out.println(a+" vs "+b+" : "+a.compete(b));
    }
    public static <T extends Enum<T> & Competitor<T>> void play(Class<T> rsbClass,int size){
        for(int i=0;i<size;i++){
            match(Enums.random(rsbClass),Enums.random(rsbClass));//随机选取两个实例
        }
    }
}
public enum RoShamBo2 implements Competitor<RoShamBo2> {
    PAPER(DRAW,LOSE,WIN), //顺序很重要
    SCISSORS(WIN,DRAW,LOSE), //与构造器的形参对应
    ROCK(LOSE,WIN,DRAW);

    private Outcome vPAPER,vSCISSORS,vROCK;
    RoShamBo2(Outcome paper,Outcome scissors,Outcome rock){
        vPAPER=paper;
        vSCISSORS=scissors;
        vROCK=rock;
    }

    @Override
    public Outcome compete(RoShamBo2 competitor) {
        switch (competitor){
            default:
            case PAPER:return vPAPER;
            case ROCK:return vROCK;
            case SCISSORS:return vSCISSORS;
        }
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo2.class,10);
    }
}

 

利用构造器初始化每个enum实例，并以“一组”结果作为参数。

比如PAPER vs SCISSORS，match()方法中a是PAPER ，b是SCISSORS，由于重写了compete()方法，返回vSCISSORS。构造器初始化了每个enum实例，PAPER中vSCISSORS是第二位，也就是LOSE。

 

public enum RoShamBo5 implements Competitor<RoShamBo5> {
    PAPER,SCISSORS,ROCK;
    static EnumMap<RoShamBo5,EnumMap<RoShamBo5,Outcome>>
            table=new EnumMap<RoShamBo5, EnumMap<RoShamBo5, Outcome>>(RoShamBo5.class);
    static {
        for(RoShamBo5 it:RoShamBo5.values()){
            table.put(it,new EnumMap<RoShamBo5, Outcome>(RoShamBo5.class));
        }
        initRow(PAPER,Outcome.DRAW,Outcome.LOSE,Outcome.WIN);
        initRow(SCISSORS,Outcome.WIN,Outcome.DRAW,Outcome.LOSE);
        initRow(ROCK,Outcome.LOSE,Outcome.WIN,Outcome.DRAW);
    }
    static void initRow(RoShamBo5 it,Outcome vPAPER,Outcome vSCISSORS,Outcome vROCK){
        EnumMap<RoShamBo5,Outcome> row=RoShamBo5.table.get(it);
        row.put(RoShamBo5.PAPER,vPAPER);
        row.put(RoShamBo5.SCISSORS,vSCISSORS);
        row.put(RoShamBo5.ROCK,vROCK);
    }
    @Override
    public Outcome compete(RoShamBo5 it) {
        return table.get(this).get(it);
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo5.class,10);
    }
}

 

import static enum_test.Outcome.*;
public enum RoShamBo6 implements Competitor<RoShamBo6> {
    PAPER,SCISSORS,ROCK;
    private static Outcome[][] table={
            {DRAW,LOSE,WIN},//PAPER
            {WIN,DRAW,LOSE},//SCISSORS
            {LOSE,WIN,DRAW}//ROCK
    };
    @Override
    public Outcome compete(RoShamBo6 competitor) {
        return table[this.ordinal()][competitor.ordinal()];
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo6.class,10);
    }
}

Reverse train.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组与枚举
m0_46772476的博客
06-08 1306
一、数组 （不是基本的数据类型，属于引用数据类型，类似String或者自己写的Person） 数组是一个特殊的对象，用于存放一组相同类型的数据。 int arr [] = {1,2,4,5}; 二、创建数组（数组一旦创建，其大小保持不变） 1.声明数组 ArrayType arrayName[]; 数据类型 数组名 方括号[]（方括号在数组名前后均可） 如：float boy[]; 2.分配内存空间 两种方式： （1）new关键字分配内存空间 arrayName = new ArrayType[size];
c语言之数组应用
往事流年的博客
09-04 4676
所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。 目录 数组作...
数组实用类Arrays和枚举类型Enum
余心所善
04-07 7306
一、数组使用类Arrays1.在java.util包中，Arrays提供了一系列静态方法，帮助操作数组。以下是较常用的一些方法。 （1） equals方法，比较两个数组参数是否相同。 （2） fill方法，向数组中填充数据参数。 （3） binarySearch方法，查找数组中元素的值与给定数据相同的元素。 （4） sort方法，将数组按升序排列。 （5） copyOfRange方法，将数组的指定范
【TS】enum 枚举（含数字枚举转数组方法）
热门推荐
qq_45677671的博客
09-16 1万+
枚举的功能类似于字面量类型+联合类型组合的功能，也可以表示一组明确的可选值。数字枚举: 枚举成员的值为数字的枚举。字符串枚举：枚举成员的值是字符串。
Java中枚举类enum的values()方法的详解
爱科比的博客
10-07 8188
关于枚举，相信使用的已经很普遍了，现在主要写的是枚举中的一个特殊方法，values()， 为什么说特殊呢，因为在Enum 的 API 文档中也找不到这个方法。接下来就看看具体的使用。 理论上此方法可以将枚举类转变为一个枚举类型的数组，因为枚举中没有下标，我们没有办法通过下标来快速找到需要的枚举类，这时候，转变为数组之后，我们就可以通过数组的下标，来找到我们需要的枚举类。接下来就展示代码...
C++ SerialEnum 串口枚举实例
07-12
`SerialEnum`在C++中通常指的是一个用于枚举计算机上可用串口的程序或类。在这个实例中，我们将深入探讨如何使用C++实现串口枚举功能，并了解相关的关键知识点。 首先，我们需要理解串口的基础知识。串行接口，简称...
易语言枚举串口
08-21
易语言枚举串口源码系统结构:注册表操作_打开注册表项,注册表操作_枚举子键,注册表操作_关闭键,注册表操作_枚举键值,DLL命令1, ======窗口程序集1 || ||------__启动窗口_创建完毕 || || =
Java枚举类的使用与注解
01-20
Java枚举类是Java语言中一个非常重要的特性，它用于创建固定的、有限数量的类实例。枚举类在很多场景下被用作定义一组相关的常量，提供了比使用静态final变量更安全、更灵活的方式。 一、枚举类的理解： 1. 枚举类...
详细了解C# 枚举与位枚举
12-17
一、枚举的概念： 　C# 枚举（Enum）, 枚举类型是用于声明一组命名的常数的基本数据类型（值类型）； 二、枚举的定义： 　声明enum变量： enum <enum> {enumeration list}; 　其中enum_name 指定枚举的类型名称； ...
自己整理的目录枚举工具
09-01
目录枚举是信息技术领域中一个基础且重要的概念，主要用于遍历和检索文件系统中的目录结构。在编程和系统管理中，目录枚举工具扮演着关键角色，帮助用户快速、高效地获取目录信息，包括文件名、大小、创建时间、修改...
简述C#枚举高级战术
12-16
【C# 枚举高级战术】 在C#中，枚举（Enumeration）是一种强大的工具，用于定义一组相关的命名常量。这些常量通常用于表示有限的、预定义的集合，如颜色、星期几或者状态等。在处理角色或权限这样的多值场景时，枚举...
C# 枚举转换操作
12-22
Enum为枚举提供基类，其基础类型可以是除 Char 外的任何整型。如果没有显式声明基础类型，则使用 Int32。编程语言通常提供语法来声明由一组已命名的常数和它们的值组成的枚举。 　注意：枚举类型的基类型是除 Char ...
TypeScript枚举
01-06
枚举(Enum)类型用于取值被限定在一定范围内的场景 定义一个枚举如下所示 enum Days{ Sun, Mon, Tue, Wed, Thu, Fri, Sat } console.log(Days.Sun) console.log(Days.Sat) 执行如上代码我们可以看到控制台会...
Java枚举使用方法详解
08-29
Java枚举（enum）是Java语言中的一种特殊类，它用于定义一组固定的常量，这些常量在程序中是不可变的。枚举提供了一种更安全、更规范的方式来表示有限集合的数据。以下是对Java枚举使用方法的详细说明： 1. **普通...
java中枚举入门_Java基础：枚举学习笔记
weixin_32334209的博客
02-28 184
枚举概述枚举(enumeration)是Java1.5引入的新特性，枚举类是一种特殊的类class，通过关键字 enum 来定义。之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。枚举的特性枚举类的构造方法强制被私有化，即枚举类不能实例化所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继...
五、数组与枚举
qq_42601983的博客
03-15 2293
理解数组 数组（Array），顾名思义就是一组数据 一维数组 一维数组的声明与内存的分配 数组中元素的表示方法 数组元素的使用 二维数组 二维数组的声明与赋值 二维数组元素的引用及访问 枚举简介 Java中的枚举 常见的枚举定义方法 在程序中使用枚举 在switch语句中使用枚举 ...
数组枚举部分
sinat_37443796的博客
02-10 1726
数组 1.创建数组 声明数组： int  a[]; 创建数组： a = new a[5]; 声明与创建同时： int a[] = new a[5]; length:使用a.length来获得数组长度，对于二维数组，其值为一维数组的值。例：int b[][] = new b[3][7];  b.length = 3; 初始化：int a[] = {1,2,3,4,5};   相当于
Java枚举深入解析：values方法与枚举特性
"Java中的枚举类型详细介绍，包括values方法的使用、枚举类的特性、枚举实例的方法如ordinal()、compareTo()、equals()、getDeclaringClass()、name()，以及如何通过字符串创建枚举值。" 在Java编程语言中，枚举...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值