enum枚举java【java,enum(枚举)使用详解+,总结】
java枚举类型enum用法 switch-概述说明以及解释
java枚举类型enum用法switch-概述说明以及解释1.引言1.1 概述在计算机编程中，枚举类型(enum)是一种特殊的数据类型，用于表示一组具名的常量。
与普通的变量不同，枚举类型的取值是有限且固定的，它将一系列具有相似属性或关联关系的常量进行分组，方便在程序中进行使用和管理。
在Java编程语言中，枚举类型是一种独立的类，它可以包含多个枚举常量，并且允许定义属性和方法。
枚举类型的定义方式简单明了，可以帮助程序员更好地组织和管理常量。
本文将重点介绍Java中枚举类型enum的用法，并阐述枚举类型在switch语句中的应用。
首先，我们将讨论枚举类型的定义和声明，包括如何创建枚举类型以及如何给枚举常量赋值。
接着，我们将探讨枚举类型的属性和方法，包括如何为枚举常量定义属性和方法，以及如何在程序中使用它们。
最后，我们将重点关注枚举类型在switch语句中的应用，介绍如何使用switch语句处理枚举类型的不同取值。
通过本文的学习，读者将能够更好地掌握枚举类型enum的用法，进一步提升自己的编程能力。
接下来，我们将详细介绍枚举类型的定义和声明。
1.2 文章结构本文将按照以下结构来探讨Java枚举类型（enum）以及其在switch 语句中的应用。
1. 引言1.1 概述在引言部分，我们将简要介绍Java枚举类型（enum）的基本概念和作用，以及本文的目的和重要性。
1.2 文章结构（当前部分）在文章结构部分，我们将详细介绍本文的整体结构，让读者对接下来的内容有一个清晰的认知。
1.3 目的在目的部分，我们将阐述本文的目标是为读者提供全面了解Java 枚举类型（enum）及其在switch语句中应用的知识，以帮助读者在实际开发中更好地运用这些概念。
2. 正文在这一节中，我们将介绍如何定义和声明枚举类型，以及枚举类型的特点和用法。
2.2 枚举类型的属性和方法这一节将介绍枚举类型可以拥有属性和方法，以及如何使用这些属性和方法来对枚举类型进行操作和使用。
详解Java枚举类型enum及其使用
详解Java枚举类型enum及其使用详解Java枚举类型enum及其使用Java 中的枚举类型采用关键字enum 来定义，从jdk1.5才有的新类型，所有的枚举类型都是继承自Enum 类型。
以下是店铺搜索整理的关于Java枚举类型enum详解及其使用，,需要的朋友可以参考本文!想了解更多相关信息请持续关注我们店铺!要了解枚举类型，建议大家先打开jdk 中的Enum 类简单读一下，这个类里面定义了很多protected 方法，比如构造函数，如果要使用这些方法我们可以把枚举类型定义到当前类中。
每个枚举类型，都有自己的名字和顺序，当我们输出一个枚举类型的时候，会输入枚举类型的name ，具体可以参考下面的例子。
一、通常定义常量方法我们通常利用public final static 方法定义的代码如下，分别用1 表示红灯，3 表示绿灯，2 表示黄灯。
package com.csdn.myEnum;public class Light {/* 红灯 */public final static int RED =1;/* 绿灯 */public final static int GREEN =3;/* 黄灯 */public final static int YELLOW =2;}二、枚举类型定义常量方法枚举类型的简单定义方法如下，我们似乎没办法定义每个枚举类型的值。
比如我们定义红灯、绿灯和黄灯的代码可能如下：public enum Light {RED , GREEN , YELLOW ;}我们只能够表示出红灯、绿灯和黄灯，但是具体的值我们没办法表示出来。
别急，既然枚举类型提供了构造函数，我们可以通过构造函数和覆写toString 方法来实现。
首先给Light 枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString 方法，在该方法中返回从构造函数中传入的参数，改造后的'代码如下：public enum Light {// 利用构造函数传参RED (1), GREEN (3), YELLOW (2);// 定义私有变量private int nCode ;// 构造函数，枚举类型只能为私有private Light( int _nCode) {this . nCode = _nCode;}@Overridepublic String toString() {return String.valueOf ( this . nCode );}}三、完整示例代码枚举类型的完整演示代码如下：package com.csdn.myEnum;import java.util.EnumMap;import java.util.EnumSet;public class LightT est {// 1. 定义枚举类型public enum Light {// 利用构造函数传参RED (1), GREEN (3), YELLOW (2);// 定义私有变量private int nCode ;// 构造函数，枚举类型只能为私有private Light( int _nCode) {this . nCode = _nCode;}@Overridepublic String toString() {return String.valueOf ( this . nCode );}}/*** @param args*/public static void main(String[] args ) {// 1. 遍历枚举类型System. out .println( " 演示枚举类型的遍历 ......" ); testTraversalEnum ();// 2. 演示 EnumMap 对象的使用System. out .println( " 演示 EnmuMap 对象的使用和遍历 ....." ); testEnumMap ();// 3. 演示 EnmuSet 的使用System. out .println( " 演示 EnmuSet 对象的使用和遍历 ....." ); testEnumSet ();}/*** 演示枚举类型的遍历*/private static void testTraversalEnum() {Light[] allLight = Light.values ();for (Light aLight : allLight) {System. out .println( " 当前灯 name ： " + ());System. out .println( " 当前灯 ordinal ： " + aLight.ordinal());System. out .println( " 当前灯： " + aLight);}}/*** 演示 EnumMap 的使用， EnumMap 跟 HashMap 的使用差不多，只不过 key 要是枚举类型*/private static void testEnumMap() {// 1. 演示定义 EnumMap 对象， EnumMap 对象的构造函数需要参数传入 , 默认是key 的类的类型EnumMap currEnumMap = new EnumMap(Light. class );currEnumMap.put(Light. RED , " 红灯 " );currEnumMap.put(Light. GREEN , " 绿灯 " );currEnumMap.put(Light. YELLOW , " 黄灯 " );// 2. 遍历对象for (Light aLight : Light.values ()) {System. out .println( "[key=" + () + ",value="+ currEnumMap.get(aLight) + "]" );}}/*** 演示 EnumSet 如何使用， EnumSet 是一个抽象类，获取一个类型的枚举类型内容* 可以使用 allOf 方法*/private static void testEnumSet() {EnumSet currEnumSet = EnumSet.allOf (Light. class );for (Light aLightSetElement : currEnumSet) {System. out .println( " 当前EnumSet 中数据为：" + aLightSetElement);}}}执行结果如下：演示枚举类型的遍历 ......当前灯 name ： RED当前灯 ordinal ： 0当前灯： 1当前灯 name ： GREEN当前灯 ordinal ： 1当前灯： 3当前灯 name ： YELLOW当前灯 ordinal ： 2当前灯： 2演示 EnmuMap 对象的使用和遍历 .....[key=RED,value= 红灯 ][key=GREEN,value= 绿灯 ][key=YELLOW,value= 黄灯 ]演示 EnmuSet 对象的使用和遍历 .....当前 EnumSet 中数据为： 1当前 EnumSet 中数据为： 3当前 EnumSet 中数据为： 2四、通常定义常量方法和枚举定义常量方法区别以下内容可能有些无聊，但绝对值得一窥1. 代码：public class State {public static final int ON = 1;public static final Int OFF= 0;}有什么不好了，大家都这样用了很长时间了，没什么问题啊。
Java枚举（enum）详解
Java枚举（enum）详解Java 枚举知识点概念enum的全称为 enumeration，是 JDK 1.5 中引⼊的新特性。
在Java中，被enum关键字修饰的类型就是枚举类型。
形式如下：enum Color { RED, GREEN, BLUE }如果枚举不添加任何⽅法，枚举值默认为从0开始的有序数值。
以 Color 枚举类型举例，它的枚举常量依次为RED：0，GREEN：1，BLUE：2。
枚举的好处：可以将常量组织起来，统⼀进⾏管理。
枚举的典型应⽤场景：错误码、状态机等。
枚举类型的本质尽管enum看起来像是⼀种新的数据类型，事实上，enum是⼀种受限制的类，并且具有⾃⼰的⽅法。
创建enum时，编译器会为你⽣成⼀个相关的类，这个类继承⾃ng.Enum。
ng.Enum类声明public abstract class Enum<E extends Enum<E>>implements Comparable<E>, Serializable { ... }枚举的⽅法在enum中，提供了⼀些基本⽅法：values()：返回 enum 实例的数组，⽽且该数组中的元素严格保持在 enum 中声明时的顺序。
name()：返回实例名。
ordinal()：返回实例声明时的次序，从0开始。
getDeclaringClass()：返回实例所属的 enum 类型。
equals()：判断是否为同⼀个对象。
可以使⽤==来⽐较enum实例。
此外，ng.Enum实现了Comparable和Serializable接⼝，所以也提供compareTo()⽅法。
例：展⽰enum的基本⽅法public class EnumMethodDemo {enum Color {RED, GREEN, BLUE;}enum Size {BIG, MIDDLE, SMALL;}public static void main(String args[]) {System.out.println("=========== Print all Color ===========");for (Color c : Color.values()) {System.out.println(c + " ordinal: " + c.ordinal());}System.out.println("=========== Print all Size ===========");for (Size s : Size.values()) {System.out.println(s + " ordinal: " + s.ordinal());}Color green = Color.GREEN;System.out.println(<span class="hljs-string">"green name(): "</span> + ());System.out.println(<span class="hljs-string">"green getDeclaringClass(): "</span> + green.getDeclaringClass());System.out.println(<span class="hljs-string">"green hashCode(): "</span> + green.hashCode());System.out.println(<span class="hljs-string">"green compareTo Color.GREEN: "</span> + pareTo(Color.GREEN));System.out.println(<span class="hljs-string">"green equals Color.GREEN: "</span> + green.equals(Color.GREEN));System.out.println(<span class="hljs-string">"green equals Size.MIDDLE: "</span> + green.equals(Size.MIDDLE));System.out.println(<span class="hljs-string">"green equals 1: "</span> + green.equals(<span class="hljs-number">1</span>));System.out.format(<span class="hljs-string">"green == Color.BLUE: %b\n"</span>, green == Color.BLUE);}输出=========== Print all Color ===========RED ordinal: 0GREEN ordinal: 1BLUE ordinal: 2=========== Print all Size ===========BIG ordinal: 0MIDDLE ordinal: 1SMALL ordinal: 2green name(): GREENgreen getDeclaringClass(): class org.zp.javase.enumeration.EnumDemo$Colorgreen hashCode(): 460141958green compareTo Color.GREEN: 0green equals Color.GREEN: truegreen equals Size.MIDDLE: falsegreen equals 1: falsegreen == Color.BLUE: false枚举的特性枚举的特性，归结起来就是⼀句话：除了不能继承，基本上可以将enum看做⼀个常规的类。
java,enum(枚举)使用详解+,总结 enum枚举java
java,enum(枚举)使用详解+,总结 enum枚举javaenum的全称为enumeration，是jdk1.5中引入的新特性，存放在ng包中。
下面是我在使用enum过程中的一些经验和总结。
完整的接口定义常量语法（定义）建立枚举类型必须采用enum关键字，暗含了所建立的类型都就是ng.enum类的子类（ng.enum就是一个抽象类）。
枚举类型合乎通用型模式classenum这段代码实际上调用了7次enum(stringname,intordinal)：结点、switch等常用操作方式对enum进行遍历和switch的操作示例代码：输入结果：enum对象的常用方法介绍intcompareto(eo)比较此枚举与指定对象的顺序。
classgetdeclaringclass()返回与此枚举常量的枚举类型相对应的class对象。
stringname()返回此枚举常量的名称，在其枚举声明中对其进行声明。
intordinal()返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
stringtostring()返回枚举常量的名称，它包含在声明中。
static输出结果：给enum自定义属性和方法给enum对象加一下value的属性和getvalue()的方法：输入结果：enumset，enummap的应用原理分析enum的语法结构尽管和class的语法不一样，但是经过编译器编译之后产生的是一个class文件。
该class文件经过反编译可以看到实际上是生成了一个类，该类继承了ng.enum。
enumtest经过反编译(javapcohmw.test.enumtest命令)之后得到的内容如下：所以，实际上enum就是一个class，只不过java编译器帮忙我们搞了语法的解析和编程而已。
总结可以把enum看作就是一个普通的class，它们都可以定义一些属性和方法，不同之处就是：enum无法采用extends关键字承继其他类，因为enum已经承继了ng.enum （java就是单一承继）。
java 枚举类型enum用法
java 枚举类型enum用法Java中定义枚举类型enum可以把相关的常量定义在一个枚举类型名称之下，让调用者更方便地调用、使用它们。
枚举类型enum可以被看作是一种类，它是一种特殊的类，它被用来表示常量，这些常量由一组名称、标识符和相关值来表示。
枚举类型enum的定义枚举类型enum的类定义格式如下：enum举类型名称 {//定义枚举常量//定义枚举常量...}枚举类型enum的常量定义格式如下：常量名称(参数1，参数2，...);定义枚举类型enum可以采用静态块或构造函数，允许用户自定义枚举变量，以及用于构造每个枚举变量的方法。
使用枚举类型enum 可以确保变量的唯一性。
枚举类型enum的作用枚举类型enum的定义可以有效地使程序更容易理解。
由于枚举类型enum的常量名称包含在一个类中，因此这些常量可以通过类的继承来重用。
枚举类型enum的常量可以作为参数或者返回类型传递给方法，使代码更加易读。
枚举类型enum也可以有效地改善程序中常量的管理，而不需要在多处定义常量。
枚举类型enum还可以帮助程序员设置权限，限制对特殊资源的访问，从而使程序具有更好的安全性。
使用枚举类型enum枚举类型enum可以被用于做如下操作：1、枚举可以被用来定义常量：enum Type { NUMBER, STRING, BOOLEAN };2、枚举可以被用作循环条件：for (Type type : Type.values()) {System.out.println(type);}3、枚举可以被用作switch条件：Type type = Type.NUMBER;switch (type) {case NUMBER: System.out.println(umber break;case STRING: System.out.println(string break;case BOOLEAN: System.out.println(boolean break;}4、枚举可以用来定义限制：public class MyClass {public void doSomething(Type type) {if (type == Type.NUMBER) {// do something}}}总结总而言之，枚举类型enum可以使代码更容易理解，提升变量的重用性，改善常量的管理，帮助程序员设置权限以及提升程序的安全性，是Java语言中的一种重要类型。
java 枚举enum用法
java 枚举enum用法在Java 中，枚举（enum）是一种特殊的数据类型，它允许程序员定义一个包含固定常量集合的数据类型。
以下是Java 中枚举的一些常见用法：定义枚举类型：public enum Day {MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY}访问枚举常量：Day today = Day.MONDAY; // 初始化一个枚举变量// 使用枚举常量if (today == Day.MONDAY) {System.out.println("It's Monday!");}枚举方法和属性：public enum Day {MONDAY("Monday", 1),// 其他枚举常量...private final String name;private final int order;// 构造函数Day(String name, int order) { = name;this.order = order;}// 获取枚举常量的名称public String getName() {return name;}// 获取枚举常量的顺序public int getOrder() {return order;}}使用枚举和switch 语句：Day today = Day.MONDAY;switch (today) {case MONDAY:System.out.println("It's Monday!");break;case TUESDAY:System.out.println("It's Tuesday!");break;// 其他枚举常量...default:System.out.println("It's another day!");break;}枚举的迭代：// 遍历所有枚举常量for (Day day : Day.values()) {System.out.println(day);}枚举在Java中常用于定义一组固定的常量，可以提高代码的可读性和可维护性。
java枚举类型enum用法
java枚举类型enum用法Java中的枚举类型enum是一种特殊的类，用来表示一组预定义的常量，它能避免switch语句和if-else语句，减少编码和维护的复杂性，提高代码的可读性，提高程序的健壮性。
本文将主要介绍enum类型的用法，包括定义枚举类型、声明枚举类变量、使用枚举类型的值、枚举类型的多重继承等。
一、定义枚举类型1.1明枚举类型在Java中，enum类型是一种特殊的类，语法如下：public enum举名 {举值1,举值2,…… };举例：public enum Season {Spring, Summer, Autumn, Winter};1.2现多态可以通过实现接口，实现多态，格式如下：public enum举类型 implements口{枚举值1,举值2,……} 实例：public enum Color implements Paint {RED, GREEN, BLUE};二、声明枚举类变量使用枚举类型时，需要先声明一个枚举类型的变量：public static void main(String[] args) {Season s = Season.Spring;}3.1历枚举类型可以使用 for环遍历枚举类型：for(Season s : Season.values()) { System.out.println(s);}3.2 switch语句中使用枚举类型可以在switch语句中使用枚举类型： switch(s) {case Spring:System.out.println(春天来了break;case Summer:System.out.println(夏天来了break;case Autumn:System.out.println(秋天来了break;case Winter:System.out.println(冬天来了break;}枚举类型可以实现多种继承，格式如下：public enum举名 extends举类型,口1,口2{枚举值1,举值2,…};举例：public enum Gender extends Human,Person{MALE, FEMALE};五、结论枚举类型enum是Java中一种特殊的类，它限定了变量的值，减少编码的复杂性，提升代码的可读性，提高程序的健壮性。
JAVA中枚举Enum详解
JAVA中枚举Enum详解1.关键字:enum。
枚举可以定义成单独的⽂件，也可以定义在其他类内部。
枚举在类内部的⽰例:public class EnumInner {public static void main(String[] args) {Day day=Day.MONDAY;}enum Day{MONDAY,TUESDAY,THIRSDAY,FORTHDAY,FRIDAY}}Enum⾥，需要我们定义实例，定义的实例，返回类型还是Enum这个类本⾝。
实例之间，⽤逗号隔开。
我们也可以给实例添加参数，如MONDAY("参数1","参数2","参数3",,,)。
添加参数后，我们在后⾯，定义成员变量，来接收这些参数。
因为MONDAY,TUESDAY这些，都是Enum实例，其定义的参数，就是成员变量，只不过，在Eunm⾥，实例和成员变量，混在⼀起来写了。
然后，我们提供⽅法，来获得这些实例的参数。
如下代码：public enum SimpleEnum {MONDAY("aaa","AAA"),//⼀个实例，相当于是⼀个对象。
aaa就是成员变量的值TUESDAY("bbb");//另⼀个实例//实例中写了⼏个参数，就写⼏个成员变量private String param1;//第⼀个成员变量private String param2;//第⼆个成员变量/*** 枚举可以定义构造⽅法，但是构造⽅法都是私有的，或者是默认修饰符，不能⽤public修饰符，编译都过不去* 因为构造⽅法我们不能⼿动调⽤，是编译器⾃⼰调⽤的* 在实例中，我们有⼏个参数，定义构造器时，就要写⼏个参数的构造⽅法，这是为了给成员变量赋值。
* @param param1* @param param2*/private SimpleEnum(String param1,String param2) {this.param1=param1;this.param2=param2;}private SimpleEnum(String param){this.param1=param;}/*** 通过提供⽅法，供外部获得实例的参数值。
java枚举类型enum用法
java枚举类型enum用法Javaenum型是一种特殊的类，可以定义一组常量，每个常量都代表可以使用的不同值。
在 Java 中，一般使用枚举类型来表示常见的天数，颜色，状态等。
本文将介绍枚举类型 enum使用方法，并对可以使用 enum型的具体场景做出解释。
一、enum型的定义在 Java 中，枚举类型 enum一种特殊的类，它用于定义一组常量，每个常量都代表可以使用的不同值。
定义 enum型时，需要使用关键字 enum声明一个枚举类型，并使用关键字跟一组枚举常量来定义枚举类型，如下所示：enum Color{RED, GREEN, BLUE}在上面的代码中，我们定义了一个枚举类型 Color，它包含三个枚举常量 RED、GREEN BLUE。
每一个枚举常量都代表一个可以使用的不同值，同时，每一个枚举常量都是一个这个枚举类型的实例，每一个实例都有一些属性和方法，它们都是继承自 Enum。
二、enum型的使用1、使用枚举类型的值一旦定义了一个枚举类型，就可以开始使用它的值了。
使用枚举类型的值非常简单，只需要将枚举类型声明为一个变量，然后使用枚举类型的值即可，如下所示：Color color = Color.RED;在上面的代码中，我们首先声明了一个 Color型的变量 color，然后使用 Color型的值 Color.RED赋值。
2、switch句中使用枚举类型一般来说，switch句用来检查一个变量的值，并根据变量的值来执行不同的代码。
在 Java 中，switch句可以使用枚举类型的值来进行检查，如下所示：switch(color){case RED://行某些代码break;case GREEN://行某些代码break;case BLUE://行某些代码break;}在上面的代码中，我们使用了 Color型的值来检查 color值，根据 color值，switch句会执行不同的代码。
三、使用 enum型的场景1、当使用常量时使用 enum型可以替代常量，比如当需要定义一些常量时，我们可以使用 enum型来定义一组常量，这组常量可以使用不同的值，从而避免使用字符串或者整数定义常量，而使用 enum型定义常量时，字符串或者整数都可以直接映射到枚举常量上。
全面解读Java中的枚举类型enum的使用
全⾯解读Java中的枚举类型enum的使⽤关于枚举⼤多数地⽅写的枚举都是给⼀个枚举然后例⼦就开始switch，可是我想说，我代码⾥头来源的数据不太可能就是枚举，通常是字符串或数字，⽐如⼀个SQL我解析后⾸先判定SQL类型，通过截取SQL的token，截取出来可能是SELECT、DELETE、UPDATE、INSERT、ALTER等等，但是都是字符串，此时我想⽤枚举就不⾏了，我要将字符串转换成枚举怎么转呢，类似的情况还有从数据库取出数据根据⼀些类型做判定，从页⾯传⼊数据，根据不同的类型做不同的操作，但是都是字符串，不是枚举，悲剧的是我很少看到有⼈写到这个东西；所以我把它写下来，希望有⼈能⽤到。
⾸先为什么要⽤枚举？我们在什么时候⽤枚举⽐较好，⽤枚举有啥优势？我认为哈，当你在⼀些⼀个范畴类，并可列举，不变化的类型，⽤以指导程序向不同的地⽅路由，⽤枚举是较好的选择；听起来有点绕，不过有个例⼦也许可以明⽩，例如：我们可以列举下⽇常⼯作⽇所做的事情：上班、开会、吃饭、睡觉等我们可以列举医院五官科需要检查⼈的部位：眼睛、⿐⼦、⽿朵、嘴巴等这些都是可以被列举的，且每种事情我们要⽤不同的⽅式去做；当然你可以说：1、可以⽤动态⽅法分派，通过配置⽂件或annotation；2、可以使⽤常量来达到类似的效果；3、直接通过字符串的equals来表达，⽤if else来表达如果⽤配置加⽅法分派来做，是灵活，便于修改；但是如果在很多不经常修改的参数上，我们⽤这中⽅式往往增加配置的负担，并且当你需要看系统逻辑的时候，需要需要⼀遍看配置⼀遍看代码；不过，如果参数是可动态变换的信息，⽤配置是正确的选择；⽽常量的使⽤，通常在switch case的时候都是数字，字符串在java中是不能做switch case的，使⽤常量的⽬的⽐case 1、case 2 …这种增加了可读性；但是字符串数据也⿇烦，除⾮再映射⼀次，那没那个必要，其实枚举也差不多是帮你映射了⼀次，只是它将代码封装了⽽已吧了，既然他弄好了，⽽且语法上⽀持，⼲嘛不⽤呢！其次，常量虽然增加了可读性，不过他没有范畴和管理类型的概念，即⼀个枚举的定义会定义个范畴，可以很好的将这个范围所需要的东西列举出来，⽽常量通常是些⾃⼰定义的⼀些池，放在⼀些公共类中或随机定义，都是⽐较零散的，并且枚举在switch的时候就明确定义好了就在锁列举的范围内case，既可以控制好系统，增加可读性，并且可以随时查看这个范畴的枚举信息到底有那些，达到类似看配置⽂件的作⽤；不过还是回到那句话，如果参数是可变的，那么就不适合做枚举，枚举是⼀定是可列举的，或者说当前系统考虑范围是可以被枚举的，例如上⾯的医院五官科，可能还有很多没有列举到，但是当前医院只处理⼏个部位，不处理其他的，就是这个道理；什么是可变的呢，例如URL参数来分派到对应⽅法，不可能⼤家加⼀段逻辑就去加⼀个枚举，加⼀个case，此时⽤【配置+动态⽅法分派】更好，当然配置可以⽤⽂件或annotation⽽已。
javaenum枚举类的用法以及高级玩法
javaenum枚举类的⽤法以及⾼级玩法enum(枚举)类介绍**java枚举类是⼀组预定义常量的集合，使⽤enum关键字声明这个类，常量名称官⽅建议⼤写 **1.enum类基本⽤法举⼀个常见的例⼦，例如星期就可以描述为⼀个枚举类，如下public enum Day {SUNDAY, MONDAY, TUESDAY, WEDNESDAY,THURSDAY, FRIDAY, SATURDAY}怎么调⽤呢，Java switch语句参数就⽀持enum类public class EnumTest {Day day;public EnumTest(Day day) {this.day = day;}public void tellItLikeItIs() {switch (day) {case MONDAY:System.out.println("周⼀各种不在状态");break;case FRIDAY:System.out.println("周五感觉还不错");break;case SATURDAY: case SUNDAY:System.out.println("周末给⼈的感觉是最棒的");break;default:System.out.println("周内感觉就那样吧。
");break;}}public static void main(String[] args) {EnumTest firstDay = new EnumTest(Day.MONDAY);firstDay.tellItLikeItIs();EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);thirdDay.tellItLikeItIs();EnumTest fifthDay = new EnumTest(Day.FRIDAY);fifthDay.tellItLikeItIs();EnumTest sixthDay = new EnumTest(Day.SATURDAY);sixthDay.tellItLikeItIs();EnumTest seventhDay = new EnumTest(Day.SUNDAY);seventhDay.tellItLikeItIs();}}运⾏结果EnumTest类运⾏结果.png2.enum类和static常量区别看了上⾯的例⼦，有些⼩伙伴就嗤之以⿐孔了，这没什么嘛，java静态常量也⼀样可以办到public class EnumTest2 {public static final int MONDAY= 1;public static final int WEDNESDAY= 3;public static final int FRIDAY= 5;public static final int SATURDAY= 6;public static final int SUNDAY= 7;public void tellItLikeItIs(int day) {switch (day) {case 1:System.out.println("周⼀各种不在状态");break;case 5:System.out.println("周五感觉还不错");break;case 6: case 7:System.out.println("周末给⼈的感觉是最棒的");break;default:System.out.println("周内感觉就那样吧。
Java枚举（enum）详解7种常见的用法
Java枚举（enum）详解7种常见的⽤法JDK1.5引⼊了新的类型——枚举。
在 Java 中它虽然算个“⼩”功能，却给我的开发带来了“⼤”⽅便。
⽤法⼀：常量在JDK1.5 之前，我们定义常量都是： public static fianl.... 。
现在好了，有了枚举，可以把相关的常量分组到⼀个枚举类型⾥，⽽且枚举提供了⽐常量更多的⽅法。
public enum Color {RED, GREEN, BLANK, YELLOW}⽤法⼆：switchJDK1.6之前的switch语句只⽀持int,char,enum类型，使⽤枚举，能让我们的代码可读性更强。
enum Signal {GREEN, YELLOW, RED}public class TrafficLight {Signal color = SignalRED;public void change() {switch (color) {case RED:color = SignalGREEN;break;case YELLOW:color = SignalRED;break;case GREEN:color = SignalYELLOW;break;}}}⽤法三：向枚举中添加新⽅法如果打算⾃定义⾃⼰的⽅法，那么必须在enum实例序列的最后添加⼀个分号。
⽽且 Java 要求必须先定义 enum 实例。
public enum Color {RED("红⾊", 1), GREEN("绿⾊", 2), BLANK("⽩⾊", 3), YELLO("黄⾊", 4);// 成员变量private String name;private int index;// 构造⽅法private Color(String name, int index) {thisname = name;thisindex = index;}// 普通⽅法public static String getName(int index) {for (Color c : Colorvalues()) {if (cgetIndex() == index) {return cname;}}return null;}// get set ⽅法public String getName() {return name;}public void setName(String name) {thisname = name;}public int getIndex() {return index;}public void setIndex(int index) {thisindex = index;}}⽤法四：覆盖枚举的⽅法下⾯给出⼀个toString()⽅法覆盖的例⼦。
Java中的Enum枚举用法
Java中的Enum枚举用法Java中的Enum用法1. 关于Java Enum:学过C/C++等语言的人，应该都对Enum类型略知一二。
Enum一般用来表示一组相同类型的常量。
如性别、日期、月份、颜色等。
对这些属性用常量的好处是显而易见的，不仅可以保证单例，且比较时候可以用”==”来替换equals。
是一种好的习惯。
JDK1.5之前没有Enum 这个类型，那时候一般用接口常量来替代。
有了JavaEnum之后，可以更贴近的表示这种常量。
2. 如何使用Java Enum简单的用法：JavaEnum简单的用法一般用于代表一组常用常量，可用来代表一类相同类型的常量值。
如：性别：public enum SexEnum {male, female;}颜色：public enum Color {RED, BLUE,GREEN,BLACK;}枚举对象里面的值都必须是唯一的。
可以通过Enum类型名直接引用该常量，如SexEnum.male,Color.RED.复杂用法：Java为枚举类型提供了一些内置的方法，同事枚举常量还可以有自己的方法。
可以很方便的遍历枚举对象，看个下面的例子：1. 代码一 WeekDay.java:public enum WeekDay {Mon("Monday"), Tue("Tuesday"), Wed("Wednesday"),Thu("Thursday"), Fri( "Friday"),Sat("Saturday"), Sun("Sunday");private final String day;private WeekDay(String day) {this.day = day;}public static void printDay(int i){switch(i){case 1:System.out.println(WeekDay.Mon); break;case 2:System.out.println(WeekDay.Tue);break;case 3:System.out.println(WeekDay.Wed);break;case 4:System.out.println(WeekDay.Thu);break;case 5:System.out.println(WeekDay.Fri);break;case 6:System.out.println(WeekDay.Sat);break;case 7:System.out.println(WeekDay.Sun);break;default:System.out.println("wrongnumber!");}}public String getDay() {return day;}}2. 代码二 WeekDayTest.java:public class WeekDayTest {public static void main(String args[]) {for (WeekDay day :WeekDay.values()) {System.out.println(day+ "====>" + day.getDay());}WeekDay.printDay(5);}}输出结果为：Mon====>MondayTue====>TuesdayWed====>WednesdayThu====>ThursdayFri====>FridaySat====>SaturdaySun====>SundayFri3. Java Enum原理JavaEnum类型的语法结构尽管和java类的语法不一样，应该说差别比较大。
Java中枚举Enum的使用详解
Java中枚举Enum的使⽤详解⼀：Enum 类型的介绍 枚举类型（Enumerated Type）很早就出现在编程语⾔中，它被⽤来将⼀组类似的值包含到⼀种类型当中。
⽽这种枚举类型的名称则会被定义成独⼀⽆⼆的类型描述符，在这⼀点上和常量的定义相似。
不过相⽐较常量类型，枚举类型可以为申明的变量提供更⼤的取值范围。
⼆：Enum 类型的特点在某些情况下，⼀个类的对象时有限且固定的，如季节类，它只有春夏秋冬4个对象这种实例有限且固定的类，在 Java 中被称为枚举类；在 Java 中使⽤ enum 关键字来定义枚举类，其地位与 class、interface 相同；枚举类是⼀种特殊的类，它和普通的类⼀样，有⾃⼰的成员变量、成员⽅法、构造器 (只能使⽤ private 访问修饰符，所以⽆法从外部调⽤构造器，构造器只在构造枚举值时被调⽤)；⼀个 Java 源⽂件中最多只能有⼀个 public 类型的枚举类，且该 Java 源⽂件的名字也必须和该枚举类的类名相同，这点和类是相同的；使⽤ enum 定义的枚举类默认继承了 ng.Enum 类，并实现了 ng.Seriablizable 和 parable 两个接⼝;所有的枚举值都是 public static final 的，且⾮抽象的枚举类不能再派⽣⼦类；枚举类的所有实例(枚举值)必须在枚举类的第⼀⾏显式地列出，否则这个枚举类将永远不能产⽣实例。
列出这些实例(枚举值)时，系统会⾃动添加 public static final 修饰，⽆需程序员显式添加。
三：Enum 使⽤1package com.ljq.test;23/**4 * 枚举⽤法详解5 *6 * @author jiqinlin7 *8*/9public class TestEnum {10/**11 * 普通枚举12 *13 * @author jiqinlin14 *15*/16public enum ColorEnum {17 red, green, yellow, blue;18 }1920/**21 * 枚举像普通的类⼀样可以添加属性和⽅法，可以为它添加静态和⾮静态的属性或⽅法22 *23 * @author jiqinlin24 *25*/26public enum SeasonEnum {27//注：枚举写在最前⾯，否则编译出错28 spring, summer, autumn, winter;2930private final static String position = "test";3132public static SeasonEnum getSeason() {33if ("test".equals(position))34return spring;35else36return winter;37 }38 }3940/**41 * 性别42 *43 * 实现带有构造器的枚举44 *45 * @author jiqinlin46 *47*/48public enum Gender{49//通过括号赋值,⽽且必须带有⼀个参构造器和⼀个属性跟⽅法，否则编译出错50//赋值必须都赋值或都不赋值，不能⼀部分赋值⼀部分不赋值；如果不赋值则不能写构造器，赋值编译也出错51 MAN("MAN"), WOMEN("WOMEN");5253private final String value;5455//构造器默认也只能是private, 从⽽保证构造函数只能在内部使⽤56 Gender(String value) {57this.value = value;58 }5960public String getValue() {61return value;62 }63 }6465/**66 * 订单状态67 *68 * 实现带有抽象⽅法的枚举69 *70 * @author jiqinlin71 *72*/73public enum OrderState {74/** 已取消 */75 CANCEL {public String getName(){return "已取消";}},76/** 待审核 */77 WAITCONFIRM {public String getName(){return "待审核";}},78/** 等待付款 */79 WAITPAYMENT {public String getName(){return "等待付款";}},80/** 正在配货 */81 ADMEASUREPRODUCT {public String getName(){return "正在配货";}},82/** 等待发货 */83 WAITDELIVER {public String getName(){return "等待发货";}},84/** 已发货 */85 DELIVERED {public String getName(){return "已发货";}},86/** 已收货 */87 RECEIVED {public String getName(){return "已收货";}};8889public abstract String getName();90 }9192public static void main(String[] args) {93//枚举是⼀种类型，⽤于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值 94 ColorEnum colorEnum = ColorEnum.blue;95switch (colorEnum) {96case red:97 System.out.println("color is red");98break;99case green:100 System.out.println("color is green");101break;102case yellow:103 System.out.println("color is yellow");104break;105case blue:106 System.out.println("color is blue");107break;108 }109110//遍历枚举111 System.out.println("遍历ColorEnum枚举中的值");112for(ColorEnum color : ColorEnum.values()){113 System.out.println(color);114 }115116//获取枚举的个数117 System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");118119//获取枚举的索引位置，默认从0开始120 System.out.println(ColorEnum.red.ordinal());//0121 System.out.println(ColorEnum.green.ordinal());//1122 System.out.println(ColorEnum.yellow.ordinal());//2123 System.out.println(ColorEnum.blue.ordinal());//3124125//枚举默认实现了parable接⼝126 System.out.println(pareTo(ColorEnum.green));//-1127128//--------------------------129 System.out.println("===========");130 System.err.println("季节为" + SeasonEnum.getSeason());131132133//--------------134 System.out.println("===========");135for(Gender gender : Gender.values()){136 System.out.println(gender.value);137 }138139//--------------140 System.out.println("===========");141for(OrderState order : OrderState.values()){142 System.out.println(order.getName());143 }144 }145146 }四：枚举集合的使⽤java.util.EnumSet和java.util.EnumMap是两个枚举集合。
java中枚举类型enum用法
java中枚举类型enum用法
Java中枚举类型enum是一种特殊的类，它用于定义一组相关的常量。
枚举类型的本质就是一组常量，它们对应着特定的值，根据不同的值来调用它们，使设计的结构更加清晰和完善，也可以提高程序的可读性和可维护性。
枚举类型enum有以下特点：
* 所有的枚举类型必须声明为public static final，因为每个枚举都是一个常量。
* 枚举类型可以包含抽象方法，但不能有构造函数，因为它们是公共常量，无需创建实例。
* Java中枚举类型enum可以有实例变量，但必须在枚举声明之前声明，否则会报错。
* 枚举类型有四种初始化方式：枚举值，值加参数，值加属性和值加构造函数。
* 枚举类型可以实现接口，但它不能继承其他类，并且它也不能继承枚举类型，因为枚举类型拥有特殊的可修改性能。
* 枚举类型可以用来构建枚举集合，这些枚举集合可以方便地将特定值和枚举构建关系。
* 枚举类型可以在switch语句或循环语句中使用，这样可以根据枚举的不同值来进行分别处理，从而提升代码的可读性。
枚举类型enum的作用在很多地方都能看到，比如日期的存储，每个月都有一个相应的枚举值；或者使用枚举作为某种特定状态的边界，比如枚举可以表示“成功”，“失败”或“待定”的情况，这样可以方便地区分出返回的不同值，当我们需要给某次操作赋予一定的含义时，它也可以起到大有裨益的作用。
总之，enum是Java中一种重要的特性，它能帮助我们更好地组织程序结构，让代码更容易阅读和维护，这也是它受到开发者们欢迎的原因之一。
讲述java中enum的用法
讲述java中enum的用法本文实例讲述了java中enum的用法。
分享给大家供大家参考。
具体分析如下：1.基本用法复制代码代码如下:enumDay{SUNDAY,MONDAY,TUESDAY,WENDSDAY,THURSDAY,FRIDAY, SATURDAY;}枚举是常量，所以应该用大写。
2.枚举是对象枚举隐含地继承了ng.Enum，所以它具有ng.Enum 的属*和方法。
遍历枚举：复制代码代码如下:publicclassMain{publicstaticvoidmain(String[]args){for(Dayday:Day.values()){System.out.println(day);}}}3.枚举可以带字段和方法，以下示例来自官方TheJavaTutorials复制代码代码如下:publicenumEnumDemo{AOBJECT("fieldone","fieldtwo");privateStringfield1;privateStringfield2;EnumDemo(Stringval1,Stringval2){this.field1=val1;this.field2=val2;}publicvoidprintFields(){System.out.println(this.field1);System.out.println(this.field2);}publicstaticvoidmain(String[]args){ EnumDemo.AOBJECT.printFields();}}以下现实中的示例来自官方的JavaTutorial:复制代码代码如下:publicenumPla{ 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); privatefinaldoublemass;//inkilograms privatefinaldoubleradius;//inmetersPla(doublemass,doubleradius){this.mass=mass;this.radius=radius;}privatedoublemass(){returnmass;} privatedoubleradius(){returnradius;}//universalgravitationalconstant(m3kg-1s-2) publicstaticfinaldoubleG=6.67300E-11; doublesurfaceGravity(){returnG*mass/(radius*radius);}doublesurfaceWeight(doubleotherMass){returnotherMass*surfaceGravity();}publicstaticvoidmain(String[]args){DoubleearthWeight=120;for(Plap:Pla.values()){System.out.println(p.surfaceGravity());System.out.println(p.surfaceWeight(earthWeight/EARTH.sur faceGravity()));}}}4.枚举是singleton，可以用枚举来构建一个Singleton复制代码代码如下:publicenumSingleton{INSTANCE(newString[]{"arg1","arg2"});String[]myArgs;Singleton(String[]args){this.myArgs=args;}publicstaticSingletongetInstance(){returnINSTANCE;}publicstaticvoidmain(String[]args){for(Stringarg:INSTANCE.myArgs)System.out.println(arg);}}。
enum java用法 -回复
enum java用法-回复枚举（Enum）是Java中的一种特殊数据类型，用于定义一组取值有限且固定的常量。
枚举类型可以提高代码的可读性和可维护性，使程序代码更加清晰明了。
本文将详细介绍Java中枚举类型的用法。
一、定义枚举类型在Java中，我们可以使用关键字enum来定义一个枚举类型。
枚举类型可以包含一个或多个枚举常量，每个常量都是该枚举类型的一个实例对象。
例如，我们可以定义一个表示星期的枚举类型：enum Week {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;}上述代码定义了一个名为Week的枚举类型，包含了七个枚举常量，分别表示星期一到星期日。
二、使用枚举类型在使用枚举类型时，我们可以像使用其他数据类型一样对枚举常量进行操作。
1. 访问枚举常量我们可以通过枚举类型名和枚举常量名来访问枚举常量。
例如，要访问Week枚举类型的TUESDAY常量，可以使用Week.TUESDAY来获取该常量的引用。
2. 遍历枚举常量枚举类型中定义了一个values()方法，该方法可以返回枚举类型中的所有枚举常量作为一个数组。
我们可以使用增强for循环来遍历枚举常量数组，便于对枚举常量进行处理。
Week[] weekdays = Week.values();for (Week weekday : weekdays) {System.out.println(weekday);}上述代码可以输出Week枚举类型中的所有枚举常量，即星期一到星期日。
3. 比较枚举常量枚举常量是唯一的，可以使用==运算符进行比较。
例如，要比较两个Week 枚举常量是否相等，可以使用Week.MONDAY == Week.TUESDAY进行比较。
4. 使用switch语句在Java中，我们可以将枚举类型用于switch语句中，以便根据不同的枚举常量执行相应的操作。
java枚举类型enum用法和写法
java枚举类型enum用法和写法Java枚举类型enum是一种特殊的类，用于定义一些固定的值。
它可以作为参数或返回值类型，以确保变量只能是该枚举类型中的一个值。
以下是Java枚举类型enum的使用方法和写法：1. 声明一个枚举类型枚举类型的语法格式如下：enum EnumName {VALUE1,VALUE2,…}其中，`EnumName`是枚举类型的名称，`VALUE1`、`VALUE2`等是该枚举类型中定义的枚举常量。
2. 使用枚举类型在Java中使用枚举类型非常简单。
可以像任何其他类型一样声明枚举类型的变量，并将其初始化为枚举常量。
例如：enum Color {RED, GREEN, BLUE}Color c = Color.RED;3. 枚举类型的方法可以在枚举类型中定义方法，以便可以在枚举常量之间执行自定义操作。
方法的定义与其他Java类的方法定义相同。
例如：enum Size {SMALL, MEDIUM, LARGE;public boolean isLargerThan(Size otherSize) {return this.ordinal() > otherSize.ordinal();}}Size s1 = Size.SMALL;Size s2 = RGE;boolean result = s2.isLargerThan(s1); true4. 枚举类型的常用方法Java中的枚举类型有一些常用方法，如下所示：- `values()`方法：返回该枚举类型中的所有枚举常量的数组。
- `valueOf(String name)`方法：返回指定名称的枚举常量。
例如：enum Level {LOW, MEDIUM, HIGH}Level[] allLevels = Level.values();Level highLevel = Level.valueOf("HIGH");以上就是Java枚举类型enum的使用方法和写法。
Java枚举Enum用法详解
Java枚举Enum⽤法详解前两篇博⽂对枚举处理器进⾏了详细的介绍，这⾥对枚举Enum的⽤法进⾏⼀个⼤致总结，以便于更好的理解代码逻辑。
还是以Enabled枚举类为例⼦进⾏汇总：package com.example.simple.type;public enum Enabled {enabled(1), //启⽤disabled(0); //禁⽤private final int value;private Enabled(int value) {this.value = value;}public int getValue() {return value;}}⼀、⽅法⽅法详解Enabled.values()以数组形式返回枚举类型的所有成员System.out.println(Enabled.values());测试了⼀下上⾯代码实现⽅式不可⾏，并不能实现枚举类型成员实现，⽽要通过循环⽅式实现，如下：for(Enabled enabled:Enabled.values()){System.out.println(enabled);}或者：for(int i = 0;i<Enabled.values().length ; i++){System.out.println(Enabled.values()[i]);}测试结果为：enableddisabledEnabled.valueOf（String string）根据普通字符串抓取到对应的枚举实例，普通字符串类型变为枚举类型System.out.println(Enabled.valueOf("enabled"));输出：enabled若变为：System.out.println(Enabled.valueOf("aaa"));会出现异常：ng.IllegalArgumentException: No enum constant com.example.simple.type.Enabled.aaacompareTo（Enabled enabled）⽐较两个枚举成员在定义时的顺序，通俗来说就是前后顺序compare(Enabled.valueOf("enabled"));public static void compare(Enabled enabled){for(int i = 0;i<Enabled.values().length ; i++){System.out.println(enabled+"和"+ Enabled.values()[i]+ "的⽐较结果是" + pareTo(Enabled.values()[i])); }}测试结果为：enabled和enabled的⽐较结果是0enabled和disabled的⽐较结果是-1如果枚举类中将enabled和disabled前后顺序倒过来，那么结果是：enabled和disabled的⽐较结果是1enabled和enabled的⽐较结果是0Enabled.disabled 获取到对应的枚举值disabled，其类型是Enabled，从枚举类中直接获取到此枚举，没进⾏任何加⼯，来⼀⼩⾏代码测试⼀下：System.out.println(Enabled.disabled);Enabled disabled = Enabled.disabled;System.out.println(disabled);输出结果为：disableddisabledEnabled.enabled 获取到对应的枚举值enabled，其类型是Enabled，从枚举类中直接获取到此枚举，没进⾏任何加⼯。
Java枚举类型enum使用详解
Java枚举类型enum使⽤详解java的Enum枚举类型终于在j2se1.5出现了。
之前觉得它只不过是鸡肋⽽已，可有可⽆。
毕竟这么多年来，没有它，⼤家不都过得很好吗？今⽇看《Thinking in Java》4th edition，⾥⾯有⼀句话“有时恰恰因为它，你才能够"优雅⽽⼲净"地解决问题。
优雅与清晰很重要，正式它们区别了成功的解决⽅案与失败的解决⽅案。
⽽失败的解决⽅案就是因为其他⼈⽆法理他。
"使⽤Enum枚举类型，可以将以前笨拙的代码变得优雅简单？但是，我同时也在思考另外⼀个问题，使⽤新的技术，会不会给技术⼈员带来更多的负担呢？"学习新版语⾔的⼀个危险就是疯狂使⽤新的语法结构"先学习⼀下enum的简单应⽤，以下简洁的代码已经包括enum所提供的绝⼤部分功能。
1.enum的应⽤，包括定义，遍历，switch，enumset，enummap等Java代码[c-sharp]1. import java.util.EnumMap;2. import java.util.EnumSet;3. public class EnumTest {4. // 定义⼀个enum枚举类型，包括两个实例ON，OFF5. public enum State {6. ON, OFF7. };8. // 测试函数9. public static void main(String[] args) {10. // 直接变量enum11. for (State s : State.values())12. System.out.println(());13. // switch与enum的结合使⽤14. State switchState = State.OFF;15. switch (switchState) {16. case OFF:17. System.out.println("OFF");18. break;19. case ON:20. System.out.println("ON");21. break;22. }23. // EnumSet的使⽤24. EnumSet<State> stateSet = EnumSet.allOf(State.class);25. for (State s : stateSet) {26. System.out.println(s);27. }28. // EnumMap的使⽤29. EnumMap<State,String> stateMap = new EnumMap<State,String>(State.class);30. stateMap.put(State.ON, "is On");31. stateMap.put(State.OFF, "is off");32. for (State s : State.values()) {33. System.out.println(() + ":" + stateMap.get(s));34. }35. }36. }[c-sharp]1. package com.aicent.test;2. public enum TestEnumMathod {3. // 为每个enum实例添加不同的实现⽅法4. SAMPLE1 {5. String getInfo() {6. return "SAMPLE1";7. }8. },9. SAMPLE2 {10. String getInfo() {11. return "SAMPLE2";12. }13. };14. abstract String getInfo();15. // 测试16. public static void main(String args[]) {17. for (TestEnumMathod method : values()) {18. System.out.println(method.getInfo());19. }20. }21. }以下内容可能有些⽆聊，但绝对值得⼀窥1.代码：public class State {public static final int ON = 1;public static final Int OFF= 0;}有什么不好了，⼤家都这样⽤了很长时间了，没什么问题啊。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
enum枚举java【java,enum(枚举)使用详解+,总
结】
enum的全称为enumeration，是JDK1.5中引入的新特性，存放在ng包中。
原始的接口定义常量
语法（定义）
创建枚举类型要使用enum关键字，隐含了所创建的类型都是ng.Enum类的子类（ng.Enum是一个抽象类）。
枚举类型符合通用模式ClassEnum
这段代码实际上调用了7次Enum(Stringname,intordinal)：
遍历、switch等常用操作
对enum进行遍历和switch的操作示例代码：
输出结果：
enum对象的常用方法介绍
intcompareTo(Eo)
比较此枚举与指定对象的顺序。
ClassgetDeclaringClass()
返回与此枚举常量的枚举类型相对应的Class对象。
Stringname()
返回此枚举常量的名称，在其枚举声明中对其进行声明。
intordinal()
返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
StringtoString()
返回枚举常量的名称，它包含在声明中。
static
输出结果：
给enum自定义属性和方法
给enum对象加一下value的属性和getValue()的方法：
输出结果：
EnumSet，EnumMap的应用
原理分析
enum的语法结构尽管和class的语法不一样，但是经过编译器编译之后产生的是一个class文件。
该class文件经过反编译可以看到实际上是生成了一个类，该类继承了ng.Enum。
EnumTest经过反编译(javapcom.hmw.test.EnumTest命令)之后得到的内容如下：48f0d266f44.png"data-size="undefined"/>
所以，实际上enum就是一个class，只不过java编译器帮我们做了语法的解析和编译而已。
总结。