从零开始深入理解Java枚举

最新推荐文章于 2024-07-25 21:24:50 发布
最新推荐文章于 2024-07-25 21:24:50 发布
阅读量1.1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： 枚举 java核心技术 effective java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37334135/article/details/94324166

​ 这一篇内容有点多，但是肯定会很有帮助，很多内容来自《Java核心技术》和《Effective Java》（刚学Java的时候，这本中文版的书非常不建议阅读，本来就不是很好理解，加上令人崩溃的翻译，但是主要内容都写在了这篇最后一章）另外还参考了《Java学习笔记》（这本书虽然没那么出名，但是读起来很容易理解，非常适合入门）还有一些其他资料就不说了，最后就是自己的一些理解。后面部分很多代码都没有使用idea，所以可能一点点会有笔误，当做是个学习笔记好了。

文章目录

1. 枚举使用时机

  • 当需要一组固定常量的时候。包括天然的枚举，比如 行星，一周的天数，衣服的尺码等；
  • 你在编译的时候就知道其所有可能值的集合
  • 变量值仅在一个范围内变化（尤其是保护延伸意义的时候，比如SUMMER(2)中的2就表示一年中的第二个季节），使用enum(阿里小册子)。

2. Enum源码解读

所有的枚举类都是继承自Enum（将在后续看到），Enum源码不多，就全部扣下来了

public abstract class Enum<E extends Enum<E>>
    implements Comparable<E>, Serializable {
	//枚举常数名字
	private final String name;
	//枚举常数的序号，默认0开始
	private final int ordinal;
	//返回该枚举常数的名字
    public final String name() {
        return name;
    }
	//同上
	public String toString() {
        return name;
    }
	//返回该枚举常数的序号
	public final int ordinal() {
        return ordinal;
    }
	//构造函数，传人枚举名字和序号
	protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
	//返回指定名字的枚举类型常数，静态的，使用Emun直接来调用
	public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                            String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }
	//hashCode(),equals,compareTo(),getDeclaringClass()方法不需要了解了
}

定义一个动作枚举Action 如下:

public enum  Action {
    STOP,LEFT,RIGHT,UP,DOWN;
}

这个枚举通过反编译是可以看到继承了Enum的，下面测试Enum的几个常用方法，解释写在了注释中，

@Test
public void test1(){
    Action left = Action.LEFT;
    String leftName = left.name();//名称就是LEFT
    String leftToString = left.toString();//LEFT
    int ordinal = left.ordinal();//枚举实例`LEFT`在枚举类中处于第二个位置,所以序号是1
	
    Action right = Enum.valueOf(Action.class, "RIGHT");//实例RIGHT的名称就是RIGHT
}

​ 静态方法似乎不好用，待会会介绍替代方法.对于ordinal方法也没啥用，就如<>>中第31条所说的，不要去依赖ordinal方法产生的序号，可控性不强，通常使用实例域来替代（需要关联值的时候别使用ordinal）。name,toString通常我们也很少用到。这些问题如何解决后面会说到。

3. 枚举原理

​ 要看Action枚举如何工作的，反编译看看一目了然。

public final class Action extends Enum
{

    private Action(String s, int i)
    {
        super(s, i);
    }

    public static Action[] values()
    {
        Action aaction[];
        int i;
        Action aaction1[];
        System.arraycopy(aaction = ENUM$VALUES, 0, aaction1 = new Action[i = aaction.length], 0, i);
        return aaction1;
    }

    public static Action valueOf(String s)
    {
        return (Action)Enum.valueOf(com/scu/enu/Action, s);
    }

    public static final Action STOP;
    public static final Action RIGHT;
    public static final Action LEFT;
    public static final Action UP;
    public static final Action DOWN;
    private static final Action ENUM$VALUES[];

    static 
    {
        STOP = new Action("STOP", 0);
        RIGHT = new Action("RIGHT", 1);
        LEFT = new Action("LEFT", 2);
        UP = new Action("UP", 3);
        DOWN = new Action("DOWN", 4);
        ENUM$VALUES = (new Action[] {
            STOP, RIGHT, LEFT, UP, DOWN
        });
    }
}

