「java枚举类实例」java中的枚举类型的使用

今天给各位分享java枚举类实例的知识，其中也会对java中的枚举类型的使用进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java，求高手讲解一下一个枚举的例子
• 2、java枚举
• 3、java 获取枚举类型的实例
• 4、用java写一个枚举类程序
• 5、JAVA枚举可以用来做什么？举一个简单的例子（用枚举、不用）
• 6、介绍一下java枚举，顺便举个例子，谢谢

java，求高手讲解一下一个枚举的例子

结果：Mr. John Doe

转的。枚举是一个特殊的类。

枚举类型是JDK5.0的新特征 。Sun引进了一个全新的关键字enum来定义一个枚举类 。下面就是一个典型枚举类型的定义：

Java代码：

public enum Color{

RED，BLUE，BLACK，YELLOW，GREEN

}

显然，enum很像特殊的class，实际上enum声明定义的类型就是一个类 。 而这些类都是类库中Enum类的子类（java.lang.Enum） 。它们继承了这个Enum中的许多有用的方法 。我们对代码编译之后发现，编译器将enum类型单独编译成了一个字节码文件：Color.class 。

Color字节码代码

final enum hr.test.Color {

// 所有的枚举值都是类静态常量

public static final enum hr.test.Color RED;

public static final enum hr.test.Color BLUE;

public static final enum hr.test.Color BLACK;

public static final enum hr.test.Color YELLOW;

public static final enum hr.test.Color GREEN;

private static final synthetic hr.test.Color〔〕 ENUM$VALUES;

// 初始化过程，对枚举类的所有枚举值对象进行第一次初始化

static {

0 new hr.test.Color 〔1〕

3 dup

4 ldc 〔16〕 //把枚举值字符串“RED”压入操作数栈

6 iconst_0 // 把整型值0压入操作数栈

7 invokespecial hr.test.Color（java.lang.String， int） 〔17〕 //调用Color类的私有构造器创建Color对象RED

10 putstatic hr.test.Color.RED ： hr.test.Color 〔21〕 //将枚举对象赋给Color的静态常量RED 。

。.. 。.. 。.. 枚举对象BLUE等与上同

102 return

};

// 私有构造器，外部不可能动态创建一个枚举类对象（也就是不可能动态创建一个枚举值） 。

private Color（java.lang.String arg0， int arg1）{

// 调用父类Enum的受保护构造器创建一个枚举对象

3 invokespecial java.lang.Enum（java.lang.String， int） 〔38〕

};

public static hr.test.Color〔〕 values（）;

// 实现Enum类的抽象方法

public static hr.test.Color valueOf（java.lang.String arg0）;

}

下面我们就详细介绍enum定义的枚举类的特征及其用法 。（后面均用Color举例）

1、Color枚举类就是class，而且是一个不可以被继承的final类 。

其枚举值（RED，BLUE. 。.）都是Color类型的类静态常量， 我们可以通过下面的方式来得到Color枚举类的一个实例：

Color c=Color.RED;

注意：这些枚举值都是public static final的，也就是我们经常所定义的常量方式，因此枚举类中的枚举值最好全部大写 。

2、即然枚举类是class，当然在枚举类型中有构造器，方法和数据域 。

但是，枚举类的构造器有很大的不同：

（1） 构造器只是在构造枚举值的时候被调用 。

Java代码：

enum Color{

RED（255，0，0），BLUE（0，0，255），BLACK（0，0，0），YELLOW（255，255，0），GREEN（0，255，0）;

//构造枚举值，比如RED（255，0，0）

private Color（int rv，int gv，int bv）{

this.redValue=rv;

this.greenValue=gv;

this.blueValue=bv;

}

public String toString（）{ //覆盖了父类Enum的toString（）

return super.toString（）+“（”+redValue+“，”+greenValue+“，”+blueValue+“）”;

}

private int redValue; //自定义数据域，private为了封装 。

private int greenValue;

private int blueValue;

}

