精华内容
下载资源
问答
  • 枚举类型enum用法

    2020-08-20 06:01:11
    枚举常量是枚举类型中的值,即枚举值。枚举类型是一种用户定义的类型,只有用户在程序中定义它后才能被使用。
  • 枚举类型enum用法 我是Java枚举的忠实拥护者。 似乎我们一直在等待获得它,但是当我们最终获得它( J2SE 5 )时,该枚举比C和C ++提供的枚举要好得多,在我看来,“值得等待” 。 与Java enum一样好,它也不是没有问题...
    枚举类型enum用法

    枚举类型enum用法

    我是Java枚举的忠实拥护者 似乎我们一直在等待获得它,但是当我们最终获得它( J2SE 5 )时,该枚举比CC ++提供的枚举要好得多,在我看来,“值得等待” 与Java enum一样好,它也不是没有问题。 特别是,Java枚举的方法values()返回数组的新副本,该副本表示每次调用时其可能的值。

    Java语言规范阐明了枚举行为。 Java语言规范Java SE 10 Edition中第8.9节涵盖了枚举。 第8.9.3节(“枚举成员”)列出了两个“隐式声明的方法”: public static E[] values()public static E valueOf(String name) 例8.9.3-1 (“使用增强的for循环遍历枚举常量”)演示了如何调用Enum.values()遍历枚举。 但是,问题在于Enum.values()返回一个数组,并且Java中的数组是可变的[Java语言规范的10.9节(“字符数组不是字符串”)提醒我们,当在Java之间进行区分时) string和Java字符数组。]。 Java枚举是紧密不变的,因此有意义的是,每次调用该枚举以确保不更改与该枚举关联的数组时,该枚举必须返回由values()方法返回的数组的克隆。

    最近在OpenJDK编译器-开发邮件列表上的标题为“关于Enum.values()内存分配”的Enum.values()指出,在紧密循环中调用Enum.values()会克隆大量常量数组时会分配大量内存。 ” 该消息的发布者补充说,这“可能是出于不变性”,并指出:“我能理解。” 该消息还引用了同一邮件列表上的2012年3月消息和相关主题。

    编译器开发邮件列表上的两个线程包含一些有趣的当前可用的解决方法。

    Brian Goetz在该线程上的消息开头是“这本质上是API设计错误; 因为values()返回一个数组,并且数组是可变的,所以每次都必须复制该数组。” [Goetz在该消息中还嘲笑了“冻结数组”(使Java数组变得不可变)的概念。]

    这个问题不是新问题。 威廉·希尔兹(William Shields)在2009年12月发布的文章《 Java中的可变性,数组和临时对象的成本》指出:“所有这些的最大问题是Java数组是可变的。” 在撰写有关Enum.values()提出的特定问题之前,Shields解释了Java Date类中的可变性的古老而众所周知的问题:

    Java枚举有一个称为values()的静态方法,该方法返回该enum的所有实例的数组 Date类的课程中,这个特殊的决定令人震惊。 List本来是更明智的选择。 在内部,这意味着实例数组在每次调用时都必须进行防御性复制。

    对此问题的其他引用包括“ Enums.values()方法”(Guava线程)和“ Java的Enum.values()隐藏分配”(显示缓存Enum.values()返回的数组)。 上面还写了一个JDK错误: JDK-8073381 (“需要API来获取枚举值而不创建新数组”)。

    下一篇代码清单中说明了本文中讨论的一些当前可用的变通方法,这是一个简单的Fruit枚举,演示了以三种不同格式缓存该枚举的值。

    具有三个“值”的缓存集的Fruit.java枚举

    package dustin.examples.enums;
    
    import java.util.EnumSet;
    import java.util.List;
    
    /**
     * Fruit enum that demonstrates some currently available
     * approaches for caching an enum's values so that a new
     * copy of those values does not need to be instantiated
     * each time .values() is called.
     */
    public enum Fruit
    {
       APPLE("Apple"),
       APRICOT("Apricot"),
       BANANA("Banana"),
       BLACKBERRY("Blackberry"),
       BLUEBERRY("Blueberry"),
       BOYSENBERRY("Boysenberry"),
       CANTALOUPE("Cantaloupe"),
       CHERRY("Cherry"),
       CRANBERRY("Cranberry"),
       GRAPE("Grape"),
       GRAPEFRUIT("Grapefruit"),
       GUAVA("Guava"),
       HONEYDEW("Honeydew"),
       KIWI("Kiwi"),
       KUMQUAT("Kumquat"),
       LEMON("Lemon"),
       LIME("Lime"),
       MANGO("Mango"),
       ORANGE("Orange"),
       PAPAYA("Papaya"),
       PEACH("Peach"),
       PEAR("Pear"),
       PLUM("Plum"),
       RASPBERRY("Raspberry"),
       STRAWBERRY("Strawberry"),
       TANGERINE("Tangerine"),
       WATERMELON("Watermelon");
    
       private String fruitName;
    
       Fruit(final String newFruitName)
       {
          fruitName = newFruitName;
       }
    
       /** Cached fruits in immutable list. */
       private static final List<Fruit> cachedFruitsList = List.of(Fruit.values());
    
       /** Cached fruits in EnumSet. */
       private static final EnumSet<Fruit> cachedFruitsEnumSet = EnumSet.allOf(Fruit.class);
    
       /** Cached fruits in original array form. */
       private static final Fruit[] cachedFruits = Fruit.values();
    
       public static List<Fruit> cachedListValues()
       {
          return cachedFruitsList;
       }
    
       public static EnumSet<Fruit> cachedEnumSetValues()
       {
          return cachedFruitsEnumSet;
       }
    
       public static Fruit[] cachedArrayValues()
       {
          return cachedFruits;
       }
    }

    在很多情况下,每次调用Enum.values()必须克隆其数组的事实实际上并不重要。 也就是说,不难想象在“紧循环”中反复调用Enum.values()会很有用,然后每次将枚举值复制到数组中都会开始对内存产生明显影响的情况并不难使用以及与更大内存使用相关的问题。 如果有一种标准的方法来以更有效的内存方式访问枚举的值,那就太好了。 前面提到的两个线程讨论了一些潜在实现此功能的想法。

    翻译自: https://www.javacodegeeks.com/2018/08/memory-hogging-enum-values-method.html

    枚举类型enum用法

    展开全文
  • Python枚举类型Enum用法详解

    千次阅读 2019-07-29 07:14:47
    实际开发中,我们离不开定义各种类型,当我们需要定义类型时,一般是通过一组整数来定义。比如:定义不同的月份 JAN 1 FEB 2 MAR 3 ... NOV 11 DEC 12 复制代码大多数人想到以下几种定义的方法: 1.直接使用定义变量...

    实际开发中,我们离不开定义各种类型,当我们需要定义类型时,一般是通过一组整数来定义。比如:定义不同的月份

    JAN 1
    FEB 2
    MAR 3
    ...
    NOV 11
    DEC 12
    复制代码

    大多数人想到以下几种定义的方法:

    1.直接使用定义变量的方法

    jan = 1
    feb = 2
    复制代码

    2.使用字典

    d = {"jan": 1, "feb": 2}
    复制代码

    3.使用类变量

    class TypeMonth:
        jan = 1
        feb = 2
    复制代码

    对于表示月份的数字或者其他类型,一旦定义之后就不需要作改变!但是以上几种定义的方法,都能轻易的对类型的值进行改变,比如:

    d['jan'] = 3
    
    TypeMonth.jan = 3
    复制代码

    这在实际开发中是不严谨的,也不安全,是不可取的。 同时,以上几种方法都会出现不同的类型 key,相同值的情况。

    d = {"jan": 1, "feb": 2, "mar": 2}
    复制代码

    对于这种情况,在 Python3.4 之后,给我们增加了枚举类,枚举类型可以看作是一种标签或是一系列常量的集合,通常用于表示某些特定的有限集合,例如星期、月份、状态等

    枚举类

    简单示例:

    from enum import Enum
    
    class Color(Enum):
        RED = 1
        GREEN = 2
        BLUE = 3
    
    print(Color.RED)
    输出结果: Color.RED
    复制代码

    上面的代码创建了一个基本的枚举示例,与我们普通类不同,它继承 Enum 这个类。同时使用类获取属性的时候,输出的不是它的数值,而是会显示枚举项。这样更能增加代码的可读性。

    对比普通的类,它有以下优势: ####不允许在类外直接修改枚举项的值。

    我们可以尝试修改枚举中标签的值,

    Color.RED = 4
    复制代码

    运行之后,会报错,

    不存在 key 相同的枚举项(类变量)

    在枚举类中存在相同的 key 值也是不允许的,比如下面代码有两个相同的 RED

    class Color(Enum):
        RED = 1
        RED = 1
        GREEN = 2
        BLUE = 3
    复制代码

    运行之后,会提示类型错误。

    枚举可以相同的值,但是值相同的各项 Key 都会当做别名

    在枚举类中,可以有相同值,但是后面的枚举项都是第一个的别名

    
    class Color(Enum):
        RED = 1
        GREEN = 1
        BLUE = 3
    
    print(Color.GREEN)
    
    输出结果:Color.RED
    复制代码

    从结果中可以看到,输出的是 Color.RED 这个类型,而不是 Color.GREEN。 如果你不想让枚举类中有相同的 value 值,Enum 也提供了的相应的处理方法

    from enum import Enum
    from enum import unique
    
    @unique
    class Color(Enum):
        RED = 1
        GREEN = 1
        BLUE = 3
    
    print(Color.GREEN)
    复制代码

    运行之后,代码会提示 ValueError

    枚举的基本操作

    获取枚举标签的值

    Color.GREEN.value
    复制代码

    获取枚举标签的名字

    Color.GREEN.name
    复制代码

    对枚举进行遍历

    for v in Color:
        print(v)
    
    输出结果:
    Color.RED
    Color.GREEN
    Color.BLUE
    复制代码

    对于有相同 value 值的枚举类进行遍历

    class Color(Enum):
        RED = 1
        GREEN = 2
        BLUE = 3
        BLACK = 1
    
    for v in Color:
        print(v)
    
    输出结果:
    Color.RED
    Color.GREEN
    Color.BLUE
    复制代码

    可以看到,相同值的标签名称不会被输出。如果要输出,要使用以下方法遍历

    for k, v in Color.__members__.items():
        print(k, v)
    
    输出结果:
    RED Color.RED
    GREEN Color.GREEN
    BLUE Color.BLUE
    BLACK Color.RED
    复制代码

    枚举的比较运算

    枚举之间可以进行等值比较

    result = Color.RED == Color.GREEN
    print(result)
    
    输出结果: False
    复制代码

    同时支持 is 身份比较

    result = Color.RED is Color.BLACK
    print(result)
    
    输出结果: True
    复制代码

    因为 RED 和 BLACK 的 value 值是相等的

    枚举之间不支持大小比较

    枚举之间不支持 '>' 或 '<' 比较,比如下面的代码就会报错

    result = Color.RED > Color.BLACK
    复制代码

    枚举类型转换

    枚举最大的好处,就是增加了我们代码的可读性

    if a ==1:
      pass
    elif a == 2:
      pass
    复制代码

    上面代码可读性就很差,因为我们并不知道 1、2 所代表的含义。但是如果有枚举类就不一样了。

    if a == Color.RED.value:
        pass
    elif a == Color.GREEN.value:
        pass
    复制代码

    相比第一份代码,后面的代码可读性就好很多了。那么如果我们怎么将枚举的值转换成枚举名称呢? 比如 a = 1,直接将该变量传入枚举类即可

    a = 1
    print(Color(a))
    
    输出结果:
    Color.RED
    复制代码

    总结

    1.枚举类不能用来实例化对象

    2.访问枚举类中的某一项,直接使用类名访问加上要访问的项即可,比如 color.RED

    3.枚举类里面定义的 Key = Value,在类外部不能修改 Value 值

    4.枚举项可以用来比较,使用 ==,或者 is

    5.枚举类中的 Key 不能相同,Value 可以相同,但是 Value 相同的各项 Key 都会当做别名

    6.枚举类可以用 for 进行遍历,members.items() 可以遍历出含有别名的类

    7.如果要枚举类中的 key 也不能相同,需要导入 unique 对枚举类进行装饰

    转载于:https://juejin.im/post/5d3e9c77f265da1b7402461d

    展开全文
  • 定义一个简单的枚举类型enumDays {Sat, Sun, Mon, Tue, Wed, Thu, Fri}; //这时候 Days.Sat = 0 ,后面依此递增。当然也可以手动指定起始值:enumDays {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri}; //这样就从1开始了...

    定义一个简单的枚举类型:
       enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};        //这时候         Days.Sat = 0 ,后面依此递增。

    当然也可以手动指定起始值:
       enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri}; //这样就从1开始了。

              枚举型的隐含类型为 int 型, 例如 int x=(int)Days.Sat ; 一点问题没有。据MSDN说枚举类型的隐含类型可以为除了char以外的任意数字类型……        [        Every enumeration type has an underlying type, which can be any integral type except char. ]
              下面这个例程演示使用长整型作为枚举的隐含类型:

    // keyword_enum2.cs
    // Using long enumerators

    using System;
    public class EnumTest 
    {
        enum Range :long {Max = 2147483648L, Min = 255L};
        static void Main() 
              {
           long x = (long)Range.Max;
           long y = (long)Range.Min;
            Console.WriteLine("Max = {0}", x);
            Console.WriteLine("Min = {0}", y);
              }
    }
    如果需要重新取回长整形值,也是一个转换就可以了。  long x = (long)Range.Max;

    最有意思的还是下面要说的,enum的[Flags]标记。啥也不说啦,看程序吧:
    //The following code example illustrates the use and effect of the 
    //System.FlagsAttribute attribute on an enum declaration.


    // enumFlags.cs
    // Using the FlagsAttribute on enumerations.
    using System;

    [Flags]
    public enum FileAttribute
    {
             ReadOnly= 0x01,
             Hide= 0x02,
             System= 0x04,
             Archived= 0x08
    }

    class FlagTest
    {
        static void Main()
             {
            FileAttributeoptions options= FileAttribute.ReadOnly| FileAttribute.System;
            Console.WriteLine(options);
            Console.WriteLine((int)options);
             }
    }

    输出为:
           
    ReadOnly, System
    5
    看到了吧?呵呵。这就是常用的标志位阿~ 在C#里变得更简单易用了。

    enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};

    1> 我给定一个值1,怎样把对应的Sun以字符串的形式返回来?(常用在取数据库里的XXX_ID并转换成对应的值的时候用。——不过有点硬编码的感觉。)
    答:Convert.ChangeType( enumValue, enumType ).ToString();// enumValue=1; enumType=typeof(Days)

    2>我给定一个字符串"Sun",怎么返回enum Day.Sun?
    答: 可以直接用 Enum.Parse( enumType, string,[boolean])来解决问题. ;例如这个例子, Enum.Parse(typeof(Day), "Sun", true) 就返回Day.Sun , 第3个参数指定是否大小写敏感. 可以省略.

    3>我想知道 enum Day 中所有的字符串值. 怎么写?
    答: 这个貌似也很简单哦, foreach(string name in Enum.GetNames(typeof(Day))) Console.WriteLine(name);   还有一个Enum.GetName() ,具体用法看MSDN去吧....

    来源:http://blog.163.com/li_crane/blog/static/19502097200822210217451/

    转载于:https://www.cnblogs.com/shangshen/p/4942813.html

    展开全文
  • NULL 博文链接:https://rensanning.iteye.com/blog/2013734
  • 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了再想到这个问题,就不好了。

     

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

    展开全文
  • 枚举类型是java 5新增特性的一部分,它是一种特殊的数据类型,它既是一种类又比类多了些特殊的约束,但也是这些特殊的约束造就了枚举类型的简洁性、安全性以及便捷性。 为什么要使用枚举 使用枚举会更加直观、方便。...
  • mysql中的枚举类型ENUM用法:

    千次阅读 2014-10-13 16:11:28
    mysql中的枚举类型ENUM用法: (2010-06-18 13:44:13) 标签: mysql 枚举 杂谈 ...
  • 枚举类型enum用法

    2017-03-23 10:55:18
  • Java中枚举类型Enum用法介绍

    千次阅读 2016-08-21 21:26:38
    今天在学习的过程中遇到了枚举这个知识点。之前一直都知道这个“名字...定义:枚举类型enum type)是指由一组固定的常量组成合法的类型。Java中由关键字enum来定义一个枚举类型。例子如下: public enum Color{ RE
  • java中枚举类型Enum用法

    万次阅读 2011-12-06 10:21:55
    java的Enum枚举类型终于在j2se1.5出现了。之前觉得它只不过是鸡肋而已,可有可无。毕竟这么多年来,没有它,大家不都过得很好吗?今日看《Thinking in Java》4th edition,里面有一句话“有时恰恰因为它,你才能够...
  • enum声明不同于数组,其只可以声明在Main()方法体外,在Main()中可以被调用。 下面是一个小程序,用enum来实现,实现星期几到日曜日、月耀日、火耀日等的转换。 System Collections; System; System; ...
  • Python枚举Enum用法详解

    千次阅读 2019-09-04 09:29:14
    实际开发中,我们离不开定义各种类型,当我们需要定义类型时,一般是通过一组整数来定义。比如:定义不同的月份 JAN 1 FEB 2 MAR 3 ... NOV 11 DEC 12 大多数人想到以下几种定义的方法: 1.直接使用定义变量的方法 ...
  • Swift中通过enum关键字可以直接创建出枚举对象,而且可以使用switch和case语句来进行流程控制,十分强大和灵活,这里我们就来详解Swift中enum枚举类型用法
  • C++: enum枚举类型用法 课题目标 了解enum枚举类型的基本形式,掌握enum枚举类型的使用方法。 课题引入 从一个对一周(包含周一到周日)的每天进行声明与赋值,来引出enum使用的便捷性,引出...
  • enum是用来声明枚举类型数据,它可以像数组一样存储许多的元素,但是不同于数组的是,它除了数字不能存储以外,其他类型的如字母、特殊符号、汉字都可以以任意组合存入enum当中去。 enum的声明:enum A { a, b,...
  • 枚举enum),是指一个经过排序的、被打包成一个单一实体的项列表。一个枚举的实例可以使用枚举项列表中任意单一项的值。枚举在各个语言当中都有着广泛的应用,通常用来表示诸如颜色、方式、类别、状态等等数目有限...
  • enum枚举类型用法

    2021-02-24 12:53:13
    在实际的编程应用中,有的变量只有几种可能的取值,譬如说一个家族的几个成员,性别的两种可能等等。C++为这种类型的变量的定义提供了enum...enum Roster { //该语句定义了Roster这一枚举类型 Tom, Sharon, Bill,
  • // 枚举类型的地位和class是并列的,不能放在class内部,可以放于class后,也可以放于package后,class前 package 第 3 章; public class 第3章a { public static void main (String[] args) { ...

空空如也

空空如也

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

枚举类型enum用法