首页 / JAVA / 你可能不了解的java枚举

你可能不了解的java枚举

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了你可能不了解的java枚举，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12398字，纯文字阅读大概需要18分钟。

内容图文

枚举在java里也算个老生长谈的内容了，每当遇到一组需要类举的数据时我们都会自然而然地使用枚举类型：

public enum Color {
    RED, GREEN, BLUE, YELLOW;

    public static void main(String[] args) {
        Color red = Color.RED;
        Color redAnother = Color.RED;
        Color blue = Color.BLUE;

        System.out.println(red.equals(redAnother)); // true
        System.out.println(red.equals(blue)); // false
    }
}

当然今天我们要探讨的并非是java中enum的基础语法，本次的主题将会深入enum的本质，并探讨部分高阶用法。本文基于Oracle JDK 14.0.2和jad v1.5.8e（由于jad已经很久未进行更新，对于新版本的jdk支持不是很完善，但单纯分析enum和interface已经足够）。

自定义枚举值背后的秘密

枚举默认的值是从0开始递增的数值，通常来说这完全够用了。不过java中还允许我们对枚举的值做个性化定制，例如：

// 我们不仅想用英语的方位，同时还想取得对应的本地化名称（这里是中文）
enum Direction {
    EAST("东"),
    WEST("西"),
    NORTH("北"),
    SOUTH("南");

    private final String name;