（2） 构造器只能私有private，绝对不允许有public构造器 。 这样可以保证外部代码无法新构造枚举类的实例 。这也是完全符合情理的，因为我们知道枚举值是public static final的常量而已 。 但枚举类的方法和数据域可以允许外部访问 。

Java代码：

public static void main（String args〔〕）

{

// Color colors=new Color（100，200，300）; //wrong

Color color=Color.RED;

System.out.println（color）; // 调用了toString（）方法

}

3、所有枚举类都继承了Enum的方法，下面我们详细介绍这些方法 。

（1） ordinal（）方法： 返回枚举值在枚举类种的顺序 。这个顺序根据枚举值声明的顺序而定 。

Color.RED.ordinal（）; //返回结果：0

Color.BLUE.ordinal（）; //返回结果：1

（2） compareTo（）方法： Enum实现了java.lang.Comparable接口，因此可以比较象与指定对象的顺序 。Enum中的compareTo返回的是两个枚举值的顺序之差 。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException（）异常 。（具体可见源代码）

Color.RED.compareTo（Color.BLUE）; //返回结果 -1

（3） values（）方法： 静态方法，返回一个包含全部枚举值的数组 。

Color〔〕 colors=Color.values（）;

for（Color c:colors）{

System.out.print（c+“，”）;

}//返回结果：RED，BLUE，BLACK YELLOW，GREEN，

（4） toString（）方法： 返回枚举常量的名称 。

Color c=Color.RED;

System.out.println（c）;//返回结果： RED

（5） valueOf（）方法： 这个方法和toString方法是相对应的，返回带指定名称的指定枚举类型的枚举常量 。

Color.valueOf（“BLUE”）; //返回结果： Color.BLUE

（6） equals（）方法： 比较两个枚举类对象的引用 。

Java代码：

//JDK源代码：

public final boolean equals（Object other） {

return this==other;

}

4、枚举类可以在switch语句中使用 。

Java代码：

Color color=Color.RED;

switch（color）{

case RED： System.out.println（“it‘s red”）;break;

case BLUE： System.out.println（“it’s blue”）;break;

case BLACK： System.out.println（“it‘s blue”）;break;

}

java枚举

枚举 一般就是能数得清的东西。像交通指示灯就只有三个颜色：黄、绿、红

这样有限的东西，如果我们写个类就显得很多余了，所以就有了枚举。在你写的枚举中 red、blue、black都是color中的一种。用枚举color来显示color有哪些。将其写在枚举color中。

调用red的时候就需要枚举名.变量（其实这里说red是变量是不合适的，只是为了方便理解。）变量和它的值是一样的。 所以输出的就是red了。

java 获取枚举类型的实例

public class MJTest {

public enum MJ {

MJ1(1), MJ(2),MJ(3);

}

public static void main(String[] args) {

MJ[] elements = MJ.values();

for (Light i : elements) {

System.out.println(" 当前值 ： " + i.name());

}

}

}

用java写一个枚举类程序

package com.school.stereotype; 

/** 

 * 活动枚举类型 

 * @author QiXuan.Chen 

 */

public enum EventStatus { 

  /** 

   * 未发布。 

   */ 

  DRAFT("DRAFT", "未发布"), 

  /** 

   * 已发布。 

   */

  PUBLISHED("PUBLISHED", "已发布"); 

  /** 

   * 活动状态的值。 

   */

  private String value; 

  /** 

   * 活动状态的中文描述。 

   */

  private String text; 

  /** 

   * @param status 活动状态的值 

   * @param desc 活动状态的中文描述 

   */

  private EventStatus(String status, String desc) { 

    value = status; 

    text = desc; 

  } 

  /** 

   * @return 当前枚举对象的值。 

   */

  public String getValue() { 

    return value; 

  } 

  /** 

   * @return 当前状态的中文描述。 

   */

  public String getText() { 

    return text; 

  } 

  /** 

   * 根据活动状态的值获取枚举对象。 

   * 

   * @param status 活动状态的值 

   * @return 枚举对象 

   */

