java enum(枚举)使用详解 + 总结

最新推荐文章于 2023-06-17 18:52:18 发布
最新推荐文章于 2023-06-17 18:52:18 发布
阅读量454 收藏
点赞数
分类专栏： java基础

转：http://blog.csdn.net/qiyueqinglian/article/details/50738548


DK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给我的开发带来了“大”方便。 
接下来，我以自定义的枚举类LightsEnum.java和LightsEnumWithValue.java来介绍一下枚举类的使用。 
LightsEnum.java

package enums;
public enum LightsEnum {
    RED, YELLOW, GREEN
}
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

用法一：定义常量

在JDK1.5 之前，我们定义常量都是： public static fianl…. 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 
通过类名就可以直接引用这些常量，比如：LightsEnum.YELLOW

// 遍历enum
LightsEnum[] lightsEnumArr = LightsEnum.values();
for (LightsEnum e : lightsEnumArr) {
    System.out.println(e.toString());
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

运行结果： 
RED 
YELLOW 
GREEN

用法二：与switch结合

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

LightsEnum currentLight = LightsEnum.YELLOW;
switch (currentLight) {
case RED:
    System.out.println("this is the red light");
    break;
case YELLOW:
    System.out.println("this is the yellow light");
    break;
case GREEN:
    System.out.println("this is the green light");
    break;
default:
    break;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

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

运行结果：this is the yellow light

用法三：给 enum 自定义属性和方法

如果打算自定义方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 
LightsEnumWithValue.java

package enums;

public enum LightsEnumWithValue {
    RED("红灯"), YELLOW("黄灯"), GREEN("绿灯");

    // 自定义变量
    private String value;

    // 自定义普通成员方法
    public String getValue() {
        return value;
    }

    // 构造方法
    LightsEnumWithValue(String value) {
        this.value = value;
    }
}
 
 
  • 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

使用自定义的变量

LightsEnumWithValue[] lightsEnumWithValueArr = LightsEnumWithValue
                .values();
for (LightsEnumWithValue e : lightsEnumWithValueArr) {
    System.out.println("toString: " + e.toString());
    System.out.println("getValue: " + e.getValue());
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

运行结果： 
toString: RED 
getValue: 红灯 
toString: YELLOW 
getValue: 黄灯 
toString: GREEN 
getValue: 绿灯

用法四：覆盖枚举的方法

package enums;

public enum LightsEnumWithValue {
    RED("红灯"), YELLOW("黄灯"), GREEN("绿灯");

    // 自定义变量
    private String value;

    // 自定义普通成员方法
    public String getValue() {
        return value;
    }

    // 构造方法
    LightsEnumWithValue(String value) {
        this.value = value;
    }

    // 覆盖方法
    @Override
    public String toString() {
        return this.name() + "_" + this.value;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

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

调用覆盖之后的toString方法

LightsEnumWithValue[] lightsEnumWithValueArr = LightsEnumWithValue
                .values();
for (LightsEnumWithValue e : lightsEnumWithValueArr) {
    System.out.println("toString: " + e.toString());
    System.out.println("getValue: " + e.getValue());
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

运行结果（注意和用法三中的toString得到的结果不一样了）： 
toString: RED_红灯 
getValue: 红灯 
toString: YELLOW_黄灯 
getValue: 黄灯 
toString: GREEN_绿灯 
getValue: 绿灯

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于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);  
    }  
}  
 
 
  • 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

 
 
  • 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

用法六：使用接口组织枚举

public interface Food {  
    enum Coffee implements Food{  
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
    }  
    enum Dessert implements Food{  
        FRUIT, CAKE, GELATO  
    }  
}  
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
如：Food f = Food.Coffee.BLACK_COFFEE;

用法七：EnumSet，EnumMap 的应用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。

EnumSet<LightsEnum> lightsEnumSet = EnumSet.allOf(LightsEnum.class);
for (LightsEnum l : lightsEnumSet) {
    System.out.println(l.toString());
}
System.out.println("------------------EnumMap");
EnumMap<LightsEnum, String> lightsEnumMap = new EnumMap<LightsEnum, String>(
        LightsEnum.class);
lightsEnumMap.put(LightsEnum.RED, "红灯");
Set<Entry<LightsEnum, String>> set = lightsEnumMap.entrySet();
Iterator<Entry<LightsEnum, String>> iterator = set.iterator();
while (iterator.hasNext()) {
    Entry<LightsEnum, String> e = iterator.next();
    System.out.println(e.getKey().toString() + ":" + e.getValue());
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

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

运行结果： 
——————EnumSet 
RED 
YELLOW 
GREEN 
——————EnumMap 
RED:红灯

enum总结及常用方法

可以把 enum 看成是一个普通的 class，可以定义一些属性和方法,实现接口，不同之处是：enum 不能使用 extends 关键字继承其他类，因为 enum 已经继承了 java.lang.Enum（java是单一继承）

// int ordinal() 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
System.out.println("red ordinal: " + LightsEnum.RED.ordinal());
System.out.println("yellow ordinal: " + LightsEnum.YELLOW.ordinal());
System.out.println("green ordinal: " + LightsEnum.GREEN.ordinal());

// int compareTo(E o) 比较此枚举与指定对象的顺序
int compToRed = currentLight.compareTo(LightsEnum.RED);
int compToYellow = currentLight.compareTo(LightsEnum.YELLOW);
int compToGreen = currentLight.compareTo(LightsEnum.GREEN);
System.out.println("yellow compare to red: " + compToRed);
System.out.println("yellow compare to yellow: " + compToYellow);
System.out.println("yellow compare to green: " + compToGreen);

// String name() 返回此枚举常量的名称，在其枚举声明中对其进行声明
System.out.println("name: " + currentLight.name());

// String toString() 返回枚举常量的名称，它包含在声明中
System.out.println("toString: " + currentLight.toString());

// Class<E> getDeclaringClass() 返回与此枚举常量的枚举类型相对应的 Class 对象。
System.out.println("getDeclaringClass(): "
        + currentLight.getDeclaringClass().getName());

// static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
// 返回带指定名称的指定枚举类型的枚举常量。
System.out.println(LightsEnum.valueOf(LightsEnum.class, "YELLOW"));
 
 
  • 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

 
 
  • 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

运行结果： 
red ordinal: 0 
yellow ordinal: 1 
green ordinal: 2 
yellow compare to red: 1 
yellow compare to yellow: 0 
yellow compare to green: -1 
name: YELLOW 
toString: YELLOW 
getDeclaringClass(): enums.LightsEnum 
YELLOW

enum原理

语法（定义） 
创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（java.lang.Enum 是一个抽象类）。枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal)构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。 
enum 的语法结构尽管和 class 的语法不一样，但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum。LightsEnum.java和LightsEnumWithValue.java经过反编译(javap enums.LightsEnumWithValue 命令)之后得到的内容如下。 
这两个enum反编译之后的主要不同是构造函数,LightsEnumWithValue.java中还含有自定义的方法。

private LightsEnum(String s, int i)
    {
        super(s, i);
    }
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4
private LightsEnumWithValue(String s, int i, String value)
    {
        super(s, i);
        this.value = value;
    }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

LightsEnum.class

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   LightsEnum.java
package enums;
public final class LightsEnum extends Enum
{
    public static final LightsEnum RED;
    public static final LightsEnum YELLOW;
    public static final LightsEnum GREEN;
    private static final LightsEnum ENUM$VALUES[];

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

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

    public static LightsEnum valueOf(String s)
    {
        return (LightsEnum)Enum.valueOf(enums/LightsEnum, s);
    }

    static 
    {
        RED = new LightsEnum("RED", 0);
        YELLOW = new LightsEnum("YELLOW", 1);
        GREEN = new LightsEnum("GREEN", 2);
        ENUM$VALUES = (new LightsEnum[] {
            RED, YELLOW, GREEN
        });
    }
}
 
 
  • 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

 
 
  • 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

LightsEnumWithValue.class

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   LightsEnumWithValue.java

package enums;


public final class LightsEnumWithValue extends Enum
{

    public static final LightsEnumWithValue RED;
    public static final LightsEnumWithValue YELLOW;
    public static final LightsEnumWithValue GREEN;
    private String value;
    private static final LightsEnumWithValue ENUM$VALUES[];

    public String getValue()
    {
        return value;
    }

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

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

    public static LightsEnumWithValue valueOf(String s)
    {
        return (LightsEnumWithValue)Enum.valueOf(enums/LightsEnumWithValue, s);
    }

    static 
    {
        RED = new LightsEnumWithValue("RED", 0, "红灯");
        YELLOW = new LightsEnumWithValue("YELLOW", 1, "黄灯");
        GREEN = new LightsEnumWithValue("GREEN", 2, "绿灯");
        ENUM$VALUES = (new LightsEnumWithValue[] {
            RED, YELLOW, GREEN
        });
    }
}
 
 
  • 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
  • 49
  • 50
  • 51
  • 52

 
 

  
  
 
 

 
 
  • 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
  • 49
  • 50
  • 51
  • 52

参照： 
http://www.cnblogs.com/hemingwang0902/archive/2011/12/29/2306263.html 
http://blog.lichengwu.cn/java/2011/09/26/the-usage-of-enum-in-java/


爱笑的T_T
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
javaenum(枚举)使用详解+总结.pdf
01-11
javaenum(枚举)使用详解+总结.pdf
java enum enum_java枚举类型enum的使用
weixin_36474829的博客
02-12 219
2015-10-24 java达人Java 中 的枚举类型采用关键字enum 来定义，从jdk1.5才有的新类型，所有的枚举类型都是继承自Enum 类型。要了解枚举类型，建议大家先打开jdk 中的Enum类简单读一下，这个类里面定义了很多protected 方法，比如构造函数，如果要使用这些方法我们可以把枚举类型定义到当前类中。每个枚举类型，都有自己的名字和顺序，当我们输出一个枚举类型的时候，会输...
Java基础学习——枚举类
让我先想想起啥名字
04-28 785
Java基础学习——枚举类 前几天在面试中被问到了枚举类，现在就把枚举类的相关知识点总结在下面。 枚举可以用enum关键字来定义，枚举类型的取值默认是public static final。划重点了，虽然没有直接用final来修饰，但枚举类默认是final的，也就是说，枚举类不能被继承！ 枚举类的构造方法默认是private。 用enum定义的枚举类是默认继承java.lang.Enum类的，而...
java类的修饰词—final、static和枚举类
weixin_50263454的博客
05-08 1265
1.final final是修饰词，可以修饰类、成员变量和方法，表示最终的意思，修饰的内容特点是不能被修改的。 1）①final修饰类是不能被继承的，也没有子类 ② final修改的方法不能被重写 package com.itstudy.bean; /** * final * 1.final修饰的类不能被继承 * 2.final修改的方法不能被重写 */ public final class Father { public void eat(){ ...
Enum、Static、Final
BrianLee的专栏
08-27 2206
Enum（枚举）： 1、用途：
Java枚举类型enum的详解及使用
08-30
主要介绍了Java枚举类型enum的详解及使用的相关资料,需要的朋友可以参考下
Java的枚举enum示例详解
08-25
主要给大家介绍了关于Java的枚举enum的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java（enum）枚举用法详解
09-01
本篇文章主要介绍了Java 枚举用法详解，枚举的好处：可以将常量组织起来，统一进行管理。有兴趣的可以一起来了解一下。
java 中枚举类enum的values()方法的详解
08-29
主要介绍了java 中枚举类enum的values()方法的详解的相关资料,希望通过本文大家能够掌握这部分内容，需要的朋友可以参考下
Java关键字final、static使用总结
liuyu2783的博客
10-27 739
一、final 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。 final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 fin
十、复习10
qq_41416122的博客
05-13 122
今日内容 1 关键字 2 代码块 3 接口 4 枚举 1 Java中的关键字 1.1 static关键字 static关键字 : 静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员 static特点 : 静态成员被所类的所有对象共享 随着类的加载而加载 , 优先于对象存在 可以通过对象调用 , 也可以通过类名调用 , 建议使用类名 public class Student { String name; int age;
【解惑】理解java枚举类型
ccnunlp的专栏
09-26 237
枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum来定义一个枚举类。下面就是一个典型枚举类型的定义： public enum Color{ RED,BLUE,BLACK,YELLOW,GREEN } 显然，enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类(java.lang.Enum&lt;E&gt;)。...
SpringBoot传参转换枚举
weixin_30852367的博客
06-02 1079
有时候，我们传参的时候，希望使用枚举类来当作参数 public enum VipEnum { HUANG(1, "黄钻"), HONG(2, "红钻"); private Integer id; private String value; VipEnum(Integer id, String value) { this.id = id; ...
int enum java_Java Enum和String及int的相互转化示例
weixin_28984379的博客
02-12 214
一、定义性别枚举枚举(enum)，是指一个经过排序的、被打包成一个单一实体的项列表。使用枚举增加程序可读性、降低耦合性。/*** 性别枚举*/public enum Gender {male("男"),female("女");private String name;private Gender(String name) {this.name = name;}public String getNam...
java的数据类型：引用数据类型（String、数组、枚举）
yu的博客
01-19 5430
java的数据类型：引用数据类型（String、数组、枚举）
java如何将String转换为enum
qq_43842093的博客
11-23 5079
问题 假设定义了如下的enum（枚举）： public enum Blah { A, B, C, D } 已知枚举对应的String值，希望得到对应的枚举值。例如，已知"A"，希望得到对应的枚举——Blah.A，应该怎么做？ Enum.valueOf()是否能实现以上目的，如果是，那我如何使用？ 答案 是的，Blah.valueOf(“A”) 将会得到 Blah.A 静态方法valueOf() 和 values() 不存在于源码中，而是在编译时创建，我们也可以在JavaDoc查看到它们，比如 Di
Java 将枚举类型与int或String变量互相转换
最新发布
wh445306
06-17 1450
JAVA 枚举类型public enum enumType {MOUTH, YEAR, ALL, SELECT} 如何跟int或String变量互相转换？说明：综合来说，个人更推荐优先使用String变量来进行交换，更方便。方法获取所有枚举常量数组，然后根据序号获取对应的枚举常量。将枚举类型转换为 int 变量，可以使用枚举类型中的。将 int 变量转换为枚举类型，可以使用枚举类型中的。方法或，它返回枚举常量在枚举中定义时的序数。以下是使用String变量互相转换示例代码;
java8 枚举 继承_java 自定义可继承枚举Enum的案例
weixin_34258386的博客
02-26 922
一、定义enum抽象类public class AbstractEnum {private static final Map nameEnumMap = new ConcurrentHashMap<>();@Getterprotected String name;protected AbstractEnum () {}protected AbstractEnum(String name...
C语言--enum，typedef enum 枚举类型详解
05-24
枚举类型使用关键字enum来定义，其语法格式如下： ``` enum 枚举类型名 { 标识符[=整型常数], 标识符[=整型常数], ... } 枚举变量; ``` 其中，枚举类型名是用户自定义的枚举类型名称，标识符是枚举类型中定义的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值