​ Action被final修饰了，说明了枚举类是不能再被继承了。同时拥有STOP,LEFT,RIGHT,UP,DOWN4个常量，再静态块里面被初始化，也就是类加载的时候就会初始化完成（类加载最后一步）。构造方法第一个参数是name第二个参数是ordinal，这些默认值可控性差，似乎不好用。

​ 此外，注意到Action类，额外提供了valueOf方法来获取枚举实例，这样就不再需要Enum.valueOf()来获取枚举实例了；提供了values方法来获取所有枚举实例。下面就简单测试这两个方法。

@Test
public void test2(){
    Action[] actions = Action.values();
    for (Action action : actions) {
        System.out.println(action.name() + " " + action.ordinal());
    }
    /*
        输出
        STOP 0
        LEFT 1
        RIGHT 2
        UP 3
        DOWN 4
         */
    Action right = Action.valueOf("RIGHT");
}

4. 枚举的高级应用

4.1 自定义构造函数

​ 之前说了，我们可以不适用Enum给我们提供的name,ordinal。比如这里就先使用value来替换掉 ordinal，做法很简单，提供一个成员变量value，一个getValue方法，最需要注意的是提供一个私有的构造函数来初始化value，不得在构造函数里面调用super(反编译后能看到自行调用)。。

public enum Action2 {
    STOP(2), LEFT(3), RIGHT(5), UP(9), DOWN(7);
    private int value;

    public int getValue() {//访问value
        return value;
    }
    private Action2(int value) {
        this.value = value;
    }
}

​ 枚举的本质还是类，实例是固定的，所以不允许在外部随意去new，需要将构造函数用private来进行修饰，这一点是很容易理解的。但是为什么写成STOP(2)这种诡异的形式呢，实际上是将隐含的name,ordinal没有写出来，比如之前的STOP实际上应该是STOP("STOP",0)。将Action2反编译就很清楚了。

public final class Action2 extends Enum
{

    private Action2(String s, int i, int value)
    {
        super(s, i);
        this.value = value;
    }

    public int getValue()
    {
        return value;
    }

    public static Action2[] values()
    {
        Action2 aaction2[];
        int i;
        Action2 aaction2_1[];
        System.arraycopy(aaction2 = ENUM$VALUES, 0, aaction2_1 = new Action2[i = aaction2.length], 0, i);
        return aaction2_1;
    }

    public static Action2 valueOf(String s)
    {
        return (Action2)Enum.valueOf(com/scu/enu/Action2, s);
    }

    public static final Action2 STOP;
    public static final Action2 RIGHT;
    public static final Action2 LEFT;
    public static final Action2 UP;
    public static final Action2 DOWN;
    private int value;
    private static final Action2 ENUM$VALUES[];

    static 
    {
        STOP = new Action2("STOP", 0, 2);
        RIGHT = new Action2("RIGHT", 1, 3);
        LEFT = new Action2("LEFT", 2, 5);
        UP = new Action2("UP", 3, 9);
        DOWN = new Action2("DOWN", 4, 7);
        ENUM$VALUES = (new Action2[] {
            STOP, RIGHT, LEFT, UP, DOWN
        });
    }
}

​ 注意到构造函数实际上是private Action2(String s, int i, int value)带三个参数，最后一个是我们自己写的value，name,ordinal还是赋了初值，只是后续我们使用对应于枚举实例的序号是时不使用ordinal而是使用value即getValue()。

​ 如果现在要将name也替换成我们自己的，不加解释的给出如下修改。

public enum Action3 {

    //其实通常会使用名称而不是动词
    STOP("暂停",2),LEFT("左转",3),RIGHT("右转",5),UP("上跳",9),DOWN("蹲下",7);

    private int value;
    private String name;//和Enum的name属性重名没关系

    public int getValue() {
        return value;
    }
    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return this.name + " " + this.value;
    }

    private Action3(String name, int value) {
        this.name = name;
        this.value = value;
    }
}

@Test
public void t3(){
    Action3[] action3s = Action3.values();
    for (Action3 action : action3s) {
        System.out.println(action);
    }
    Action3 stop = Action3.valueOf("STOP");//注意 不能填"暂停"  应该是Enum中的name
    System.out.println(stop.getName()+" " + stop.getValue());
}
/*
暂停 2
左转 3
右转 5
上跳 9
蹲下 7
暂停 2
*/