    // 注意是private
    private Direction(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

public class Test {
    public static void main(String[] args) {
        for (var v : Direction.values()) {
            System.out.println(v.toString() + "-->" + v.getName());
        }
    }
}

编译并运行程序，你将会得到下面这样的结果：

EAST-->东
WEST-->西
NORTH-->北
SOUTH-->南

很多教程到此就结束了，点到为止，对于枚举值后面的圆括号有什么作用，为什么构造函数需要private修饰都一笔带过甚至连解释说明都没给出。然而理解这些却是我们进一步学习枚举的高阶用法的前提。

不过没关系，我们可以自己动手一探究竟，比如看看反编译后的代码，从编译器处理枚举类型的方法中一探究竟。这里我们将会利用jad，具体的使用教程参考园内其他优秀文章，本文不进行赘述，我们直接看反编译后的结果：

final class Direction extends Enum
{

    /* 省略部分无关紧要的方法 */

    private Direction(String s, int i, String s1)
    {
        super(s, i);
        name = s1;
    }

    public String getName() // 这是我们自定义的getter
    {
        return name;
    }

    public static final Direction EAST;
    public static final Direction WEST;
    public static final Direction NORTH;
    public static final Direction SOUTH;
    private final String name;
    // 省略不重要的部分字段

    static 
    {
        EAST = new Direction("EAST", 0, "\u4E1C");
        WEST = new Direction("WEST", 1, "\u897F");
        NORTH = new Direction("NORTH", 2, "\u5317");
        SOUTH = new Direction("SOUTH", 3, "\u5357");
        // 省略部分字段的初始化
    }
}

首先看到我们的enum是一个类，其次它继承自java.lang.Enum（这意味着enum是无法显式指定基类的），而我们在Direction的构造函数中调用了其父类的构造函数，通过阅读文档可知，java.lang.Enum的构造函数是protected修饰的，也就是说对于java.lang包以外的使用者无法调用这个构造函数。同时文档也指出，该构造函数是由编译器自动调用的。因此我们自己定义的enum的构造函数也是无法正常调用的，只能由编译器用来初始化enum的枚举成员。既然本身无法被用户调用那么java干脆直接不允许protected和public（default和private允许）修饰自定义enum类型的构造函数以免造成误用。

另外我们的自定义构造函数其实是被编译器进行了合成，除了自定义参数之外还有枚举成员的字符串名称以及一个从0开始的序号（可用ordinal方法获取），前两个参数编译器会自动为我们添加，而自定义参数则是根据在我们给定的枚举成员后的圆括号里的值传递给构造函数，简单说就是：

EAST("东"),
WEST("西"),
NORTH("北"),
SOUTH("南");

// 转换为（unicode字符被转码）
EAST = new Direction("EAST", 0, "\u4E1C");
WEST = new Direction("WEST", 1, "\u897F");
NORTH = new Direction("NORTH", 2, "\u5317");
SOUTH = new Direction("SOUTH", 3, "\u5357");

如果我需要更多字段，只需要像这样：

public enum Planet {
    // 带有两个自定义数值
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    // 保存自定义值的字段，不使用final也可以，但枚举值一般不应该发生改变
    private final double mass;   // in kilograms
    private final double radius; // in meters
    // 在这里使用default的权限控制，即package-private
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass() { return mass; }
    public double radius() { return radius; }
}

这就是自定义枚举值背后的秘密。

至此我们的疑问几乎都得到了解答，然而细心观察就会发现，我们的枚举成员都是Direction的_静态字段_！因此我们不能把这些枚举成员当作类型来使用：

public void work(Direction.EAST e) {
    // 这是无法通过编译的
}

静态字段很好理解，因为我们需要通过类名+枚举成员名Direction.WEST直接引用，但为什么字段类型要是Direction的呢？

别着急，下一节答案就将揭晓。

为枚举添加抽象方法

这一节看起来很荒谬，抽象方法似乎和枚举八杆子打不到一块儿去。可是仔细想一想，在上一节中我们已经为枚举添加了getter成员方法，这说明我们还可以为枚举添加其他的方法从而定制枚举类型的行为，以上一节的Planet为例，我们可以添加计算任意物体在某个行星表面所受重力和质量的大小：

public enum Planet {
    
    /* 定义枚举成员和初始化的相关重复代码，此处不再重复 */

    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }
}

运行结果如下：

$ java Planet.java 70

Your weight on MERCURY is 26.443033
Your weight on VENUS is 63.349937
Your weight on EARTH is 70.000000
Your weight on MARS is 26.511603
Your weight on JUPITER is 177.139027
Your weight on SATURN is 74.621088
Your weight on URANUS is 63.358904
Your weight on NEPTUNE is 79.682965

既然能定制整个enum的行为，那是否意味着我们可以单独定义枚举成员的行为呢，毕竟方法最终还是从枚举成员值身上进行调用的。

答案是肯定的，还记得在上一节最后部分编译器是怎么处理枚举成员的吗？

EAST = new Direction("EAST", 0, "\u4E1C");
WEST = new Direction("WEST", 1, "\u897F");
NORTH = new Direction("NORTH", 2, "\u5317");
SOUTH = new Direction("SOUTH", 3, "\u5357");

没错，枚举成员本身也是enum对象的一个实例！而且这些枚举成员虽然是Direction类型的，但实际上还可以引用Direction的派生类型。

假设我们有一个Color类型的枚举，对于每个枚举成员我们都一个定制的print方法用于打印不同的信息：

enum Color {
    RED{
        // 先不用管这是什么语法，后面会解释
        @Override
        public void print() {
            // Linux上输出彩色字符串
            System.out.println("\u001B[1;31m This is red text \u001B[0m");
        }
    },
    BLUE{
        @Override
        public void print() {
            System.out.println("\u001B[1;34m This is blue text \u001B[0m");
        }
    },
    GREEN{
        @Override
        public void print() {
            System.out.println("\u001B[1;32m This is green text \u001B[0m");
        }
    };

    // 枚举成员必须要覆写的抽象方法
    public abstract void print();
}

public class Test {
    public static void main(String[] args) {
        for (var v : Color.values()) {
            v.print();
        }
    }
}

运行结果如下：

你可能不了解的java枚举 - 文章图片

要想知道原理，我们还是得借助jad，这是Color.class经过处理后的内容：

// 变成了抽象类
abstract class Color extends Enum
{
    // 构造函数
    private Color(String s, int i)
    {
        super(s, i);
    }

