精华内容
下载资源
问答
  • typedef enum _SERVER_STATE { SERVER_ERROR = -1, SERVER_MAINTENANCE = 0, SERVER_OK = 1 }SERVER_STATE;
  • Error:(63, 24) 错误: 枚举 switch case 标签必须为枚举常量的非限定名称。 项目当中用到了饼状图,所以用到了开源的图表库,功能相当强大,传送门:XCL_Charts。 这是里面的部分代码: 虽然知道解决办法...

    错误描述:

     

    Error:(63, 24) 错误: 枚举 switch case 标签必须为枚举常量的非限定名称。

    项目当中用到了饼状图,所以用到了开源的图表库,功能相当强大,传送门:XCL_Charts

    这是里面的部分代码:

     

    虽然知道解决办法,也有提醒,因为平时不怎么用枚举。所以出现问题的时候也是不太懂了。

    解决思路:

    那就是查原因咯。

    ​switch case语句:case后的枚举常量,不带枚举类型

    java规定case后面的枚举常量名只能使用unqualified name,switch后已经指定了枚举的类型,case后无需使用全名,而且enum也不存在继承关系

    这个网址解释的非常清楚:

    http://www.xyzws.com/javafaq/can-i-use-an-enum-type-in-java-switch-statement/130

     

     

    展开全文
  • 怎么用枚举是什么? 枚举是一种包含固定常量集的数据类型。 enum就像一个class ,在编译时已知一组固定的实例。 每当需要表示一组固定的常量时,都应使用枚举类型。 其中包括自然枚举类型,例如太阳系中的行星和...

    枚举是什么?为什么用?怎么用?

    枚举是什么?

    枚举是一种包含固定常量集的数据类型。

    enum就像一个class ,在编译时已知一组固定的实例。

    每当需要表示一组固定的常量时,都应使用枚举类型。 其中包括自然枚举类型,例如太阳系中的行星和数据集,在编译时您知道所有可能的值,例如,星期,菜单上的选项,命令行标志等。

    为什么用枚举:

    为什么要使用任何编程语言功能? 我们完全有自己的语言啊,其实是为了

    1. 程序员可以有效和正确地表达计算机可以使用的形式的算法。
    2. 维护人员了解其他人编写的算法并正确进行更改。

    枚举可提高正确性和可读性的可能性,而无需编写很多样板

    枚举的目的:

    比如说你现在声明一个变量
    string week ;要给它赋值,很明显它的值应该是从星期一到星期日,也就是说你只能给它赋这七个中的一个才有意义。
    为了防止用户录入了错误的信息,设置了枚举变量,规定只能选择此变量中的一个值。
    其实这符合微软的一个通常的做法:能不让用户自己录入信息的一般都给出了一大堆的范围,让我们自己选择。
    **枚举主要用于某些有特定意义的东西,**比如具体的方向,星期等特定的内容,让用户只能选择使用这里面的特定的值

    也有用於限定用戶輸入的目的,對防錯有一定的作用

    展开全文
  • tostring方法怎么用两种方法之间的区别? Java枚举有两种方法来检索枚举常量的值: name()和.toString() 。 toString()方法调用name()方法,该方法返回枚举常量的字符串表示形式。 在清单1中,通过在Animal.DOG常量...
    tostring方法怎么用

    tostring方法怎么用

    两种方法之间的区别?

    Java枚举有两种方法来检索枚举常量的值: name().toString() toString()方法调用name()方法,该方法返回枚举常量的字符串表示形式。 在清单1中,通过在Animal.DOG常量方法上调用name()toString()返回的值是DOG

    清单1:动物枚举

    public enum Animal {
        DOG
    }
    
    // Unit test
    assertThat(DOG.toString()).isEqualTo(DOG.name());

    因此,鉴于两种方法返回的值相同,您可能会认为它们可以互换使用,并且在大多数情况下,这是正确的。 但是,这两种方法之间的区别很重要。

    有什么不同?

    name()方法是最终的,因此不能被覆盖,相反, toString()方法是打开的并且可以被覆盖。 实际上,鼓励重写toString()方法。 应该实现它,并返回枚举常量的友好版本。 清单2显示了如何完成此操作。

    清单2:覆盖toString()方法

    public enum Animal {
        DOG {
            public String toString() {
                return "Dog";
            }
        }
    }
    
    // Unit test
    assertThat(DOG.toString()).isNotEqualTo(DOG.name());

    Animal.DOG枚举常量上调用toString()的输出为Dog 因此,现在name()方法和toString()方法不会返回相同的值。

    Java文档怎么说

    让我们更深入地研究一下Java文档,该文档建议:

    大多数程序员应该优先使用toString()方法而不是name()方法,因为toString()方法可能返回更用户友好的名称。

    这就提出了一个问题。 什么时候应该使用.name()方法?

    根据Java文档:

    name()方法主要设计用于特殊情况,在这种情况下正确性取决于获得确切的名称,每个版本的名称都不会改变。

    那么他们指的是什么特殊情况? valueOf()方法可能会给我们提示。 此方法采用String值,并尝试查找与之完全匹配的枚举。 看一下清单3中的代码。

    清单3:valueOf()方法返回DOG

    assertThat(DOG).isEqualTo(Animal.valueOf("DOG"));

    传递给valueOf()方法的String值必须与枚举常量完全匹配,否则将引发IllegalArgumentException

    源代码

    本文的代码示例和单元测试存储在GitHub存储库ReadLearnCode / readlearncode_articles中

    结论

    当基于字符串值填充枚举字段时,这是一种非常有用的方法。 一个可能执行此操作的示例是在反序列化包含枚举常量的JSON文档时。 在这种情况下,应使用name()方法以保持往返等效性。

    您不能保证toString()方法不会被覆盖,但是name()方法将始终返回枚举的字符串等效项。

    进一步阅读

    您可能对我的文章“策略模式的枚举实现”感兴趣。

    翻译自: https://www.javacodegeeks.com/2017/09/enum-use-name-tostring-methods-correctly.html

    tostring方法怎么用

    展开全文
  • 恕我直言,我怀疑你没怎么用枚举

    千次阅读 多人点赞 2020-03-17 09:54:51
    我们是否一样? 估计很多小伙伴(也包括我自己)都有这种情况,在自学Java语言看书时,关于枚举enum这一块的知识点可能都有点 “轻敌” ,觉得这块内容非常简单,一带而过,而且在实际写代码过程中也不...为啥非得...

    Profile


    我们是否一样?

    估计很多小伙伴(也包括我自己)都有这种情况,在自学Java语言看书时,关于枚举enum这一块的知识点可能都有点 “轻敌” ,觉得这块内容非常简单,一带而过,而且在实际写代码过程中也不注意运用。

    是的,我也是这样!直到有一天我提的代码审核没过,被技术总监一顿批,我才重新拿起了《Java编程思想》,把枚举这块的知识点重新又审视了一遍。


    为什么需要枚举

    常量定义它不香吗?为啥非得用枚举?

    举个栗子,就以B站上传视频为例,视频一般有三个状态:草稿审核发布,我们可以将其定义为静态常量

    public class VideoStatus {
        
        public static final int Draft = 1; //草稿
        
        public static final int Review = 2; //审核
        
        public static final int Published = 3; //发布
    }
    

    对于这种单值类型的静态常量定义,本身也没错,主要是在使用的地方没有一个明确性的约束而已,比如:

    void judgeVideoStatus( int status ) {
        
        ...
        
    }
    

    比如这里的 judgeVideoStatus 函数的本意是传入 VideoStatus 的三种静态常量之一,但由于没有类型上的约束,因此传入任意一个int值都是可以的,编译器也不会提出任何警告。

    但是在枚举类型出现之后,上面这种情况就可以用枚举严谨地去约束,比如用枚举去定义视频状态就非常简洁了:

    public enum VideoStatus {
        Draft, Review, Published
    }
    

    而且主要是在用枚举的地方会有更强的类型约束

    // 入参就有明确类型约束
    void judgeVideoStatus( VideoStatus status ) {
        
        ...
        
    }
    

    这样在使用 judgeVideoStatus 函数时,入参类型就会受到明确的类型约束,一旦传入无效值,编译器就会帮我们检查,从而规避潜在问题。

    除此之外,枚举在扩展性方面比普常量更方便、也更优雅。


    重新系统认识一下枚举

    还是拿前文《答应我,别再if/else走天下了可以吗》中的那个例子来说:比如,在后台管理系统中,肯定有用户角色一说,而且角色一般都是固定的,适合定义成一个枚举:

    public enum UserRole {
    
        ROLE_ROOT_ADMIN,  // 系统管理员
    
        ROLE_ORDER_ADMIN, // 订单管理员
    
        ROLE_NORMAL       // 普通用户
    }
    

    接下来我们就用这个UserRole为例来说明枚举的所有基本用法

    UserRole role1 = UserRole.ROLE_ROOT_ADMIN;
    UserRole role2 = UserRole.ROLE_ORDER_ADMIN;
    UserRole role3 = UserRole.ROLE_NORMAL;
    
    // values()方法:返回所有枚举常量的数组集合
    for ( UserRole role : UserRole.values() ) {
        System.out.println(role);
    }
    // 打印:
    // ROLE_ROOT_ADMIN
    // ROLE_ORDER_ADMIN
    // ROLE_NORMAL
    
    // ordinal()方法:返回枚举常量的序数,注意从0开始
    System.out.println( role1.ordinal() ); // 打印0
    System.out.println( role2.ordinal() ); // 打印1
    System.out.println( role3.ordinal() ); // 打印2
    
    // compareTo()方法:枚举常量间的比较
    System.out.println( role1.compareTo(role2) ); //打印-1
    System.out.println( role2.compareTo(role3) ); //打印-2
    System.out.println( role1.compareTo(role3) ); //打印-2
    
    // name()方法:获得枚举常量的名称
    System.out.println( role1.name() ); // 打印ROLE_ROOT_ADMIN
    System.out.println( role2.name() ); // 打印ROLE_ORDER_ADMIN
    System.out.println( role3.name() ); // 打印ROLE_NORMAL
    
    // valueOf()方法:返回指定名称的枚举常量
    System.out.println( UserRole.valueOf( "ROLE_ROOT_ADMIN" ) );
    System.out.println( UserRole.valueOf( "ROLE_ORDER_ADMIN" ) );
    System.out.println( UserRole.valueOf( "ROLE_NORMAL" ) );
    

    除此之外,枚举还可以用于switch语句中,而且意义更加明确:

    UserRole userRole = UserRole.ROLE_ORDER_ADMIN;
    switch (userRole) {
        case ROLE_ROOT_ADMIN:  // 比如此处的意义就非常清晰了,比1,2,3这种数字好!
            System.out.println("这是系统管理员角色");
            break;
        case ROLE_ORDER_ADMIN:
            System.out.println("这是订单管理员角色");
            break;
        case ROLE_NORMAL:
            System.out.println("这是普通用户角色");
            break;
    }
    

    自定义扩充枚举

    上面展示的枚举例子非常简单,仅仅是单值的情形,而实际项目中用枚举往往是多值用法。

    比如,我想扩充一下上面的UserRole枚举,在里面加入 角色名 – 角色编码 的对应关系,这也是实际项目中常用的用法。

    这时候我们可以在枚举里自定义各种属性、构造函数、甚至各种方法:

    public enum UserRole {
    
        ROLE_ROOT_ADMIN( "系统管理员", 000000 ),
        ROLE_ORDER_ADMIN( "订单管理员", 100000 ),
        ROLE_NORMAL( "普通用户", 200000 ),
        ;
    
        // 以下为自定义属性
        
        private final String roleName;  //角色名称
    
        private final Integer roleCode; //角色编码
    
        // 以下为自定义构造函数
        
        UserRole( String roleName, Integer roleCode ) {
            this.roleName = roleName;
            this.roleCode = roleCode;
        }
    
        // 以下为自定义方法
        
        public String getRoleName() {
            return this.roleName;
        }
    
        public Integer getRoleCode() {
            return this.roleCode;
        }
    
        public static Integer getRoleCodeByRoleName( String roleName ) {
            for( UserRole enums : UserRole.values() ) {
                if( enums.getRoleName().equals( roleName ) ) {
                    return enums.getRoleCode();
                }
            }
            return null;
        }
    
    }
    

    从上述代码可知,在enum枚举类中完全可以像在普通Class里一样声明属性、构造函数以及成员方法。


    枚举 + 接口 = ?

    比如在我的前文《答应我,别再if/else走天下了可以吗》中讲烦人的if/else消除时,就讲过如何通过让枚举去实现接口来方便的完成。

    这地方不妨再回顾一遍:

    什么角色能干什么事,这很明显有一个对应关系,所以我们首先定义一个公用的接口RoleOperation,表示不同角色所能做的操作:

    public interface RoleOperation {
        String op();  // 表示某个角色可以做哪些op操作
    }
    

    接下来我们将不同角色的情况全部交由枚举类来做,定义一个枚举类RoleEnum,并让它去实现RoleOperation接口:

    public enum RoleEnum implements RoleOperation {
    
        // 系统管理员(有A操作权限)
        ROLE_ROOT_ADMIN {
            @Override
            public String op() {
                return "ROLE_ROOT_ADMIN:" + " has AAA permission";
            }
        },
    
        // 订单管理员(有B操作权限)
        ROLE_ORDER_ADMIN {
            @Override
            public String op() {
                return "ROLE_ORDER_ADMIN:" + " has BBB permission";
            }
        },
    
        // 普通用户(有C操作权限)
        ROLE_NORMAL {
            @Override
            public String op() {
                return "ROLE_NORMAL:" + " has CCC permission";
            }
        };
    }
    

    这样,在调用处就变得异常简单了,一行代码就行了,根本不需要什么if/else

    public class JudgeRole {
        public String judge( String roleName ) {
            // 一行代码搞定!之前的if/else灰飞烟灭
            return RoleEnum.valueOf(roleName).op();
        }
    }
    

    而且这样一来,以后假如我想扩充条件,只需要去枚举类中加代码即可,而不用改任何老代码,非常符合开闭原则


    枚举与设计模式

    什么?枚举还能实现设计模式?

    是的!不仅能而且还能实现好几种!

    1、单例模式

    public class Singleton {
    
        // 构造函数私有化,避免外部创建实例
        private Singleton() {
    
        }
    
        //定义一个内部枚举
        public enum SingletonEnum{
    
            SEED;  // 唯一一个枚举对象,我们称它为“种子选手”!
    
            private Singleton singleton;
    
            SingletonEnum(){
                singleton = new Singleton(); //真正的对象创建隐蔽在此!
            }
    
            public Singleton getInstnce(){
                return singleton;
            }
        }
    
        // 故意外露的对象获取方法,也是外面获取实例的唯一入口
        public static Singleton getInstance(){
            return SingletonEnum.SEED.getInstnce(); // 通过枚举的种子选手来完成
        }
    }
    

    2、策略模式

    这个也比较好举例,比如用枚举就可以写出一个基于策略模式的加减乘除计算器

    public class Test {
    
        public enum Calculator {
    
            ADDITION {
                public Double execute( Double x, Double y ) {
                    return x + y; // 加法
                }
            },
    
            SUBTRACTION {
                public Double execute( Double x, Double y ) {
                    return x - y; // 减法
                }
            },
    
            MULTIPLICATION {
                public Double execute( Double x, Double y ) {
                    return x * y; // 乘法
                }
            },
    
    
            DIVISION {
                public Double execute( Double x, Double y ) {
                    return x/y;  // 除法
                }
            };
    
            public abstract Double execute(Double x, Double y);
        }
        
        public static void main(String[] args) {
            System.out.println( Calculator.ADDITION.execute( 4.0, 2.0 ) );       
            // 打印 6.0
            System.out.println( Calculator.SUBTRACTION.execute( 4.0, 2.0 ) );    
            // 打印 2.0
            System.out.println( Calculator.MULTIPLICATION.execute( 4.0, 2.0 ) ); 
            // 打印 8.0
            System.out.println( Calculator.DIVISION.execute( 4.0, 2.0 ) );       
            // 打印 2.0
        }
    }
    

    专门用于枚举的集合类

    我们平常一般习惯于使用诸如:HashMapHashSet等集合来盛放元素,而对于枚举,有它专门的集合类:EnumSetEnumMap

    1、EnumSet

    EnumSet 是专门为盛放枚举类型所设计的 Set 类型。

    还是举例来说,就以文中开头定义的角色枚举为例:

    public enum UserRole {
    
        ROLE_ROOT_ADMIN,  // 系统管理员
    
        ROLE_ORDER_ADMIN, // 订单管理员
    
        ROLE_NORMAL       // 普通用户
    }
    

    比如系统里来了一批人,我们需要查看他是不是某个角色中的一个:

    // 定义一个管理员角色的专属集合
    EnumSet<UserRole> userRolesForAdmin 
        = EnumSet.of( 
            UserRole.ROLE_ROOT_ADMIN,
            UserRole.ROLE_ORDER_ADMIN 
        );
    
    // 判断某个进来的用户是不是管理员
    Boolean isAdmin( User user ) {
        
        if( userRoles.contains( user.getUserRole() ) )
            return true;
        
        return false;
    }
    

    2、EnumMap

    同样,EnumMap 则是用来专门盛放枚举类型为keyMap 类型。

    比如,系统里来了一批人,我们需要统计不同的角色到底有多少人这种的话:

    Map<UserRole,Integer> userStatisticMap = new EnumMap<>(UserRole.class);
    
    for ( User user : userList ) {
        Integer num = userStatisticMap.get( user.getUserRole() );
        if( null != num ) {
            userStatisticMap.put( user.getUserRole(), num+1 );
        } else {
            userStatisticMap.put( user.getUserRole(), 1 );
        }
    }
    

    EnumMap可以说非常方便了。


    总 结

    小小的枚举就玩出这么多的花样,不过好在探索和总结的过程还挺有意思的,也复习了很多知识,慢慢来吧。


    展开全文
  •  问题: 要定义星期几或性别的变量,该怎么定义?假设1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外.  枚举就是要让某个类型的变量的取值只能为若干个固定值中的一...
  • 那么你是怎么知道0,1,2,3代表什么的呢? 有的是建表,连接查询,但很少人。 有的是在jsp页面c:if判断。 我的做法是在VO类添加一个属性,属性只有getter方法,没有setter和属性定义。然后getter方法中根据代号...
  • 枚举

    2019-10-03 10:53:58
    枚举用一句话总结就是:列举出项目中所有系统常量; 没有枚举时我们是怎么做的? 答:我们一般使用Class,类中定义静态常量来使用;当我们要求颜色必须为红色,绿色,蓝色,黑色四种颜色其中的一种才可以!这时我们...
  • 记录学习Java的第十三天 由于本渣渣是前端转行Java,所以编辑器的选择就直接 webstorm 同公司的 idea ...Java 枚举是一个特殊的类,一般表示一组常量,比如一年的 4 个季节,一个年的 12 个月份,一个星期的 7
  • C++枚举类型

    2020-08-04 22:03:40
    今天接触了一个虽然一直听说过但是一直没怎么用的数据类型——枚举类型 枚举常量的集合 枚举是为了避免宏定义过多而让人看起来复杂,使代码更加简化 枚举类型定义 枚举类型的定义方式与结构体很像 enum MyEnum { ...
  • 前言 在使用Java语言进行开发时,肯定有使用过枚举类。那么Kotlin的枚举类是怎么样呢?下面分享一下,我学到的Kotlin的枚举。 枚举 一个类的对象是有限且固定的,这种实例有限...获取枚举常量名称 Week.name ...
  • 今天看《Pro Net 2.0 Windows Forms And Custom Cortrols In C#》时看到... 在MSDN里面看到了这样一句话:“2的幂(即 1、2、4、8 等)定义枚举常量。这意味着组合的枚举常量中的各个标志都不重叠。” 于是写...
  • Java中枚举的定义

    2020-07-15 15:56:20
    枚举类型怎么定义: enum 枚举名 { } 结果只有两种情况的,建议使用boolean类型。 结果超过两种,并且还是可以一枚一枚列举出来的,建议使用枚举枚举里面的值可以看成常量,值是枚举类型。 名称全部大写,单词以...
  • 枚举详解

    2014-05-08 17:06:38
     问题:要定义星期几或性别的变量,该怎么定义?假设1-7分别表示星期一到星期日,但有人可能  会写成int weekday = 0;或即使使用常量方式也无法阻止意外。  枚举就是要让某个类型的变量的取值只能为若干个固定...
  • C语言-联合体与枚举

    2020-01-12 20:47:14
    3.2 枚举怎么用? 1.联合体 联合体语法 union 联合体类型名 { 成员 }; 用法与struct一样。不同点是所有成员公用相同的内存空间。联合体的sizeof是成员中大小最大的值。 联合体是成员共用内存空间。 例如: 2....
  • java枚举小总结

    2010-08-18 09:44:41
    1:枚举类型 以前我们定义常量都是public final static String COLOR= "RED"; 这样定义常量是有缺点的! 缺点1:类型写死 必须是String ... 2:如果静态常量需要添加... 怎么定义一个枚举呢: pub...
  • Java之枚举的原理

    2017-08-09 17:42:51
    中的一个回答Java枚举型是静态常量,隐式地static final修饰过。 确切地说,Java枚举型是“静态常量”,这里面包含了两层意思: 1.枚举型中的实例隐式地static final修饰过。 2.枚举型作为某个类中的成员字段...
  • java-枚举

    2013-08-19 02:18:00
    为什么要有枚举?问题:要定义星期几或性别的变量,该怎么定义?假设1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。...以前没有枚举类的时候,我们普通...
  • Java学习枚举

    2012-09-24 23:00:06
    问题:要定义星期几或性别的变量,该怎么定义?假设1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。 枚举就是要让某个类型的变量的取值只能为若干个固定值中...
  • Enum枚举

    2014-06-06 10:50:50
     问题:要定义星期几或性别的变量,该怎么定义?假设1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。 枚举就是要让某个类型的变量的取值只能为若干个固定值中...
  • 黑马程序员_枚举

    2014-08-11 21:05:03
    为什么要有枚举 问题:要定义星期几或性别的变量,该怎么定义?假设1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。...普通类如何实现枚举功能,定义一
  • 简单看看java之枚举

    2019-10-03 11:02:04
    枚举类这个类的比较少,对这个不怎么熟悉,最近看源码刚好可以好好了解一下,那么,枚举Enum是什么呢?在jdk中,Enum是一个抽象类下图所示,这就说明这个类是不能进行实例化的,那么我们应该怎么使用呢? 1....
  • 黑马程序员——枚举

    2014-01-10 08:59:17
    假设1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。 枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个,否则,编译器就会报错。枚举可以让...

空空如也

空空如也

1 2 3 4 5 6
收藏数 104
精华内容 41
关键字:

枚举常量怎么用