java 枚举详解

最新推荐文章于 2022-03-25 10:45:17 发布
最新推荐文章于 2022-03-25 10:45:17 发布
阅读量987 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24084925/article/details/68491143
版权

1. 概述

枚举(enum)全写为的全称为:enumeration。是jdk1.5才新引进的概念，在Java中enum的有与C、C++相似的基本用法，也有很多扩展的用法。

尽管枚举类型看着像一种新的数据类型，但实际上它是一种受限制的类（继承自java.lang.Enum）。

public enum ColorEnum{
    //相当于创建了5个实例，调用了5次 Enum(String name, int ordinal)
    RED,WHITE,BLUE,BLACK,GREEN
}
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

经过编译器编译后产生的是一个class文件，该class文件经过反编译软件编译后可以看到实际上生成了一个类：

public class com.com.yarward.design.ColorEnum extends java.lang.Enum{
    public static final com.com.yarward.design.ColorEnum RED;
    public static final com.com.yarward.design.ColorEnum WHITE;
    public static final com.com.yarward.design.ColorEnum BLUE;
    public static final com.com.yarward.design.ColorEnum BLACK;
    public static final com.com.yarward.design.ColorEnum GREEN;
    static {};
    public static com.com.yarward.design.ColorEnum[] values();
    public static com.com.yarward.design.ColorEnum valueOf(java.lang.String);
    ....
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
/**
 * This is the common base class of all Java language enumeration types.
 *
 * <p> Note that when using an enumeration type as the type of a set
 * or as the type of the keys in a map, specialized and efficient
 * {@linkplain java.util.EnumSet set} and {@linkplain
 * java.util.EnumMap map} implementations are available.
 *
 * @since   1.5
 */
public abstract class Enum<E extends Enum<E>>
  implements Comparable<E>, Serializable {...}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

2. 特性介绍

2.1 基础用法

在未引入enum之前，我们定义常量的时候总是使用这样的方式：public final static 类型....,在引入了枚举类型之后,我们可以将一组相似属性统一组织、管理管理，并包含一些自己的方法：

  • name()：返回枚举常量的名称。

  • ordinal()：返回枚举常量的时序，0、1、2……。

  • getDeclaringClass()：返回实例所属的enum类型。

  • equals(Object other)：判断两个enum实例是否相等，也可用用==号来进行判断。

    注意不能用直接用数字常量与枚举类型直接比较。

  • 因为父类Enum实现了Comparable和Serializable的接口，因此也可以使用compareTo()方法。

例：

ColorEnum colorEnumWhite = ColorEnum.WHITE;
ColorEnum colorEnumRed = ColorEnum.RED;

Log.d("test enum","enum colorEnumRed.toString() is " + colorEnumRed.toString());
Log.d("test enum","enum colorEnumWhite is " + colorEnumWhite);
Log.d("test enum","enum constant name is " + colorEnumWhite.name());
Log.d("test enum","enum constant ordinal is " + colorEnumWhite.ordinal());
Log.d("test enum","enum getDeclaringClass is " + colorEnumWhite.getDeclaringClass());
Log.d("test enum","enum colorEnumWhite = colorEnumRed " + colorEnumWhite.equals(colorEnumRed));
Log.d("test enum","enum colorEnumWhite = 1 " + colorEnumWhite.equals(1));
Log.d("test enum","enum colorEnumWhite compareTo colorEnumRed " + colorEnumWhite.compareTo(colorEnumRed));
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

输出结果：

enum colorEnumRed.toString() is RED
enum colorEnumWhite is WHITE
constant name is WHITE
constant ordinal is 1
getDeclaringClass is class com.yarward.design.MainActivity$ColorEnum
enum colorEnumWhite = colorEnumRed false
enum colorEnumWhite = 1 false
enum colorEnumWhite compareTo colorEnumRed 1
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

在使用enum时需要注意：

定义的枚举类型不可再继承其他的类型的类，因为它已经继承了java.lang.Enum。

2.2 添加成员、方法

前面介绍过，枚举也是一种类，是一种受限制的类，不能在继承其他任何类的类。因此它也具有类应该有的特性。

java中的枚举与c/c++中的枚举不同，c/c++可以显示的为枚举类型赋值，而java中的枚举不可以。

/*C/C++可以显示的给枚举类型赋值*/
typedef enum _Number{
  one = 1,
  two,
  three,
  ten = 10
} Number;
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Java虽然不能直接为实例赋值，但是它有更优秀的解决方案：为 enum 添加方法来间接实现显示赋值。枚举类可以有自己的成员、构造方法、普通方法、抽象方法、静态方法。

唯一用起来比较别扭的一点是，enum相当于把类的实例化（枚举常量）放到了类声明的内部，这些枚举常量也可以重写枚举类型中的方法。