    public abstract void print();

    public static final Color RED;
    public static final Color BLUE;
    public static final Color GREEN;

    static 
    {
        // 重点从这开始
        RED = new Color("RED", 0) {

            public void print()
            {
                System.out.println("\033[1;31m This is red text \033[0m");
            }

        };
        BLUE = new Color("BLUE", 1) {

            public void print()
            {
                System.out.println("\033[1;34m This is blue text \033[0m");
            }

        };
        GREEN = new Color("GREEN", 2) {

            public void print()
            {
                System.out.println("\033[1;32m This is green text \033[0m");
            }

        };
    }
}

细心的读者大概已经发现了，这不就是_匿名内部类_么？说对了，我们的enum类型这次实际上变成了抽象类，而枚举成员则是继承自Color的匿名内部类并实现了抽象方法。所以最开始我们用注释标记的大括号其实可以理解成匿名类的类体。不过需要注意的是，虽然这里显式使用了new来创建了匿名内部类，但构造函数仍然是编译器代为调用的。

如果想增加自定义的枚举数据呢？可以这样做：

enum Color {
    RED(31){
        @Override
        public void print() {
            System.out.println("\u001B[1;31m This is red text \u001B[0m");
        }
    },
    BLUE(34){
        @Override
        public void print() {
            System.out.println("\u001B[1;34m This is blue text \u001B[0m");
        }
    },
    GREEN(32){
        @Override
        public void print() {
            System.out.println("\u001B[1;32m This is green text \u001B[0m");
        }
    };

    // color code
    private final int colorCode;
    private Color(int code) {
        colorCode = code;
    }
    public int getColorCode() {
        return colorCode;
    }

    public abstract void print();
}

我们看看编译后的代码，限于篇幅，我只保留了重要的部分：

abstract class Color extends Enum
{

    /* 大量省略代码 */

    private Color(String s, int i, int j)
    {
        super(s, i);
        colorCode = j;
    }

    public abstract void print();

    public static final Color RED;
    public static final Color BLUE;
    public static final Color GREEN;
    private final int colorCode;

    static 
    {
        // 参数传递给了构造函数
        RED = new Color("RED", 0, 31) {

            public void print()
            {
                System.out.println("\033[1;31m This is red text \033[0m");
            }

        };
        BLUE = new Color("BLUE", 1, 34) {

            public void print()
            {
                System.out.println("\033[1;34m This is blue text \033[0m");
            }

        };
        GREEN = new Color("GREEN", 2, 32) {

            public void print()
            {
                System.out.println("\033[1;32m This is green text \033[0m");
            }

        };
    }
}

总结一下，对于一个enum类型来说，通常会有如下格式：

[public] enum NAME [implements XXX, ...] {
    VALUE1 [(自定义数据，格式和自定义构造函数函数的参数列表相同)]
    [{
        // 可以override或是追加新的method
    }],
    ...,
    VALUEN [(...)]
    [{
        // overrides or methods
    }];

    [存储各种自定义数据的字段，最好用final修饰]
    [
        // 自定义构造函数
        [private] NAME(和枚举成员中给出的圆括号内的内容一致) { /* 设置数据字段 */ }
    ]

    [定义抽象方法或者重写object/Enum的方法或是添加普通类方法]
}

给出的格式中用[]框住的部分都是可以省略的。

枚举和接口

在上一节的最后，我们看到enum其实还可以实现interface（毕竟本质上还是个class），所以上一节的例子可以这么写：

interface Printer {
    void print();
}

enum Color implements Printer {
    RED{
        @Override
        public void print() {
            System.out.println("\u001B[1;31m This is red text \u001B[0m");
        }
    },
    BLUE{
        @Override
        public void print() {
            System.out.println("\u001B[1;34m This is blue text \u001B[0m");
        }
    },
    GREEN{
        @Override
        public void print() {
            System.out.println("\u001B[1;32m This is green text \u001B[0m");
        }
    };
}

我个人更倾向于第二种方法，因为enum主要是数据的集合，而对于数据表现出的行为/模式尽量使用interface进行描述。

除此之外，enum还可以定义在iinterface中。假设我们有一个枚举表示从周一到周日，同时给定一个方法isRestDay判断当前日期是否可以休息（比如有的人双休有的人单休还有的人在周一或周五休息），不同类型的人对于周几该休息将会产生不同的答案，因此将它抽象成接口再合适不过了：

interface Relaxable {
    enum Weekly {
        Mon, Tue, Wed, Thu, Fri, Sat, Sun
    }