  public static EventStatus getInstance(String status) { 

    EventStatus[] allStatus = EventStatus.values(); 

    for (EventStatus ws : allStatus) { 

      if (ws.getValue().equalsIgnoreCase(status)) { 

        return ws; 

      } 

    } 

    throw new IllegalArgumentException("status值非法，没有符合课程状态的枚举对象"); 

  } 

}

JAVA枚举可以用来做什么？举一个简单的例子（用枚举、不用）

Enum作为Sun全新引进的一个关键字，看起来很象是特殊的class, 它也可以有自己的变量，可以定义自己的方法，可以实现一个或者多个接口。当我们在声明一个enum类型时，我们应该注意到enum类型有如下的一些特征。

1．它不能有public的构造函数，这样做可以保证客户代码没有办法新建一个enum的实例。

2．所有枚举值都是public , static , final的。注意这一点只是针对于枚举值，我们可以和在普通类里面定义变量一样定义其它任何类型的非枚举变量，这些变量可以用任何你想用的修饰符。

3．Enum默认实现了java.lang.Comparable接口。

4．Enum覆载了了toString方法，因此我们如果调用Color.Blue.toString()默认返回字符串”Blue”.

5．Enum提供了一个valueOf方法，这个方法和toString方法是相对应的。调用valueOf(“Blue”)将返回Color.Blue.因此我们在自己重写toString方法的时候就要注意到这一点，一把来说应该相对应地重写valueOf方法。

6．Enum还提供了values方法，这个方法使你能够方便的遍历所有的枚举值。

7．Enum还有一个oridinal的方法，这个方法返回枚举值在枚举类种的顺序，这个顺序根据枚举值声明的顺序而定，这里Color.Red.ordinal()返回0。

1．遍历所有有枚举值. 知道了有values方法，我们可以轻车熟路地用ForEach循环来遍历了枚举值了。

for (Color c: Color.values())

System.out.println(“find value:” + c);

2．在enum中定义方法和变量，比如我们可以为Color增加一个方法随机返回一个颜色。

public enum Color {

Red,

Green,

Blue;

private static int number = Color.values().length ;

public static Color getRandomColor(){

long random = System.currentTimeMillis() % number;

switch ((int) random){

case 0:

return Color.Red;

case 1:

return Color.Green;

case 2:

return Color.Blue;

default : return Color.Red;

}

}

}

可以看出这在枚举类型里定义变量和方法和在普通类里面定义方法和变量没有什么区别。唯一要注意的只是变量和方法定义必须放在所有枚举值定义的后面，否则编译器会给出一个错误。

3．覆载(Override)toString, valueOf方法。

前面我们已经知道enum提供了toString,valueOf等方法，很多时候我们都需要覆载默认的toString方法，那么对于enum我们怎么做呢。其实这和覆载一个普通class的toString方法没有什么区别。

….

public String toString(){

switch (this){

case Red:

return "Color.Red";

case Green:

return "Color.Green";

case Blue:

return "Color.Blue";

default:

return "Unknow Color";

}

}

….

这时我们可以看到，此时再用前面的遍历代码打印出来的是

Color.Red

Color.Green

Color.Blue

而不是

Red

Green

Blue.

可以看到toString确实是被覆载了。一般来说在覆载toString的时候我们同时也应该覆载valueOf方法，以保持它们相互的一致性。

4．使用构造函数。

虽然enum不可以有public的构造函数，但是我们还是可以定义private的构造函数，在enum内部使用。还是用Color这个例子。

public enum Color {

Red("This is Red"),

Green("This is Green"),

Blue("This is Blue");

private String desc;

Color(String desc){

this.desc = desc;

}

public String getDesc(){

return this.desc;

}

}

这里我们为每一个颜色提供了一个说明信息

public enum Color {

Red {

public String toString(){

return "Color.Red";

}

},

Green {

public String toString(){

return "Color.Green";

}

},

Blue{

public String toString(){

return "Color.Blue";

}

};

}

, 然后定义了一个构造函数接受这个说明信息。