 public enum WeekEnum{
     //定义枚举常量
     Mon(true),Tue(true),Wen(true),Thu(true),
       //定义枚举常量的时候可以重写枚举类型中方法
       Fri(true){
         @Override
         public String helloEnum() {
             return "sad to work";
         }
     },
     Sat(false),Sun(false);

     //枚举类型中可以有成员变量
     private boolean mIsWork;

     //枚举类型中可以有构造函数
     private WeekEnum(boolean isWork){
         this.mIsWork = isWork;
     }

     //枚举类型中可以有成员方法
     public boolean isWork(){
         return mIsWork;
     }

     public String helloEnum(){
         return "happy to work";
     }

     //枚举类型中可以静态方法
     public static String infoPrint(){
         return "Monday to Sunday!";
     }
 }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
WeekEnum tue = WeekEnum.Tue;
WeekEnum fri = WeekEnum.Fri;
WeekEnum sat = WeekEnum.Sat;

Log.d("test enum","enum static method :" + WeekEnum.infoPrint());
Log.d("test enum","enum tue.helloEnum :" + tue.helloEnum());
Log.d("test enum","enum fri.helloEnum :" + fri.helloEnum());
Log.d("test enum","enum fri is work? " + fri.isWork());
Log.d("test enum","enum sat is work? " + sat.isWork());
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
enum static method :Monday to Sunday! 
enum tue.helloEnum :happy to work      
enum fri.helloEnum :sad to work        
enum fri is work? true                 
enum sat is work? false                
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

2.3 实现接口

同样作为类，枚举类型也可以实现接口。用法和普通类的用法一致。

public interface IDoSomeThing{
    public void doJobs();
}
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3
public enum WeekEnum implements IDoSomeThing{
    Mon(true),Tue(true),Wen(true),Thu(true),Fri(true){
        @Override
        public String helloEnum() {
            return "sad to work";
        }
    },
    Sat(false){
        @Override
        public void doJobs() {
            Log.d("test enum","I am at resting");
        }
    },Sun(false);
  ...
  ...
    @Override
    public void doJobs() {
        Log.d("test enum","I am at working");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
fri.doJobs();
sat.doJobs();
 
 
  • 1
  • 2

 
 
  • 1
  • 2
I am at working
I am at resting
 
 
  • 1
  • 2

 
 
  • 1
  • 2

3、枚举的典型应用场景

3 .1 常量

如果enum不添加任何方法的话，枚举的默认值为：从0开始的有序数值，每次递增1。

如果定义的枚举类型没有任何方法的话，可以在最后一个实例（常量）后加”,” 或”;” 或什么都不加。

注意：如果枚举类中添加了方法，则必须在最后一个实例后添加”;”

以下三种方式定义都可以：

enum ColorEnum{ RED, WHITE, BLUE, BLACK, GREEN }
enum ColorEnum{ RED, WHITE, BLUE, BLACK, GREEN, }
enum ColorEnum{ RED, WHITE, BLUE, BLACK, GREEN; }
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

3.2 switch中

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;  
        }  
    }  
}  
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

3.3 组织枚举

可以将类型相近的枚举通过接口或类组织起来，但是一般用接口方式进行组织。

原因是：Java接口在编译时会自动为enum类型加上public static修饰符；Java类在编译时会自动为 enum 类型加上static修饰符。看出差异了吗？

