精华内容
下载资源
问答
  • public enum Day{ ...这个枚举类里面的MONDAY, TUESDAY……是什么东西? 如果是基本数据类型肯定要写声明,所以它们肯定不是。 如果是这个枚举类的实例化对象,为什么不用一个普通的class类解决?
  • **请问("S"),("M")是什么意思呢?这个实在Java核心卷中看到的写法** ![图片说明](https://img-ask.csdn.net/upload/202010/17/1602927824_410949.png)
  • 今天写枚举类的时候发现了一个有趣的现象,在这里分享一下: 首先我们定义一个简单的枚举类: /** * @author jinghuaixin * @date 2020/04/30 */ public enum Week { Monday, Tuesday; // 静态代码块 static ...

    今天写枚举类的时候发现了一个有趣的现象,在这里分享一下:

    首先我们定义一个简单的枚举类:

    /**
     * @author jinghuaixin
     * @date 2020/04/30
     */
    public enum Week {
    
        Monday, Tuesday;
        // 静态代码块
        static {
            System.out.println("枚举中静态代码块执行了");
        }
    
        // 构造方法
        private Week() {
            System.out.println("枚举中构造方法执行了");
        }
    
        // 构造代码块
        {
            System.out.println("枚举中代码块执行了");
        }
    }
    

    然后定义一个简单的测试类:

    public class TestEnum {
    
        static {
            System.out.println("普通类中静态代码块执行了");
        }
        {
            System.out.println("普通类中代码块执行了");
        }
    
        public TestEnum() {
            System.out.println("普通类的构造方法执行了");
        }
    
        public static void main(String[] args) {
            new TestEnum();
            System.out.println("+++++++++++++++++++++++++++");
            new TestEnum();
            System.out.println("=========================");
            Week week = Week.Monday;
            System.out.println("=========================");
            Week week2 = Week.Tuesday;
        }
    
    }
    

    运行结果:

    普通类中静态代码块执行了
    普通类中代码块执行了
    普通类的构造方法执行了
    +++++++++++++++++++++++++++
    普通类中代码块执行了
    普通类的构造方法执行了
    =========================
    枚举中代码块执行了
    枚举中构造方法执行了
    枚举中代码块执行了
    枚举中构造方法执行了
    枚举中静态代码块执行了
    =========================
    

    普通类中,静态代码块在类加载的时候执行,类只会加载一次,所以只会执行一次,并且这个动作在对象实例化之前,所以是最先输出的,紧接着每次实例化都会去调用构造代码块和构造方法,所以会2次输出。但是枚举类就比较有趣了,可以看到枚举类中第一次使用的时候,调用构造代码块和构造方法块执行次数和枚举元素相等,第二次并没有再调用构造代码块和构造方法,静态代码块虽然也只执行了一次,但是却放在最后了,这是为什么呢?

    我们借助jad反编译一下枚举类的代码:

    jad Week.class
    

    反编译生成的代码:

    // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
    // Jad home page: http://www.kpdus.com/jad.html
    // Decompiler options: packimports(3) 
    // Source File Name:   Week.java
    
    package learnbymaven.single;
    
    import java.io.PrintStream;
    
    public final class Week extends Enum
    {
    
        private Week(String s, int i)
        {
            super(s, i);
            System.out.println("枚举中代码块执行了");
            System.out.println("枚举中构造方法执行了");
        }
    
        public static Week[] values()
        {
            Week aweek[];
            int i;
            Week aweek1[];
            System.arraycopy(aweek = ENUM$VALUES, 0, aweek1 = new Week[i = aweek.length], 0, i);
            return aweek1;
        }
    
        public static Week valueOf(String s)
        {
            return (Week)Enum.valueOf(learnbymaven/single/Week, s);
        }
    
        public static final Week Monday;
        public static final Week Tuesday;
        private static final Week ENUM$VALUES[];
    	
    	// 静态代码块初始化变量
        static 
        {
            Monday = new Week("Monday", 0);
            Tuesday = new Week("Tuesday", 1);
            ENUM$VALUES = (new Week[] {
                Monday, Tuesday
            });
            System.out.println("枚举中静态代码块执行了");
        }
    }
    
    

    通过反编译代码可以看到,枚举底层其实还是class,枚举元素是被声明成public static final的成员变量(可以通过类名直接调用),并且在static静态代码块中一起初始化了,这就解释了为什么第一次调用枚举类的时候,构造代码块和构造方法执行次数会和枚举元素相等,因为第一次加载类的时候就全部初始化了。由于java类的加载和初始化过程都是线程安全的,所以创建一个enum类型是线程安全的

    展开全文
  • Enum枚举类

    2019-05-11 16:47:38
    关于枚举类是什么我在这里就不重复做介绍了,本文的内容是剥开枚举表面的面纱,还原一个最真实最原始的枚举类 。 正文 首先我们来看一个最简单的枚举类的写法: public enum EnumSingleton { INSTANCE } ...

    介绍

        关于枚举类是什么我在这里就不重复做介绍了,本文的内容是剥开枚举表面的面纱,还原一个最真实最原始的枚举类 。

     

    正文

    首先我们来看一个最简单的枚举类的写法:

    public enum EnumSingleton {
        INSTANCE
    }

    说明:上面不仅是一个枚举类,还是一个单例的写法 。整个代码看起相当简洁,但就因为它的简洁,我们可能会好奇,这个枚举结构和我们的一般的类不同,但是却又能把他当做一个普通的类来用,那么他又是如何实现我们普通类的功能?

    这里我们想到了一个思路,既然 java 文件最终都会编译成 class 文件然后载入内存去运行,按理来说,能跟普通类一样运行的枚举类,class 文件应该都相差不大,我们动手实践一下:

    javac EnumSingleton.java
    
    javap -c EnumSingleton

    得到如下的代码:

    public final class EnumSingleton extends java.lang.Enum<EnumSingleton> {
    
      public static final EnumSingleton INSTANCE;
    
      public static EnumSingleton[] values();
        Code:
           0: getstatic     #1                  // Field $VALUES:[LEnumSingleton;
           3: invokevirtual #2                  // Method "[LEnumSingleton;".clone:()Ljava/lang/Object;
           6: checkcast     #3                  // class "[LEnumSingleton;"
           9: areturn
    
      public static EnumSingleton valueOf(java.lang.String);
        Code:
           0: ldc           #4                  // class EnumSingleton
           2: aload_0
           3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
           6: checkcast     #4                  // class EnumSingleton
           9: areturn
    
      static {};
        Code:
           0: new           #4                  // class EnumSingleton
           3: dup
           4: ldc           #7                  // String INSTANCE
           6: iconst_0
           7: invokespecial #8                  // Method "<init>":(Ljava/lang/String;I)V
          10: putstatic     #9                  // Field INSTANCE:LEnumSingleton;
          13: iconst_1
          14: anewarray     #4                  // class EnumSingleton
          17: dup
          18: iconst_0
          19: getstatic     #9                  // Field INSTANCE:LEnumSingleton;
          22: aastore
          23: putstatic     #1                  // Field $VALUES:[LEnumSingleton;
          26: return
    }

    说明:经过我们对枚举类 class 文件的反编译,看到了许多不是我们自己写的代码,而且通过这个反编译的结果,大体的结构已经出来了,但是方法里面还是包含许多不易读懂的指令操作 。这还不是我们最终想要的结果,我们的目的是想办法将其还原成我们最熟悉的结构 。接下来我们继续使用 jad.exe 这个小工具将其还原(工具可以自行百度下载):

    C:\Users\zoke\Desktop\jad.exe EnumSingleton.class

    得到如下的代码:

    public final class EnumSingleton extends Enum {
    
        public static final EnumSingleton INSTANCE;
    
        private static final EnumSingleton $VALUES[];
        
        private EnumSingleton(String s, int i){
            super(s, i);
        }
    
        public static EnumSingleton[] values(){
            return (EnumSingleton[])$VALUES.clone();
        }
    
        public static EnumSingleton valueOf(String s){
            return (EnumSingleton)Enum.valueOf(EnumSingleton, s);
        }
    
        static {
            INSTANCE = new EnumSingleton("INSTANCE", 0);
            $VALUES = (new EnumSingleton[] {INSTANCE});
        }
    }

    结论与总结:到了这里已经非常简洁明了,我们写的枚举类,实际上还是继承的 Enum 类,同时也有着自己的构造方法 。这里面涉及到一个名称,那就是语法糖 。实际上枚举类的写法就是一个语法糖的体现 。那什么是语法糖呢,以 Java 语言举例,简单来说就是我们可以写一些非常简洁的代码(例如枚举),去实现一些原本需要很多代码才能实现的功能,而编译器在进行编译时,遇到这些语法糖,会将这些语法糖代码按照一定的规则编译成正常的 Java 语法结构的 class 文件,也就是说是编译器帮我们完成了剩下的工作,这对开发者和 JVM 来说都是无感知的,不会影响正常的运行性能,并且更易于读懂。语法糖在Java中的运用还有有 泛型与类型擦除、自动装箱与拆箱、变长参数、增强for循环、内部类 等 。也就是说枚举实际上编译后还是一个正常的 Java 类 。

    展开全文
  • 目录枚举类什么会有枚举类枚举类的使用枚举类的常用方法枚举的构造枚举类型能被反射吗?为什么枚举实现单例模式安全的?枚举类的优缺点 枚举类什么会有枚举类? 假如说程序中有一些颜色的状态,或者说消息...

    枚举类

    为什么会有枚举类?

    假如说程序中有一些颜色的状态,或者说消息的类型等,在JDK1.5之前,只能用常量来进行表示

    public class TestEnum {
        public static final int RED = 1;
        public static final int BLACK = 2;
        public static final int GREEN = 3;
        public static void main(String[] args) {
            int num = 1;
            System.out.println(RED == num);
        }
    }
    //true
    

    num不是一个颜色,就与实际不太相符合,于是JDK1.5中引入了枚举类型

    enum EnumColor {
        RED, BLACK, GREEN;
    
        public static void main(String[] args) {
            EnumColor color = EnumColor.BLACK;
            switch (color) {
                case RED:
                    System.out.println("红色");
                    break;
                case BLACK:
                    System.out.println("黑色");
                    break;
                case GREEN:
                    System.out.println("绿色");
                    break;
            }
        }
    }
    //黑色
    

    枚举类的使用

    • 类的对象只有有限个,确定的(星期,性别,季节…)
    • 当需要定义一组常量
    • 使用enum定义的枚举类默认继承了java.lang. Enum类,因此不能再继承其他类
    • 枚举类的构造器只能使用private权限修饰符
    • 枚举类的所有实例必须在枚举类中显式列出(,分隔结尾)。列出的实例
      系统会自动添加public static final修饰必须在枚举类的第一行声明枚举类对象
    • 枚举不能再类外直接实例化,也不能被继承

    如果枚举有参数可以添加对应的构造函数,但要注意:枚举的构造函数默认是私有的。所以不能被继承
    枚举就是定义了一些状态或者常见集合,一般不需要单独实例化,用的时候到枚举类中找合适的即可
    枚举的构造函数不能使用public和protected修饰。

    枚举类的常用方法

    方法名称 描述
    values() 以数组形式返回枚举类型的所有成员
    ordinal() 获取枚举成员的索引位置
    valueOf() 将普通字符串转换为枚举实例
    compareTo() 比较两个枚举成员在定义时的顺序
    enum EnumColor {
        RED, BLACK, GREEN;
        public static void main(String[] args) {
        // 以数组的方式返回所有的枚举成员
            EnumColor[] colors = EnumColor.values();
        // 打印每个枚举成员的索引
            for(int i = 0; i < colors.length; ++i){
                System.out.println(colors[i] + ":" + colors[i].ordinal());
            }
        // 将字符串GREEN转化为枚举类型
            EnumColor color1 = EnumColor.valueOf("GREEN");
            System.out.println(color1);
        // 在进行转换时,如果有对应的枚举类型则转换,否则抛出IllegalArgumentException
    //     EnumColor color2 = EnumColor.valueOf("YELLOW");//定义的枚举类没有YELLOW
    //     System.out.println(color2);
            EnumColor color2 = EnumColor.valueOf("BLACK");//定义的枚举类没有YELLOW
            System.out.println(color2);
            System.out.println("-------------------------------------");
            System.out.println("枚举实例的比较");
        // 注意此处的比较是使用枚举成员的索引来比较了
            EnumColor black = EnumColor.BLACK;
            EnumColor red = EnumColor.RED;
            System.out.println(black.compareTo(red));
            System.out.println(BLACK.compareTo(RED));
            System.out.println(RED.compareTo(BLACK));
        }
        //结果:
        RED:0
    	BLACK:1
    	GREEN:2
    	GREEN
    	BLACK
    	-------------------------------------
    	枚举实例的比较
    	1
    	1
    	-1
    

    枚举的构造

    上述枚举类型有一个不太友好的地方是,枚举中只有枚举常量,拿到一个枚举常量后还是不知道其是什么颜色的,因此可以给枚举增加构造函数。

     enum EnumColor {
        RED("红色", 1), BLACK("黑色", 2), GREEN("绿色", 3);
        private String color;
        private int key;
        // 注意:枚举的构造函数默认是私有的,此处不能增加非private的访问权限进行限制
        /*public*/EnumColor(String color, int key){
            this.color = color;
            this.key = key;
        }
        public static EnumColor getEnum(String str){
            for (EnumColor color : EnumColor.values()){
                if(color.color.equals(str))
                    return color;
            }
            return null;
        }
        public static void main(String[] args) {
            System.out.println(EnumColor.getEnum("红色"));
        }
    }
    

    枚举类型能被反射吗?

    不能不能不能!
    通过看反射的源码,可以看出反射在通过newInstance创建对象时,会检查该类是否ENUM修饰,如果是则抛出异常,反射失败。
    在这里插入图片描述

    为什么枚举实现单例模式是安全的?

    enum Singleton5 {//枚举类的单例模式
        INSTANCE;
        public Singleton5 getInstance(){
            return INSTANCE;
        }
    }
    

    1、 私有化构造器并不保险,通过反射机制调用私有构造器。而枚举类不能被反射,所以可以防止反射攻击

    //模拟反射攻击
    class Singleton {//双重校验锁,性能佳线程安全
        private static Singleton4 instance=null;
        private Singleton4() {}
        public static Singleton4 getInstance() {
            if(instance==null) {
                synchronized (Singleton4.class) {
                    if (instance==null) {
                        //new对象分为三个操作
                        //分配内存
                        //调用构造方法初始化
                        //赋值
                        instance=new Singleton4();
                    }
                }
            }
            return instance;
        }
    }
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton s=Singleton.getInstance();
        Singleton sUsual=Singleton.getInstance();
        Constructor<Singleton> constructor=Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton sReflection=constructor.newInstance();
        System.out.println(s+"\n"+sUsual+"\n"+sReflection);
        System.out.println("正常情况下,实例化两个实例是否相同:"+(s==sUsual));
        System.out.println("通过反射攻击单例模式情况下,实例化两个实例是否相同:"+(s==sReflection));
    }
    //com.lxp.pattern.singleton.Singleton@1540e19d
    //com.lxp.pattern.singleton.Singleton@1540e19d
    //.lxp.pattern.singleton.Singleton@677327b6
    //正常情况下,实例化两个实例是否相同:true
    //通过反射攻击单例模式情况下,实例化两个实例是否相同:false
    

    2.避免序列化问题(任何一个readObject方法,不管是显式的还是默认的,它都会返回一个新建的实例,这个新建的实例不同于该类初始化时创建的实例)

    枚举类的优缺点

    1、优点

    枚举常量更简单安全 。
    枚举具有内置方法 ,代码更优雅
    

    2. 缺点

    不可继承,无法扩展
    
    展开全文
  • 枚举类

    2021-01-27 10:19:02
    Java五新增了一个euum关键字(他的地位和class interface 关键字地位相同)用来定义枚举类,枚举类是一种特殊的类,他一样可以有自己的成员变量、方法;可以实现一个或多个接口,也可以定义自己的构造器 注意事项:...

    一 :什么是枚举类型


    在某些情况,一个类的对象是固定的,例如一年有12个月,一年有4个季节 ,在Java中
    这些类被称为枚举类。


    二:早期的枚举类实现形式:

    三:Enum关键字

    Java五新增了一个euum关键字(他的地位和class interface 关键字地位相同)用来定义枚举类,枚举类是一种特殊的类,他一样可以有自己的成员变量、方法;可以实现一个或多个接口,也可以定义自己的构造器

    注意事项:

    一个Java源文件中最多只能定义一个public访问权限的枚举类,且该Java原文件也必须和该枚举类的类名相同。

    四:枚举类和普通类的区别

    枚举类可以实现一个或多个接口,使用enum定义的枚举类默认继承了java.lang.Enum类,而不是默认继承Object类,因此枚举类不能显示继承其他父类。其中Java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口。

    使用enum定义、非抽象的枚举类默认会用final修饰,随意枚举类没有派生子类;

    枚举类的构造器只能使用private访问控制符,如果省略前面的修饰符,则默认为private修饰,如果强制的话只能使用private修饰符;

    枚举类的所有实现必须在枚举的第一行显示列出,否则这个枚举类永远不能产生实例。

    五:如何定义一个枚举类

    由此可见 枚举类与class类和interface类的作用差不多;定义枚举类时需要显示出所有的枚举值,枚举值中间用,隔开,枚举值结束后用;结束,这些枚举值代表所有可能的实例。

    六:使用前面定义的枚举类实现某个实例

    package Demo;
    
    /**
     * @author Administrator
     */
    public class EnumTest {
        public void judge(SeasonEnum s){
            //switch 语句里的表达式可以是枚举类
            switch (s){
                case SPRING:
                    System.out.println("春暖花开");
                    break;
                case SUMMER:
                    System.out.println("夏日炎炎");
                    break;
                case FALL:
                    System.out.println("秋高气爽");
                    break;
                case WINTER:
                    System.out.println("大雪皑皑");
                    break;
            }
        }
    
        public static void main(String[] args) {
            //枚举类默认有一个values()方法,返回该枚举类的所有实例
            for (SeasonEnum s :SeasonEnum.values()
                 ) {
                System.out.println(s);
            }
            //使用枚举实例时,可通过EnumClass.variable形式来方位
            new EnumTest().judge(SeasonEnum.SPRING);
        }
    }
    

    结果图

    七:枚举类提供的方法

    所有的枚举类都继承java.lang.Enum类,所以枚举类可以直接使用java.lang.Enum类中所宝行的方法。

    1)int compareTo(E o)该方法用于指定枚举对象比较顺序,同一个枚举实例只能与相同烈性的枚举实例进行比较。如果该枚举对象位于指定枚举对象之后,则返回正整数;如果该枚举对象位于指定枚举对象之前,则返回负整数,否则返回零。

    2)String name () :返回枚举实例的名称,

    3).int ordinal();返回枚举类中的索引值

    4)String ToString ();返回枚举常量的名称,与name方法相似,但是toString()方法更加常用

    八:枚举的成员变量、方法和构造器

    1)定义一个枚举的实例变量

    上面定义了一个枚举的实例变量name 下面来调用这个枚举类

     

    1)通过Enum的valueOf来获取枚举类的类型值,

    在java中应该把类设置为良好的封装性 所以我们在类中实例要设置为私有的,通过方法对类的实例进行使用,上面的枚举类改为

    package Demo;
    
    /**
     * @author Administrator
     */
    
    public enum Gender {
        MALE, FEMALE;
        private String name;
    
        public void setName(String name) {
            switch (this) {
                case MALE:
                    if (name.equals("男")) {
                        this.name = name;
                    } else {
                        System.out.println("参数错误");
                        return;
                    }
                    break;
                case FEMALE:
                    if (name.equals("女")) {
                        this.name = name;
                    } else {
                        System.out.println("参数错误");
                        return;
                    }
                    break;
            }
        }
    
        public String getName() {
            return name;
        }
    }
    

     

    九:实现接口的枚举类

    定义一个接口

    public interface GenderDescription{

      void info();

    }

    实现枚举接口

    public Enum Gender implements GenderDesc{

       

    }

    十:包含抽象方法的枚举类

    注意:并不是所有的枚举类都使用final修饰!非抽象的枚举类才默认使用final修饰。对于一个抽象的枚举类而言----只有包含了抽象方法,他就是抽象枚举类,系统会默认使用abstract修饰,而不是使用final修饰。

    package Demo;
    
    /**
     * @author Administrator
     */
    public enum  Operation {
        PLUS{
            @Override
            public double eval(double x , double y){
                return x+y;
            }
        },
        MINUS{
            @Override
            public double eval(double x , double y){
                return x-y;
            }
        },
        TIMES{
            @Override
            public double eval(double x , double y){
                return x*y;
            }
        },
        DIVDE{
            @Override
            public double eval(double x , double y){
                return x/y;
            }
        };
        //定义个抽象方法 枚举类对抽象方法的重写
        public abstract double eval(double x,double y);
    
        public static void main(String[] args) {
            System.out.println(Operation.PLUS.eval(3,4));
            System.out.println(Operation.MINUS.eval(5,4));
            System.out.println(Operation.TIMES.eval(5,4));
            System.out.println(Operation.DIVDE.eval(5,4));
        }
    }
    

     

     

     

     

     

     

     

     

     

    展开全文
  • 什么需要枚举类? 因为现实生活中有的事物只有明确的几个固定值,我们不希望用户再创建出其它的值,所以我们需要枚举类把描述这些事物的值一一列举出来。 比如:季节、性别、键盘上的方向键等 我们如何自己设计...
  • 硬啃JAVA之枚举类

    2021-06-16 22:54:37
    文章目录枚举类一、枚举类是什么?二、使用步骤1.引入库2.读入数据总结 一、枚举类是什么? 枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类。 当需要定义一组常量时,强烈建议使用枚举类 二、使用...
  • 什么枚举类中一定要有私有构造方法呢? 枚举被设计成单例模式,即枚举类型会由JVM在加载的时候,实例化枚举对象,你在枚举类中定义了多少个就会实例化多少个,JVM为了保证每一个枚举类元素的唯一实例,不会允许...
  • 什么是枚举类? 类的对象只有有限个并且确定的 当需要定义一组常量时,强烈建议使用枚举类 如何定义枚举类? 在jdk5.0之前,自定义枚举类 jdk5.0及以后,使用enum关键字定义枚举类 自定义枚举类 a. 声明...
  • 说句很丢人的话,学了几年java,我对于枚举类还是非常不了解,了解之后才发现枚举用处非常之大。我们通过一个简单的例子,了解枚举的前世今生。 在java没有枚举类的时候,我们可以创建一个普通类来表示性别。 // 1...
  • 为什么需要枚举?  一些方法在运行时,它需要的数据不能是任意的,而必须是一定范围内的值,此类问题在JDK5以前采用...枚举类是什么?  ¨枚举类也是一种特殊形式的Java类。 ¨枚举类和普通类的区别?  1.
  • 什么枚举类中构造函数必须私有的呢?
  • 什么需要枚举类

    2018-01-21 11:16:55
    什么需要枚举类枚举类在我们的实际开发中,我们用得并不多。很少有机会去自己写枚举类。用到的情况下也不是很多。 枚举类其实就是用来代替常量的。 为什么这样说呢??? 比如我现在有5个选项,篮球、足球、...
  • 是枚举类?

    2020-04-30 10:26:22
    这个枚举类里面的MONDAY,TUESDAY……是什么东西? 如果是基本数据类型肯定要写声明,所以它们肯定不是。 如果是这个枚举类的实例化对象,为什么不用一个普通的class类解决? 枚举类里的MONDAY,T...
  • 二、什么时候使用枚举类 类的对象只有有限个,确定的。 例如: 星期:Monday、Tuesday、… 、Sunday 季节:Spring、Summer、Autumn、Winter 线程状态:创建、就绪、运行、阻塞、死亡 订单状态:Nonpayment(未付款...
  • 比如: class Tips{ enum{ssize = 100}; }; 这种形式的枚举类型定义有什么意义呢?
  • Java枚举类Enum

    2021-02-17 18:03:34
    文章目录Java枚举类Enum什么是枚举类枚举类的使用场景什么是枚举Java中的枚举Enum没有枚举类型时定义常量使用枚举类型定义Java枚举的常见API的使用Java枚举类常见API Java枚举类Enum 什么是枚举类枚举类的使用...
  • Kotlin枚举类

    2019-08-13 11:55:12
    枚举类最基本的用法实现一个类型安全的枚举(typesafe enum),什么叫做类型安全的枚举呢,即每个枚举都是枚举类的实例且不提供公共的构造方法。 enum class Color{ RED, GREEN, BLUE, WHITE, BLACK } 枚举类...
  • 枚举类详解

    2019-09-24 21:34:02
    1.1什么是枚举类? 1.1.1自定义枚举类代码演示: 1.1.2enum关键字定义枚举类 1.介绍 1.1什么是枚举类? 定义:类的对象只有有限个,确定的。比如: 星期:Monday(星期一)、......、Sunday(星期天) 性别:Man...
  • 今天对接第三方支付,我用枚举规定了几个支付方式和状态。有同事看到,问我为什么用枚举,交流中我发现他们对...也,它和class与interface在同一个位置,说明同一个级别的,都类,但是我们总说枚举类枚举类,...

空空如也

空空如也

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

枚举类是什么