​ 其实构造函数是下面这个样子，父类中的name改成了s

private Action5(String s, int i, String name, int value)
{
super(s, i);
this.value = value;
this.name = name;
}

public static Action5 valueOf(String s)
{
return (Action5)Enum.valueOf(com/scu/enu/Action5, s);
}

4.2 特点于常量的方法

​ 什么叫特点于常量的方法？这是《effective java》中文版中的，意思就是每个常量实例都有自己特定的方法。

​ 上述介绍的方法getName,getAge都过于简单，但是有时候又希望枚举拥有自己的特定的成员方法。可能你会说，跟普通的类一样直接定义方法就好了，比如像定义一个·Student类，定义show方法，里面写点逻辑，创建每个实例都可以调用show方法。但是枚举的实例是有限个数的，比如上面的例子就是5个实例，每个实例的作用各不相同，通常我们需要根据实例的不同执行方法的逻辑差异也很大，所以需要让每个常量拥有自己的特定的方法。

​ 比如有枚举类Operation，定义了±*/ 4枚举实例，你想要提供一个方法来执行每个常量所代表的算术运算。可以通过下面较简单的方法来实现。

public enum  Operation {
    PLUS, MINUS, TIMES, DIVIDE;
    double apply(double x, double y) {
        switch (this){
            case PLUS:
                return x + y;
            case MINUS:
                return x - y;
            case TIMES:
                return x * y;
            default:
                return x / y;
        }
    }
}
//测试
@Test
public void test1(){
    Operation minus = Operation.MINUS;
    double ans = minus.apply(10, 2);
    System.out.println(ans);//8.0
}

​ 注意：如果涉及到金额，需要精确数值那么就不能用double类型了，double不够精确，因为浮点数小数位其实都是由1/2^k分数来表示的，比如0.75=1/2+1/4，用BigDecimal即可（《effective java》中第48条也有说）。

​ 这段代码运行起来是没有问题的。但是这段代码很脆弱，如果你添加了新的枚举常量，却忘记给switch添加相应的条件，程序仍可以编译，但是运行的话就可能得到错误的结果。这时候就是使用特点于常量的方法即可。

​ 即：在枚举中声音一个apply的抽象方法，并在各常量类主体中，用具体的方法覆盖每个常量的抽象apply方法。

public enum Operation2 {
    PLUS {
        @Override
        double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES {
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };
    abstract  double apply(double x, double y);
}

​ 这个时候如果你添加了个新操作比如幂运算常量EXP，编译器会自动提醒你去实现apply方法。甚至我们可以各个常量与特定的数据绑定起来，写成下面的形式。

public enum Operation3 {
    PLUS("+") {
        @Override
        double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES("*") {
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };
    private final String symbol;

    public String getSymbol() {
        return symbol;
    }

    private Operation3(String symbol) {
        this.symbol = symbol;
    }

    abstract  double apply(double x, double y);
}
//测试
@Test
@Test
public void test3(){
    double x = 10.0;
    double y = 2.0;
    Operation3[] ops = Operation3.values();
    for (Operation3 operation : ops) {
        System.out.println(x + operation.getSymbol() + y + "=" + operation.apply(x,y));
    }
}
/*
10.0+2.0=12.0
10.0-2.0=8.0
10.0*2.0=20.0
10.0/2.0=5.0
*/

4.3 用接口模拟可伸缩的枚举

​ 这个标题的名字就是《effective java》中的第34条。枚举其实就是final 类，所以一旦定义了枚举类，该类就不能被继承了，在该类的基础上也就很难使用extends去拓展了。再看Operation枚举，提供了加减乘除4中基本运算，全都有自己特点的apply方法。加入另外有人需要定义幂运算，定义求余运算该怎么做。

​ 虽然枚举是不可拓展的，但是接口则可以进行拓展，所以只需要将apply操作抽取到接口中。你可以定义另一个枚举类型来实现这个接口，并使用新的枚举实例以及特定于该实例的apply方法即可。现在将上述Operation该写成下面的扩展版本，

public interface  Operation {
    double apply(double x, double y);
}

public enum BasicOperation implements Operation{
    PLUS("+") {
        @Override
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        @Override
        public double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES("*") {
        @Override
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        @Override
        public double apply(double x, double y) {
            return x / y;
        }
    };
    private final String symbol;

    public String getSymbol() {
        return symbol;
    }

    private BasicOperation(String symbol) {
        this.symbol = symbol;
    }
}

​ 如果你想要定义一个上述操作类型的拓展，由求幂运算和求余运算组成，需要做的就是定义枚举类型实现Operation接口。

public enum  ExtendedOperation implements Operation{
    EXP("^") {
        @Override
        public double apply(double x, double y) {
            return Math.pow(x,y);
        }
    },
    REMINDER("%") {
        @Override
        public double apply(double x, double y) {
            return x % y;
        }
    };
    private final String symbol;

