精华内容
下载资源
问答
  • 在C++中,如果个变量只有几可能的值,可以定义为枚举类型枚举是指将变量的值一一列举出来,变量的值只能在列举出来的值的范围内。 C++声明枚举类型用enum开头。 enum weekday_enum { Sunday,Monday,Tuesday...

    C++枚举类型

    在C++中,如果一个变量只有几种可能的值,可以定义为枚举类型。枚举是指将变量的值一一列举出来,变量的值只能在列举出来的值的范围内。

    C++声明枚举类型用enum开头。

    enum weekday_enum
    {
      Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday
    };
    

    上面声明了一个枚举类型weekday,花括号中Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday称为枚举元素或枚举常量,表示这个类型的变量的值只能是以上7个值之一,它们是用户自己定义的标识符。

    C++声明枚举类型的一般形式为

    enum 枚举类型名 {枚举常量表列};

    C++在声明了枚举类型之后,可以用声明的枚举来定义变量。

    weekday workday,week_end;
    
    workday和week_end被定义为枚举类型weekday的变量。 
    

    学过C语言的读者应该知道,枚举类型名包括关键字enum,但是在C++中允许不写enum,一般也不写enum,但保留了C语言的用法。

    关于C++枚举,以下六点读者需要知道:

    C++对枚举元素按常量处理,故称枚举常量。
    C++枚举元素作为常量,它们是有值的。
    C++编译按定义时的顺序对它们赋值为0,1,2,3,…。
    C++可以在声明枚举类型时另行指定枚举元素的值。
    C++枚举值可以用来做判断比较。
    C++中一个整数不能直接赋给一个枚举变量。

    C++枚举类型
    更多案例可以公众号:C语言入门到精通

    展开全文
  • Java 枚举(enum) 详解7常见的用法

    万次阅读 多人点赞 2016-08-11 11:14:45
    JDK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能,却给我的开发带来了“大”方便。...现在好了,有了枚举,可以把相关的常量分组到枚举类型里,而且枚举提供了比常量更多的方法。 Java代码 publ...

    JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能,却给我的开发带来了“大”方便。

    大师兄我【大师兄】又加上自己的理解,来帮助各位理解一下。

    用法一:常量

    在JDK1.5 之前,我们定义常量都是: public static final.... 。现在好了,有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。 

    Java代码 

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

    用法二:switch

    JDK1.6之前的switch语句只支持int,char,enum类型,使用枚举,能让我们的代码可读性更强。 

    Java代码 

    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;  
            }  
        }  
    }  

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

    如果打算自定义自己的方法,那么必须在enum实例序列的最后添加一个分号。

    https://blog.csdn.net/qq_27093465/article/details/52180865

    而且 Java 要求必须先定义 enum 实例。 

    Java代码 

    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;  
        }  
    }  

    用法四:覆盖枚举的方法

    下面给出一个toString()方法覆盖的例子。 

    Java代码 

    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;  
        }  
    }  

    用法五:实现接口

    所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承,所以枚举对象不能再继承其他类。 

    Java代码 

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

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

     Java代码 

    public interface Food {  
        enum Coffee implements Food{  
            BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
        }  
        enum Dessert implements Food{  
            FRUIT, CAKE, GELATO  
        }  
    }  
        /**
         * 测试继承接口的枚举的使用(by 大师兄 or 大湿胸。)
         */
        private static void testImplementsInterface() {
            for (Food.DessertEnum dessertEnum : Food.DessertEnum.values()) {
                System.out.print(dessertEnum + "  ");
            }
            System.out.println();
            //我这地方这么写,是因为我在自己测试的时候,把这个coffee单独到一个文件去实现那个food接口,而不是在那个接口的内部。
            for (CoffeeEnum coffee : CoffeeEnum.values()) {
                System.out.print(coffee + "  ");
            }
            System.out.println();
            //搞个实现接口,来组织枚举,简单讲,就是分类吧。如果大量使用枚举的话,这么干,在写代码的时候,就很方便调用啦。
            //还有就是个“多态”的功能吧,
            Food food = Food.DessertEnum.CAKE;
            System.out.println(food);
            food = CoffeeEnum.BLACK_COFFEE;
            System.out.println(food);
        }

    运行结果

    用法七:关于枚举集合的使用

    java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型,而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述,可以参考JDK文档。

    关于枚举的实现细节和原理请参考:

    参考资料:《ThinkingInJava》第四版

    http://softbeta.iteye.com/blog/1185573

     

    我的这篇文章,因为是转载的,可能基本就没有变动,导致被某人踩了一脚。觉得不符合我大师兄的性格。下面我把自己的使用理解给整理一下。

     

    也是因为因为当时刚刚开始学习吧。把平时自以为了解的东西都只是大概了解了一下,说到底,还是自以为了解了,其实转眼就不知道什么是什么了。
    出来学习,不习惯看代码怎么能行呢?
    下面是我自己的测试代码。

    package com.lxk.enumTest;
    
    /**
     * Java枚举用法测试
     * <p>
     * Created by lxk on 2016/12/15
     */
    public class EnumTest {
        public static void main(String[] args) {
            forEnum();
            useEnumInJava();
        }
    
        /**
         * 循环枚举,输出ordinal属性;若枚举有内部属性,则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性)
         */
        private static void forEnum() {
            for (SimpleEnum simpleEnum : SimpleEnum.values()) {
                System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());
            }
            System.out.println("------------------");
            for (TYPE type : TYPE.values()) {
                System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());
            }
        }
    
        /**
         * 在Java代码使用枚举
         */
        private static void useEnumInJava() {
            String typeName = "f5";
            TYPE type = TYPE.fromTypeName(typeName);
            if (TYPE.BALANCE.equals(type)) {
                System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");
            } else {
                System.out.println("大师兄代码错误");
            }
    
        }
    
        /**
         * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例
         * Ordinal 属性,对应的就是排列顺序,从0开始。
         */
        private enum SimpleEnum {
            SPRING,
            SUMMER,
            AUTUMN,
            WINTER
        }
    
    
        /**
         * 常用类型(带参数的枚举常量,这个只是在书上不常见,实际使用还是很多的,看懂这个,使用就不是问题啦。)
         */
        private enum TYPE {
            FIREWALL("firewall"),
            SECRET("secretMac"),
            BALANCE("f5");
    
            private String typeName;
    
            TYPE(String typeName) {
                this.typeName = typeName;
            }
    
            /**
             * 根据类型的名称,返回类型的枚举实例。
             *
             * @param typeName 类型名称
             */
            public static TYPE fromTypeName(String typeName) {
                for (TYPE type : TYPE.values()) {
                    if (type.getTypeName().equals(typeName)) {
                        return type;
                    }
                }
                return null;
            }
    
            public String getTypeName() {
                return this.typeName;
            }
        }
    }
    

    然后是测试的结果图:

    简单的例子,大家基本都用过,看不懂的基本都是第二个例子。可以看到,在第二个例子里面,后面带有参数,其实可以这么理解。

    enum这个关键字,可以理解为跟class差不多,这也个单独的类。可以看到,上面的例子里面有属性,有构造方法,有getter,也可以有setter,但是一般都是构造传参数。还有其他自定义方法。那么在这些东西前面的,以逗号隔开的,最后以分号结尾的,这部分叫做,这个枚举的实例。也可以理解为,class  new 出来的实例对象。这下就好理解了。只是,class,new对象,可以自己随便new,想几个就几个,而这个enum关键字,他就不行,他的实例对象,只能在这个enum里面体现。也就是说,他对应的实例是有限的。这也就是枚举的好处了,限制了某些东西的范围,举个栗子:一年四季,只能有春夏秋冬,你要是字符串表示的话,那就海了去了,但是,要用枚举类型的话,你在enum的大括号里面把所有的选项,全列出来,那么这个季节的属性,对应的值,只能在里面挑。不能有其他的。

    我上面的例子,就是根据typeName,你可以从那些例子里面挑选到唯一的一个TYPE类型的枚举实例--TYPE.BALANCE。注意方法

    TYPE type = TYPE.fromTypeName(typeName);
    这个方法的返回类型就是这个TYPE枚举类型的。
    这下就好理解,这个枚举是怎么在工作了吧

    再补充一下:

    上面那个带参数的枚举类型的实例里面实际上是三个属性,除了我自定义的typeName以外,还有2个是系统自带的。看下面源码的图:

    看到这里之后,不知道你能不能理解下面图片内说明的话:下面图片主要说明在使用枚举时,的规范和标准。希望可以在实际开发时候用到

    最后补充一点:

    也许你知道呢,但是也许你不知道呢?我是真的不知道,测了之后才知道!!!

    枚举类型对象之间的值比较,是可以使用==,直接来比较值,是否相等的,不是必须使用equals方法的哟。

    具体,请参考下面的链接:

    java 枚举类比较是用==还是equals?

    2017.11.07 更新

    有的老铁,说这个switch case怎么写,我就在下面再啰嗦一下。

        private static void testSwitchCase() {
            String typeName = "f5";
            //这几行注释呢,你可以试着三选一,测试一下效果。
            //String typeName = "firewall";
            //String typeName = "secretMac";
            TypeEnum typeEnum = TypeEnum.fromTypeName(typeName);
            if (typeEnum == null) {
                return;
            }
            switch (typeEnum) {
                case FIREWALL:
                    System.out.println("枚举名称(即默认自带的属性 name 的值)是:" + typeEnum.name());
                    System.out.println("排序值(默认自带的属性 ordinal 的值)是:" + typeEnum.ordinal());
                    System.out.println("枚举的自定义属性 typeName 的值是:" + typeEnum.getTypeName());
                    break;
                case SECRET:
                    System.out.println("枚举名称(即默认自带的属性 name 的值)是:" + typeEnum.name());
                    System.out.println("排序值(默认自带的属性 ordinal 的值)是:" + typeEnum.ordinal());
                    System.out.println("枚举的自定义属性 typeName 的值是:" + typeEnum.getTypeName());
                    break;
                case BALANCE:
                    System.out.println("枚举名称(即默认自带的属性 name 的值)是:" + typeEnum.name());
                    System.out.println("排序值(默认自带的属性 ordinal 的值)是:" + typeEnum.ordinal());
                    System.out.println("枚举的自定义属性 typeName 的值是:" + typeEnum.getTypeName());
                    break;
                default:
                    System.out.println("default");
            }
        }
    

    然后,就是运行结果的截图。

    老铁们,看完这个枚举,你要懂个概念,那就是,这个枚举,他是个对象,就像你定义的Student类,Person类,等等一些个类一样。

    要有这么个概念。只要是个类,他就可以有构造函数,可以有属性,可以有方法。

    对的,老铁,你对这个属性,构造函数啥的,有概念吧,没有的话,我可就郁闷啦。

    然后,你就看到,这个地方有2个默认的属性,一个是name,一个是ordinal,这2个属性就像你定义Student类和Person类的name和age一样,

    只不过,这2个是系统自带的属性,不用你自己去定义啦。

    你也可以给这个枚举类,也就是你自己声明的枚举,随便加属性。

    我上面代码例子里面的那个TypeEnum那个枚举,就是这么干的,就简单的添加了个自定义属性typeName,

    虽然他有自己的name了,那姑且叫我这个自定义的属性叫别名吧。

    可以看到,我例子里面就是通过自己写的那个构造方法给我这个自定义的属性初始化值的。

    还有,这个构造方法是不可以,也不被运行public的,不信,你可以试试。

    还有,你不能对系统自带的name属性,在构造函数里面赋值,没有为什么。

    https://blog.csdn.net/qq_27093465/article/details/52180865

    (2019-07-29更新)

    再补充一点,这个也比较重要

    就是这个枚举类型,一旦创建,且被使用(比如,存数据库啥的)之后,持久化后的对象信息里面就保存了这个枚举信息。这个时候你的需求或者要求啥的,需要变更这个枚举名称。应当禁止这个变更的操作,只能重新创建,用新的代替旧的,不能直接把旧的给改了,因为,就数据在逆转成对象的时候,如果,旧的枚举不在了,那么就会400还是500的报错或者是空指针的bug。这也是需要关注的一个问题。希望注意下,不然等到出bug了再想到这个问题,就不好了。

     

    我写完文章,给自己点个赞,不过分吧,
    不过分,那我可就点啦啊。
    我先点为敬,你们随意。大家随意。不要客气。。。

    展开全文
  • 枚举器和可枚举类型

    2020-03-12 13:39:21
    枚举可以依次返回集合中项的类对象,获取枚举器的方法调用对象的GetEnumerator的方法,简单理解枚举器就是GetEnumerator方法返回的对象,这个方法的返回类型可以有很多; 3、枚举器和...

    1、什么是可枚举类型

            可枚举类型是带有GetEnumerator方法的类型,不一定是类也有可能是数组,接口,它返回一个枚举器。

    2、什么是枚举器

            枚举器是可以依次返回集合中项的对象,获取一个枚举器的方法是调用对象的GetEnumerator的方法,简单理解枚举器就是GetEnumerator方法返回的实例,这个方法的返回的实例类型可以有很多种;

           例如我们使用foreach语句遍历数组中的内容时,我们可以依次取出数组中的每一个元素,读取它的值,为什么数组可以这么做?因为数组提供了一个枚举器对象,枚举器可以依次返回请求的数组中的元素

           

    3、枚举器和foreach语句一起使用

            

    4、IEnumerator接口

                     

              IEnumerator接口是所有非泛型枚举器的基接口(即GetEnumerator方法返回实例类型如果是非泛型,则返回实例类型全部继承自IEnumerator接口).

              IEnumerator<T>接口是所有泛型枚举器的基接口

              类型是IEnumerator接口的枚举器(GetEnumerator方法返回的实例类型是IEnumerator接口)包含三个函数成员:Current、MoveNext以及Reset,复杂了解即可,直接通过foreach语句遍历

                             

     

              

    5、IEnumerable接口 

     

    展开全文
  • 枚举类型

    2020-12-05 17:02:33
    注意:枚举类型是一种基本的数据类型,而不是构造类型,因为枚举类型变量只能取一个值,它也不能再分解为任何类型。 首先,我们先看一下枚举类型的格式 enum<类型名>{枚举常量表} typedef enum<类型名>{...

    **

    枚举类型

    **
    在一些实际应用问题中,有些变量的取值被限定在一个有限的范围内。例如一周只有七天,一年只有12个月等,可以把此类变量定义为枚举类型。枚举类型的定义中列举出所有可能的取值,说明为该枚举类型的变量取值不能超过定义的范围。

    注意:枚举类型是一种基本的数据类型,而不是构造类型,因为枚举类型变量只能取一个值,它也不能再分解为任何类型。

    首先,我们先看一下枚举类型的格式

    enum<类型名>{枚举常量表}
    typedef enum<类型名>{枚举常量表}类型别名;
    enum<类型名>{枚举常量表} 枚举变量名;
    //有时甚至可以省略类型名
    enum {枚举常量表} 枚举变量名;
    

    枚举的声明:枚举声明用于声明新的枚举类型。

    访问修辞符 enum 枚举名:基础类型
    {
        枚举成员1,
        枚举成员2,
        ...
    };
    

    基础类型必须能够表示该枚举中定义的所有枚举数值。枚举声明可以显式地声明 byte、sbyte、short、ushort、int、uint、long 或 ulong 类型作为对应的基础类型。没有显式地声明基础类型的枚举声明意味着所对应的基础类型是 int。

    枚举成员(命名加赋值)
    枚举成员是该枚举类型的命名常数。任意两个枚举成员不能具有相同的名称。每个枚举成员均具有相关联的常数值。此值的类型就是枚举的基础类型。每个枚举成员的常数值必须在该枚举的基础类型的范围之内。
    示例:

    public enum Weekday:uint
     
    {   
        Monday=1,  
        Tuesday=2,
    };
    

    产生编译时错误,原因是常数值 -1、-2 和 –3 不在基础整型 uint 的范围内。

    枚举成员默认值
    在枚举类型中声明的第一个枚举成员它的默值为零。
    以后的枚举成员值是将前一个枚举成员(按照文本顺序)的值加 1 得到的。这样增加后的值必须在该基础类型可表示的值的范围内;否则,会出现编译时错误。
    示例:

    public enum Weekday:uint
     
    {   
        Monday,  
        Tuesday,
    };
    

    Monday的值为0,Tuesday的值为1。

    展开全文
  • 对于某个类的对象有限且确定的情况,以及需要定义组通用的常量的并将其作为组件供程序其他部分调用的情况,使用枚举更加简洁(写法简洁),安全(提供了安全检查的功能),当然枚举也可以用来实现责任链和多路...
  • 3枚举类型是一种基本的数据类型,数据类型中的元素是系统认定的,和整型,字符型浮点型数据类型同级别。不存在全局,局部之说。而用枚举类型声明定义的变量是有局部和全局说法的 以每周七天为例,我们可以使用#...
  • 有人会很疑惑, 都已经是枚举类型了, 还需要校验吗? 其实这边更确切的说法(应用场景), String对象映射为枚举值的校验, 如何来实现. 在Dubbo(RPC服务)中, 并不推荐枚举类型作为参数, 原因涉及枚举类型特殊的序列...
  • enum(枚举) java一种特殊的类,其枚举值就像枚举类有且仅有的静态实例,通过“类名.枚举成员”得到实例,通过该实例可以访问其中的任何成员方法,就如同常规的类实例对像一样对方法的访问。枚举类可以有带参数...
  • 定义一种新的数据类型 - 枚举型 以下代码定义了这种新的数据类型 - 枚举型 enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN }; (1) 枚举是一个集合,集合中的元素(枚举成员)是一些命名的整型常量,元素之间用...
  • 枚举(enum)类型是Java 5新增的特性,它是一种新的类型,允许用常量来表示特定的数据片断,而且全部都以类型安全的形式来表示。   1、常量的使用   在JDK1.5之前,我们定义常量都是:public static ...
  • java中的枚举类型

    2017-03-21 12:10:40
    枚举是一种类型,用于定义变量,以限制变量的赋值;赋值时通过“枚举名.值”取得枚举中的值 枚举类更加直观,类型安全。使用常量会有以下几个缺陷:  1. 类型不安全。若一个方法中要求传入季节这个参数,用常量的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,533
精华内容 2,213
关键字:

枚举是一种类型