没错，就是说，在类中组织 enum，如果你不给它修饰为 public，那么只能在本包中进行访问。

在接口中不加public static修饰词，也能在其他包中被引用。

public interface INumberEnum{
    public int getCode();
    public String getDescription();
}
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4
public interface Plant {
    enum Vegetable implements INumberEnum {
        POTATO(0, "土豆"),
        TOMATO(0, "西红柿");

        Vegetable(int number, String description) {
            this.code = number;
            this.description = description;
        }

        private int code;
        private String description;

        @Override
        public int getCode() {
            return 0;
        }

        @Override
        public String getDescription() {
            return null;
        }
    }

    enum Fruit implements INumberEnum {
        APPLE(0, "苹果"),
        ORANGE(0, "桔子"),
        BANANA(0, "香蕉");

        Fruit(int number, String description) {
            this.code = number;
            this.description = description;
        }

        private int code;
        private String description;

        @Override
        public int getCode() {
            return 0;
        }

        @Override
        public String getDescription() {
            return null;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

3.4 策略枚举(没用过)

这种枚举通过枚举嵌套枚举的方式，将枚举实例（常量）分类处理，虽然没有通过switch语句使用简洁，但是更加灵活。

enum PayrollDay {
    MONDAY(PayType.WEEKDAY), TUESDAY(PayType.WEEKDAY), WEDNESDAY(
            PayType.WEEKDAY), THURSDAY(PayType.WEEKDAY), FRIDAY(PayType.WEEKDAY), SATURDAY(
            PayType.WEEKEND), SUNDAY(PayType.WEEKEND);

    private final PayType payType;

    PayrollDay(PayType payType) {
        this.payType = payType;
    }

    double pay(double hoursWorked, double payRate) {
        return payType.pay(hoursWorked, payRate);
    }

    // 策略枚举
    private enum PayType {
        WEEKDAY {
            double overtimePay(double hours, double payRate) {
                return hours <= HOURS_PER_SHIFT ? 0 : (hours - HOURS_PER_SHIFT)
                        * payRate / 2;
            }
        },
        WEEKEND {
            double overtimePay(double hours, double payRate) {
                return hours * payRate / 2;
            }
        };
        private static final int HOURS_PER_SHIFT = 8;

        abstract double overtimePay(double hrs, double payRate);

        double pay(double hoursWorked, double payRate) {
            double basePay = hoursWorked * payRate;
            return basePay + overtimePay(hoursWorked, payRate);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
Log.d("test enum","时薪100的人在周五工作8小时的收入：" + PayrollDay.FRIDAY.pay(8.0, 100));
Log.d("test enum","时薪100的人在周六工作8小时的收入：" + PayrollDay.SATURDAY.pay(8.0, 100));
 
 
  • 1
  • 2

 
 
  • 1
  • 2

3.5 EnumSet和EnumMap

EnumSet 是枚举类型的高性能Set实现。它要求放入它的枚举常量必须属于同一枚举类型。它的使用与其他的set没有什么不同，只是在构造的时候有一些特殊而已。

public void showEnumSetValue(EnumSet<ColorEnum> enumSet){
    Log.d("enum test","enum set value is : "+ Arrays.toString(enumSet.toArray()));
}
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3
//创建一个之类enum类型的空集合
EnumSet<ColorEnum> enumEnumSet = EnumSet.noneOf(ColorEnum.class);
showEnumSetValue(enumEnumSet);
enumEnumSet.add(ColorEnum.BLACK);
enumEnumSet.add(ColorEnum.BLUE);
showEnumSetValue(enumEnumSet);

//创建一个指定enum类型的所有实例的集合
EnumSet<ColorEnum> enumEnumSet1 = EnumSet.allOf(ColorEnum.class);
showEnumSetValue(enumEnumSet1);

//创建一个指定enum初始化内容的集合
EnumSet<ColorEnum> enumEnumSet2 = EnumSet.of(ColorEnum.GREEN,ColorEnum.WHITE);
showEnumSetValue(enumEnumSet2);

//创建指定类型，指定范围的集合，包含边界数据
EnumSet<ColorEnum> enumEnumSet3 = EnumSet.range(ColorEnum.BLUE,ColorEnum.GREEN);
showEnumSetValue(enumEnumSet3);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
enum set value is : []
enum set value is : [BLUE, BLACK]
enum set value is : [RED, WHITE, BLUE, BLACK, GREEN]
enum set value is : [WHITE, GREEN]
enum set value is : [BLUE, BLACK, GREEN]
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

EnumMap 是专门为枚举类型量身定做的Map实现。虽然使用其它的Map实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用EnumMap会更加高效：它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以EnumMap使用数组来存放与枚举类型对应的值。这使得EnumMap的效率非常高。

EnumMap<ColorEnum, String> enumStringEnumMap = new EnumMap<ColorEnum, String>(ColorEnum.class);
enumStringEnumMap.put(ColorEnum.RED,"红色");
enumStringEnumMap.put(ColorEnum.BLUE,"蓝色");
enumStringEnumMap.put(ColorEnum.GREEN,"绿色");

for(Map.Entry<ColorEnum,String> enumStringEntry : enumStringEnumMap.entrySet()){
    Log.d("enum test","enum map key: " +enumStringEntry.getKey().name()+ " value " + enumStringEntry.getValue());
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
enum map key: RED value 红色
enum map key: BLUE value 蓝色
enum map key: GREEN value 绿色
CODE男孩
关注
专栏目录
Java枚举和C枚举的转换——JNI笔记
Zhou2828的博客
04-18 4178
前言 最近在做中间件相关，遇到一个JAVA和C之间枚举值通过JNI传递的问题。我们知道C语言的枚举型是一个集合，其每个枚举成员是一个整型常量；而JAVA的枚举其本质是一个类，继承自Enum类，每个枚举成员是枚举类型常量。他们之间是不同的两种数据类型，不能直接进行转换。Java枚举和C枚举的转换本质是Java枚举类型和int整型的转换。 两种枚举的特点 新创建的枚...
enum ordinal_Java Enum ordinal（）方法与示例
cumubi7552的博客
07-23 4173
enum ordinal 枚举类ordinal()方法 (Enum Class ordinal() method) ordinal() method is available in java.lang package. ordinal()方法在java.lang包中可用。 ordinal() method is used to return the position of this enum co...
Java中怎样由枚举常量的ordinal值获得枚举常量对象
MUM的专栏
12-10 1428
Java1.5提供了关键字enum，能够通过该关键字方便得定义自己须要的枚举类型，比方 　　enum Season { 　　SPRING, SUMMER, AUTUMN, WINTER 　　} 　　就定义了一个季节枚举类型。 　　在本例中，对于Season.SPRING这个对象，Season.SPRING.name()能够得到该对象的字符串，即“SPRING”；反之，
深入理解Java枚举类型(enum)（2）
醉逸鎏年的博客
04-30 574
枚举的常见方法 Enum抽象类常见方法 Enum是所有 Java 语言枚举类型的公共基本类（注意Enum是抽象类），以下是它的常见方法： 这里主要说明一下ordinal()方法，该方法获取的是枚举变量在枚举类中声明的顺序，下标从0开始，如日期中的MONDAY在第一个位置，那么MONDAY的ordinal值就是0，如果MONDAY的声明位置发生变化，那么ordinal方法获取到的值也随之变化...
Java枚举详解及使用实例（涵盖了所有典型用法）
09-03
Java枚举是Java语言中的一种特殊类，它用于定义一组有限的、预定义的值。枚举在Java中扮演着重要的角色，尤其是在处理固定集合的数据时，如颜色、星期、季节等。下面将详细介绍Java枚举的使用及其各种典型用法。 1....
详解java枚举用法及实例
08-30
Java枚举是编程语言中一种特殊的类，用于定义一组预定义的常量。枚举在Java中的使用丰富了代码的可读性和安全性。本篇文章将详细介绍Java枚举的用法和实例。 一、枚举类型作为常量 在Java中，枚举可以用来创建一组...
Java枚举详解
weixin_45743799的博客
03-07 149
枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。枚举在曰常生活中很常见，例如一个人的性别只能是“男”或者“女”，一周的星期只能是 7 天中的一个等。类似这种当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型。 声明枚举 声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。枚举声明的语法如下： enum-modifiers enum enumn...
Java5 枚举类详解及实例代码
08-31
Java 5 引入的枚举类型（enum）是面向对象编程中的一种重要特性，它为表示一组固定值提供了类型安全且强大的方式。在本文中，我们将深入探讨枚举类的概念、用法以及其与传统常量定义的区别。 1. 枚举类的定义与常量...
Java枚举详解与示例
"Java枚举相关的信息主要涵盖了枚举类型的特性和使用方法，包括枚举的安全性、构造函数、枚举常量的属性、接口实现、toString与valueOf方法、values方法以及ordinal方法。此外，还提及了如何遍历枚举值和在枚举中...
枚举的示例
yin_Pisces的博客
07-28 532
枚举类package com.yisces.y_enum;import java.util.EnumMap; import java.util.EnumSet;/** * 定义枚举 * @author yisces * */ public enum EnumConstant { //此时每一个枚举就想当与一个类，他们拥有共同的父类，因此要实现父类的getValue方法 ME(
JAVA基础知识修补 - 1 枚举类型
m0_46821706的博客
03-25 193
为什么要枚举类型？ 可以将常量组织起来，统一进行管理。 常用于状态码，错误码。 本质：受限制的类 枚举类（class），枚举实例（对象） 类内使用 类内枚举 常用方法 ENUM.values() 返回所有枚举值，按声明顺序返回 枚举类名.values() ENUM.valueOf(ENUM) ENUMOBJ.name()返回 具体的枚举值（对象名） ENUMOBJ.equals() ：判断是否为同一个对象。可以使用 == 来比较enum实例。 ENUMOBJ.ordinal() 返回实例在en
Java学习(5) -- 枚举详解
敲代码的小蜗牛的专栏
05-26 401
一、枚举的用法 1）常量使用 public enum EnumTest { ONE,TWO } 2）自定义函数使用 public enum EnumTest { ONE("ONE","1"),TWO("TWO","2"); private String key; private String value; private EnumTest(String key, String...
枚举报错 No enum constant XX 处理方法
花易折的博客
03-17 1万+
枚举报错 No enum constant XX 处理方法
Java中的枚举
286
04-24 345
        Enum（“枚举”）全称为 enumeration， 是 JDK 1.5  中引入的新特性，在Java开发者眼中枚举已经是再普通不过的一种类型了，可以说任何Java程序员都编写过自己的枚举类，一般这些枚举类用来表示同一类属性，如：  /** * @Description 操作系统类型 * @author ming.li * @Date 2018年4月16日 下午2...
【Java基础】枚举
Brain_L的博客
10-30 288
Java的枚举和C/C++中的枚举作用上类似，实现上不一样。本文主要探讨下Java中枚举的实现与应用。 如果要定义常量，可能会这样定义：private static final int SUCCESS = 0;一旦这样的定义多了之后，就很难管理，容易出错，甚至重复定义。用枚举的话就很简洁清晰。 枚举原理分析 public enum EnumTest { SUCCESS, ...
enum用ordinal获取对象
zhongkeli的专栏
11-23 3434
package test; import java.io.IOException; public class t1 { public enum action{ answer,learn,query; public static action valueOf(int ordinal) { if (ordinal = values().length) { thro
Enum类型详解
丿彽訡丶淺誯的博客
10-09 3949
通过指令集查看编译器给我们定义的枚举类型添加的内容，可以让我们更好的去了解枚举和应用它！
Java中Enum类型的序列化及类升级不建议用枚举的原因
热门推荐
hupoling的专栏
07-11 11万+
在Java中，对Enum类型的序列化与其他对象类型的序列化有所不同，今天就来看看到底有什么不同。下面先来看下在Java中，我们定义的Enum在被编译之后是长成什么样子的。 Java代码： Java代码 publicenumFruitEnum{ APPLE,ORAGE } 上面的代码定义了一个FruitEnum类型，是最简单形式的，下面我们来看看编...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值