要注意这里构造函数不能为public或者protected, 从而保证构造函数只能在内部使用，客户代码不能new一个枚举值的实例出来。这也是完全符合情理的，因为我们知道枚举值是public static final的常量而已。

5．实现特定的接口

我们已经知道enum可以定义变量和方法，它要实现一个接口也和普通class实现一个接口一样，这里就不作示例了。

6．定义枚举值自己的方法。

前面我们看到可以为enum定义一些方法，其实我们甚至可以为每一个枚举值定义方法。这样，我们前面覆载 toString的例子可以被改写成这样。

从逻辑上来说这样比原先提供一个“全局“的toString方法要清晰一些。

总的来说，enum作为一个全新定义的类型，是希望能够帮助程序员写出的代码更加简单易懂，个人觉得一般也不需要过多的使用enum的一些高级特性，否则就和简单易懂的初衷想违背了。

介绍一下java枚举，顺便举个例子，谢谢

package com.ljq.test;

/**

* 枚举用法详解

*

* @author jiqinlin

*

*/

public class TestEnum {

/**

* 普通枚举

*

* @author jiqinlin

*

*/

public enum ColorEnum {

red, green, yellow, blue;

}

/**

* 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法

*

* @author jiqinlin

*

*/

public enum SeasonEnum {

//注：枚举写在最前面，否则编译出错

spring, summer, autumn, winter;

private final static String position = "test";

public static SeasonEnum getSeason() {

if ("test".equals(position))

return spring;

else

return winter;

}

}

/**

* 性别

*

* 实现带有构造器的枚举

*

* @author jiqinlin

*

*/

public enum Gender{

//通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错

//赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错

MAN("MAN"), WOMEN("WOMEN");

private final String value;

//构造器默认也只能是private, 从而保证构造函数只能在内部使用

Gender(String value) {

this.value = value;

}

public String getValue() {

return value;

}

}

/**

* 订单状态

*

* 实现带有抽象方法的枚举

*

* @author jiqinlin

*

*/

public enum OrderState {

/** 已取消 */

CANCEL {public String getName(){return "已取消";}},

/** 待审核 */

WAITCONFIRM {public String getName(){return "待审核";}},

/** 等待付款 */

WAITPAYMENT {public String getName(){return "等待付款";}},

/** 正在配货 */

ADMEASUREPRODUCT {public String getName(){return "正在配货";}},

/** 等待发货 */

WAITDELIVER {public String getName(){return "等待发货";}},

/** 已发货 */

DELIVERED {public String getName(){return "已发货";}},

/** 已收货 */

RECEIVED {public String getName(){return "已收货";}};

public abstract String getName();

}

public static void main(String[] args) {

//枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值

ColorEnum colorEnum = ColorEnum.blue;

switch (colorEnum) {

case red:

System.out.println("color is red");

break;

case green:

System.out.println("color is green");

break;

case yellow:

System.out.println("color is yellow");

break;

case blue:

System.out.println("color is blue");

break;

}

//遍历枚举

System.out.println("遍历ColorEnum枚举中的值");

for(ColorEnum color : ColorEnum.values()){

System.out.println(color);

}

//获取枚举的个数

System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");

//获取枚举的索引位置，默认从0开始

System.out.println(ColorEnum.red.ordinal());//0

System.out.println(ColorEnum.green.ordinal());//1

System.out.println(ColorEnum.yellow.ordinal());//2

System.out.println(ColorEnum.blue.ordinal());//3

//枚举默认实现了java.lang.Comparable接口

System.out.println(ColorEnum.red.compareTo(ColorEnum.green));//-1

//--------------------------

System.out.println("===========");

System.err.println("季节为" + SeasonEnum.getSeason());

//--------------

System.out.println("===========");

for(Gender gender : Gender.values()){

System.out.println(gender.value);

}

//--------------

System.out.println("===========");

for(OrderState order : OrderState.values()){

System.out.println(order.getName());

}

}

}

java枚举类实例的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java中的枚举类型的使用、java枚举类实例的信息别忘了在本站进行查找喔。