    boolean isRestDay(Relaxable.Weekly day);
}

class PersonA implements Relaxable {
    @Override
    public boolean isRestDay(Relaxable.Weekly day) {
        return day.equals(Relaxable.Weekly.Sat) || day.equals(Relaxable.Weekly.Sun);
    }
}

class PersonB implements Relaxable {
    @Override
    public boolean isRestDay(Relaxable.Weekly day) {
        return day.equals(Relaxable.Weekly.Sun);
    }
}

public class Relax {
    public static void main(String[] args) {
        var a = new PersonA();
        var b = new PersonB();
        var day = Relaxable.Weekly.Sat;
        System.out.println(a.isRestDay(day)); // true
        System.out.println(b.isRestDay(day)); // false
    }
}

PersonA拥有一个美好的双休，而可怜的PersonB却要在周六加班！使用jad查看生产的代码：

interface Relaxable
{
    public static final class Weekly extends Enum
    {

        /* 省略了部分代码 */

        public static final Weekly Mon;
        public static final Weekly Tue;
        public static final Weekly Wed;
        public static final Weekly Thu;
        public static final Weekly Fri;
        public static final Weekly Sat;
        public static final Weekly Sun;

        static 
        {
            Mon = new Weekly("Mon", 0);
            Tue = new Weekly("Tue", 1);
            Wed = new Weekly("Wed", 2);
            Thu = new Weekly("Thu", 3);
            Fri = new Weekly("Fri", 4);
            Sat = new Weekly("Sat", 5);
            Sun = new Weekly("Sun", 6);
        }

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