    public String getSymbol() {
        return symbol;
    }

    private ExtendedOperation(String symbol) {
        this.symbol = symbol;
    }
}

​ 说明：使用接口模拟可伸缩枚举有个小小的不足，即无法实现从一个枚举类型继承另一个枚举类型。在上述例子中，symbol的初始化和获取操作，在BasicOperation,ExtendedOperation中是相同的，由于就这两个子类且共享的功能不多，所以可以将以下共享代码从BasicOperation复制到ExtendedOperation即可。但是如果共享功能很多的时候，或者子类很多的时候就需要将这些功能封装到辅助类或者静态辅助方法中去了，从而避免代码的复制工作。

private final String symbol;

public String getSymbol() {
return symbol;
}

private ExtendedOperation(String symbol) {
this.symbol = symbol;
}

4.4 枚举中的匿名内部类

对于4.2,4.3节中特点于枚举常量的方法的写法有没有感觉到很诡异，其实是编译器进行了处理，实际上就是使用了匿名内部类，反编译后就能看清楚了。比如DIVIDE常量实际上反编译后差不多是下面这个样子。

public static final BasicOperation DIVIDE;
static{
	DIVIDE = new BasicOperation("DIVIDE",3,"/"){
		public double apply(double x, double y) {
            return x / y;
        }
	}
}

5. 策略枚举

​ 特点于常量的方法实现有一个美中不足的地方，它们使得在枚举常量中共享代码变得更加困难了，这一点在马上就会通过例子说到。

​ 考虑这样一个需求，用一个枚举表示薪资包中的工作天数。这个枚举有一个方法，根据给定的某工人的基本工作和当天工作时间来计算当天的报酬。在五个工作日中，工作时间超过8小时都会产生加班工资；在双休日工作的全部算加班工资。通过switch语句很容易实现这个功能。

public enum  PayRollDay {
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;
    private static final int BASE_WORK_TIME = 8;//每个正常工作时间
    public double pay(double hoursWorked, double payRate) {
        double basicPay = hoursWorked * payRate;//基本薪资
        double overtimePay;//加班费
        switch (this) {
            case SATURDAY:case SUNDAY:
                overtimePay = hoursWorked * payRate/2;
                break;
            default:
                overtimePay = hoursWorked > BASE_WORK_TIME?(hoursWorked -
                    BASE_WORK_TIME)*payRate/2:0;
                break;
        }
        return basicPay + overtimePay;
    }
}
//测试
@Test
public void test1(){
    PayRollDay saturday = PayRollDay.SATURDAY;
    double pay = saturday.pay(10, 10);
    System.out.println(pay);//150
}
  1. 这段代码还是很简洁明了的，但是从维护的角度来看却不行。假设将一个假日常量，比如国庆加入其中，但是没有加入对应的case，编译也会通过，但是就会被当做工作日计算了，这显然是不对的。这个问题在4.2节也说到过，但是使用特定于常量的方法来完成这个任务会存在下面的问题。
  2. 如果使用特定于常量的方法来姐姐switch带来的问题的话，那么就会出现很多重复带买吗，比如5个工作日中的特定的方法都是相同的，即default中的那堆代码，而周末和节假日中的代码也是重复的。这种大量重复并不好，但是特定于常量的方法确实在共享代码方面很差。
  3. 我们需要做的是，每添加一个常量，就强制选择一种加班策略，同时不需要太多重复代码。一种可靠的想法就是将加班工资移到一个私有的嵌套枚举中，将这个策略枚举的实例传到PayrollDay的构造方法中。PayrollDay枚举将加班工资计算委托给策略枚举，PayrollDay中就不需要switch语句或者特定于常量的方法实现了。
public enum PayRollDay2 {
    MONDAY(PayType.WEEKDAY),TUESDAY(PayType.WEEKDAY),WEDNESDAY(PayType.WEEKDAY),
    THURSDAY(PayType.WEEKDAY),FRIDAY(PayType.WEEKDAY),SATURDAY(PayType.WEEKEND),
    SUNDAY(PayType.WEEKEND);