    public abstract boolean isRestDay(Weekly weekly);
}

可以看出此时的enum仅仅只是interface中的一个静态内部类而已。使用类似的方法可以借由interface来组织多个不同但有弱关联性的枚举类型，从而构成类似其他语言中namespace的组织结构。

当然，通常我们并不推荐用接口来组织多种不同的类型或是构成namespace，接口通常的作用是抽象出一组类的共同特性，或是让不同的类之间可以遵守相同的协议从而简化开发工作，主体应该是接口提供的方法以及这些方法所依赖的共通的一小部分数据类型（例如上例，虽然例子不是很好）;而final class则更适合组织不同数据类型和静态常量，更进一步的理由超过了本文的探讨范畴，你可以在园内搜索相关文章进一步学习。

总结

在本文中，我们学到了：

如何添加枚举的自定义数据
为枚举添加构造函数和方法
用枚举实现接口
将枚举和接口组合使用

当然，依靠反编译的代码来学习语言特性并不是一个值得推荐的选择，但确实最直观的最容易让人理解底层原理的办法。

长文难免会有疏漏之处，如有补充和指正欢迎指出！

内容总结

以上是互联网集市为您收集整理的你可能不了解的java枚举全部内容，希望文章能够帮你解决你可能不了解的java枚举所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/625388.html

来源：【匿名】

【上一篇】Jenkins--pipline 流水线部署Java后端项目【下一篇】JAVA/JSP学习系列之五

更多 ►

【你可能不了解的java枚举】教程文章相关的互联网学习教程文章

Java学习笔记之——枚举类【图】

枚举可以限定类的值只是有限个，例如：星期，只有星期一到星期天语法案例：原文：https://www.cnblogs.com/wrf-hsj/p/10109854.html

java中Enum枚举的底层【代码】

我们都知道，Enum特性是jdk5引入的，表面上和类、接口属于同一层次，那么我们反编译class文件会出现什么呢？首先，我写了一个简单的Enum，如下所示：public enum Sex {MALE("男"),FEMALE("女");private String desc;Sex(String desc) {this.desc = desc;} } 编译：javac Sex.java用jad工具反编译：jad Sex.class结果如下所示：public final class Sex extends Enum {public static Sex[] values(){return (Sex[])$VALUES.clone();}...

java枚举enum【代码】

http://www.cnblogs.com/wenruo/p/5349614.htmljava的枚举通过关键字enum实现。可以理解为一个类，不过这个类由编译器自动加了一些方法。static values()方法用来按照enum常量的声明顺序产生由这些常量值构成的数组ordinal 表示某个特定enum常量的声明顺序toString() 以显示每个enum实例的名字可以在switch语句中使用，但是注意case处直接写常量，不加enum的名字。 1enum Spiciness {2// 用大写字母表示 3 NOT, MILD, MEDIUM,...

JAVA_SE 枚举类【代码】【图】

public class TestSeason {public static void main(String[] args) {Season spring = Season.SPRING;System.out.println(spring);spring.show();System.out.println(spring.getSeasonName());} } //枚举类 class Season{//1.提供类的属性，声明为private final private final String seasonName;private final String seasonDesc;//2.声明为final的属性，在构造器中初始化。private Season(String seasonName,String seasonDesc){...

2020.1.25 Java枚举详解【代码】【图】

Java枚举枚举类型是什么JDK5引入了一种新特性，关键字enum 可以将一组具名的值的有限集合创建为一种新的类型，而这些具名的值可以作为常规的程序组件使用，这就是枚举类型。一个枚举的简单例子enum SeasonEnum {SPRING,SUMMER,FALL,WINTER; }枚举类的常用方法Enum 常用方法有以下几种：name():返回enum实例声明时的名字ordinal();返回一个int值，表示enum 实例在声明的次序equals();返回布尔值，enum实例判断相等compareTo();比较e...

Java 设计模式--策略模式，枚举+工厂方法实现【代码】【图】

如果项目中的一个页面跳转功能存在10个以上的if else判断，想要做一下整改一、什么是策略模式策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理，最终可以实现解决多重If判断问题。1.环境（Context）角色：持有一个Strategy的引用。2.抽象策略（Strategy）角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。3.具体策略（ConcreteStrategy）角色：包...

枚举Java

public enum Color{　　GREEN,YELLOW,RED} public class TrafficLight{　　Color color=Color.RED;　　public void change(){　　　　switch(color){　　　　　　case RED:　　　　　　　　color=Color.GREEN;　　　　　　　　break;　　　　　　case YELLOW:　　　　　　　　color=Color.RED;　　　　　　　　break;　　　　　　case GREEN:　　　　　　　　color=Color.YELLOW;　　　　　　　　break;　　　　}　　} }原文：htt...

java 枚举类 enum 总结【代码】

枚举定义：enum是计算机编程语言中的一种数据类型。枚举类型：在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月，一个班每周有六门课程等等。如果把这些量说明为整型，字符型或其它类型显然是不妥当的。为此，C语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值，被说明为该“枚举”类型的变量取值不能超过定义的范围。应该说明的是，枚举类型是...

JDK源码阅读-------自学笔记(十八)(java.lang.Enum枚举类)【代码】

枚举类简介如果有必要定义一组常量的时候使用所有的枚举类型隐性地继承自 java.lang.Enum,枚举实质上还是类.每一个枚举中的成员,就相当于枚举的一个对象,默认都是public static final修饰的如果用到枚举的高级特性,建议不如定义一个普通类,否则会使问题复杂化一般常量都是使用大写的枚举类创建1enum Season{ 2SPRING, SUMMER,AUTUMN,WINTER 3 }View Code实战 1 2 Season season = Season.AUTUMN;3 4switch(season){5case SPRIN...

java的枚举入门【代码】

1.枚举的出现：为了简化代码2.自定义枚举publicclass Practice11 {publicstaticvoid main(String[] args) {Week.MON.show();Week.TUS.show();Week.WED.show();System.out.println(Week.MON);System.out.println(Week.TUS);System.out.println(Week.WED);} }abstractclass Week {public final static Week MON = new Week("星期一") {publicvoid show() {System.out.println("星期一");}};public final static Week TUS = new Week(...

JavaScript一个简易枚举类型实现扑克牌【代码】

java中enum----枚举的学习(更新中)【代码】

1package com.hdmaxfun;2 3import java.util.Scanner;4import com.icpc.Icpm;5import java.util.HashMap;6import java.util.Map;publicclass hdmaxfun{publicstaticvoid main(String[] args){7 Icpm A = Icpm.D.getIcpmPlaceByCode("8"); 8 A.SetPlace("杭州");9 A=A.getIcpmPlaceByCode("2"); 10//System.out.println(A.GetCode()+A.GetPlace());11 A=A.getIcpmPlaceByCode("8"); 12//System....

JavaScript的检测属性、属性特性、枚举属性【代码】

/* 检测属性检测属性可以通过三种方式 1.通过in运算符 2.通过hasOwnPerperty() 如果给定的属性是继承属性将返回false 3.通过propertyIsEnumerable()：只有检测到的自有属性且这个属性的可枚举性为true时它才返回true,某些内置对象是不可枚举的，通常由JavaScript代码创建的对象的属性是可枚举的。 */var o = { x: 1};"x" in o.x; //true "y" in o.x; //false "toString" in o.x //true o继承toString 属性o.hasOwnProperty("x");...

java 枚举【代码】

枚举的定义只能够取特定值中的一个使用 enum 关键字 1publicenum Gender {2 男,女; //男，女 public static final 3 4private String name;5publicvoid setName(String name){6this.name=name;7 }8public String getName(){9returnthis.name(); 10 } 11 } 枚举的使用而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是 public static final 的。可以直接通过枚举类型名直接使用它们。）强烈建议当你需要定义一...

java 枚举【代码】

枚举是JDK1.5引入的小功能，但是却对我们的开发带来了极大的帮助。首先我们应该知道什么是枚举？枚举就是把集合里的对象元素一个一个提取出来！比如说，你买了一合巧克力，里面有草莓味的、有香草口味的、有苹果口味的、你想把他们拿出来，就必须用“手”一个一个把他们拿出来并且一次只能取一个。这里的手就是枚举器，你取的动作就是枚举的过程。从代码来看，简单讲就是：枚举是限定有限可能值的一种手段。我们为什么要使...

首页 / JAVA / 你可能不了解的java枚举

你可能不了解的java枚举

内容导读

内容图文

自定义枚举值背后的秘密

为枚举添加抽象方法

枚举和接口

总结

内容总结

内容备注

内容手机端

【你可能不了解的java枚举】教程文章相关的互联网学习教程文章

Java学习笔记之——枚举类【图】

java中Enum枚举的底层【代码】

java枚举enum【代码】

JAVA_SE 枚举类【代码】【图】

2020.1.25 Java枚举详解【代码】【图】

Java 设计模式--策略模式，枚举+工厂方法实现【代码】【图】

枚举Java

java 枚举类 enum 总结【代码】

JDK源码阅读-------自学笔记(十八)(java.lang.Enum枚举类)【代码】

java的枚举入门【代码】

JavaScript一个简易枚举类型实现扑克牌【代码】

java中enum----枚举的学习(更新中)【代码】

JavaScript的检测属性、属性特性、枚举属性【代码】

java 枚举【代码】

java 枚举【代码】

JAVA - 相关标签

枚举 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程