    private PayType payType;
    private PayRollDay2(PayType payType) {
        this.payType = payType;
    }

    public double pay(double hoursWorked, double payRate) {
        return  payType.pay(hoursWorked,payRate);
    }
    //策略枚举类
    private enum PayType{
        WEEKDAY{
            @Override
            double overtimePay(double hoursWorked, double payRate) {
                return hoursWorked > BASE_WORK_TIME?(hoursWorked -
                        BASE_WORK_TIME)*payRate/2:0;
            }
        },
        WEEKEND {
            @Override
            double overtimePay(double hoursWorked, double payRate) {
                return hoursWorked * payRate/2;
            }
        };
        private static final int BASE_WORK_TIME = 8;
        abstract double overtimePay(double hoursWorked, double payRate);
        double pay(double hoursWorked, double payRate) {
            return hoursWorked * payRate + overtimePay(hoursWorked,payRate);
        }
    }
}
//测试
@Test
public void test2(){
    PayRollDay2 saturday = PayRollDay2.SATURDAY;
    double pay = saturday.pay(10, 8);
    System.out.println(pay);//120
}

6. 总结

​ 能使用常量的时候一定要先考虑到枚举。只有极少数的枚举受益于将多种行为与单个方法关联。特定于常量的方法要优先于自有值的枚举。如果多个枚举常量同时共享相同的行为，则考虑策略枚举。

Java枚举—枚举初识
12-15 4万+
1. **枚举的好处**：可以将常量组织起来，统一进行管理 枚举的典型应用场景 **错误码、状态机等**。 2. 枚举的使用方法很简单，只需要使用enum 关键字申明即可 3. 枚举的底层原理是继承了Enum 抽象类，编译器最终会将枚举编译成一个普通的Java类供Java 虚拟机使用 4. 枚举中申明的变量都是有类型的，那就是该枚举类型(其实也是一个普通的java类)
java零基础从入门到精通（全）
码农研究僧的博客
07-18 5万+
目录前言1. 入门知识1.1 java体系1.2 JDK/JRE/JVM区别1.3 编译与运行理解1.4 类体函数细节2. 标识符 前言 java优势 健壮性（JVM（C++语言写的一个虚拟的计算机）、GC（垃圾回收机制）） 多线程并发 可移植性/跨平台 1. 入门知识 1.1 java体系 JavaSE：标准版 JavaEE：企业版 JavaME：微型版 1.2 JDK/JRE/JVM区别 JVM是不能独立安装的。 JRE和JDK都是可以独立安装的 层层嵌套，jvm包括jdk，jdk包括jre
java中的枚举_Java中的枚举
从零开始的教程世界
07-22 811
java中的枚举Enum was introduced in Java 1.5 as a new type whose fields consists of a fixed set of constants. For example, we can create directions as Java Enum with fixed fields as EAST, WEST, NORTH, and ...
C#中使用action进行无限循环网络调用
fengxici1的博客
01-20 1463
最近在业务中遇到这样一个需求：用一个方法不断向网络中的某个接口提交数据。 第一反应是使用定时任务。虽然能够解决问题，但时钟觉得不够优雅。 C#中的网络包我选择了HttpLib这个开源库项目，比较简单，项目地址为https://github.com/j6mes/httplib/ 摘录一段代码如下： Http.Get("https://jthorne.co.uk/httplib").OnSu
关于Enum
XiaoMing学习分享博文
01-04 400
1. enum实例声明的次序，从0开始。可以使用==来比较enum实例，编译器会自动为你提供equals()和hasCode()方法。Enum类实现了Comparable借口，所以它具有compareTo()方法。同时，它还实现了Serializable借口。 ————源自java编程思想524页 只能在enum定义的内部使用其构造器创建enum实例。一旦enum的定义结束，编译器就不允许我们...
Java 枚举（enum）剖析
蚩尤后裔-汪茂雄
07-12 8072
目录 Java 枚举（enum）概述 枚举常量 属性与方法 枚举参数 实现接口 抽象方法 Java 枚举（enum）概述 1、Java JDK 1.5 新增的 enum 关键词，可以定义枚举类，如 public enum WeekEnum { }. 2、使用 enum 定义后的枚举类在编译后默认继承 java.lang.Enum 类，而不是普通的继承 Object 类。由于 Ja...
public static void Invoke (Action action)
weixin_34381666的博客
03-26 244
using System; using System.Security.Principal; using System.Security.Permissions; namespace Demo { class MainClass { public static void Invoke (Action action) { ...
深入理解 Java 虚拟机第三版（周志明）
最新发布
Aye
07-25 1008
这次社招选的这本作为 JVM 资料查阅，记录一些重点。
从零开始学Java源文件
04-23
本资源"从零开始学Java源文件"提供了一个完整的Java学习路径，包含了一系列经过调试的源代码，帮助学习者逐步理解并掌握Java编程。 首先，让我们了解一下Java源文件的基本结构。在Java中，源代码以`.java`文件扩展...
读书笔记之《深入理解Java虚拟机：JVM高级特性与最佳实践》
m0_68850571的博客
07-24 517
给每个对象添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。
C# Coding Conventions
青云的博客
01-26 291
Coding conventions serve the following purposes: They create a consistent look to the code, so that readers can focus on content, not layout. They enable readers to understand the code more quickly by making assumptions based on previous experience. The
枚举方法详解
殷建卫
09-11 1118
1. valueOf(String name):Day 返回当前类型指定名称的枚举常量。名称必须与在此类型中声明枚举常量所用的标识符完全匹配。（不允许使用额外的空白字符。） 参数： name - 要返回的常量名称 返回： 带指定名称的枚举常量 抛出： IllegalArgumentException - 如果指定枚举类型不包含指定名称的常量，或者指定类对象不表示枚举类型 NullP
Java 枚举(enum) 详解7种常见的用法
热门推荐
请叫我大师兄
08-11 88万+
JDK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能，却给我的开发带来了“大”方便。 大师兄我【大师兄】又加上自己的理解，来帮助各位理解一下。 用法一：常量 在JDK1.5之前，我们定义常量都是：public static final....。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 Java代码 publ...
实现带有构造方法的枚举,索引从0开始
weixin_35693083的博客
05-13 1117
/** * * @author juvie * 所有的枚举元素都是静态成员变量，在初始化时都会调用构造函数。 */ public class EnumTest { public enum WeekDay{ SUN(1),MON,TUE,WED,THI,FRI,SAT; private WeekDay(){ System.out.println("first"); ...
java enum从几开始_Java获取下一个枚举值或从第一个开始
weixin_42500739的博客
02-16 1698
参见英文答案 >What’s the best way to implement `next` and `previous` on an enum type?2个我有一个Java的枚举如下：public enum Cars{Sport,SUV,Coupe}我需要获得枚举的下一个值.所以,假设我有一个名为myCurrent...
从零开始的枚举
weixin_45050225的博客
08-06 1625
枚举 把一种类型可以等于的值全部列举出来，除此以再赋其它值就是非法的。 注意：这只一种美好的愿望，而实际上为了提高运行速度，编译器并没有做检查，因此枚举变量是可以用整数来赋值的（我猜测枚举就是使用unsigned int模拟的）。 enum Role {STUDENT=3,TEACHER=5,ADMIN=7}; enum Role role = STUDENT; 为什么使用枚举：可以把意义的整数使...
深入理解Java枚举类型(enum)
zejian的博客
05-13 47万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.youkuaiyun.com/javazejian/article/details/71333103 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
Java基础教程：初学者从零开始学习Java
在Java学习笔记中，详细阐述了Java作为编程语言的特点、运行原理以及基础语法。...以上知识点是Java初学者需要掌握的基础知识与技能，有助于理解Java语言的核心概念，并为深入学习Java编程打下坚实基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值