包含java枚舉通俗實例解析的詞條

本文目錄一覽：

• 1、java，求高手講解一下一個枚舉的例子
• 2、介紹一下java枚舉，順便舉個例子，謝謝
• 3、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枚舉，順便舉個例子，謝謝

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枚舉類型有什麼好處?請舉個簡單明了的例子

Enum是enumeration(列舉)的簡寫形式,包含在java.lang包中.熟悉C, C++, C#, 或 Pascal人應該對列舉有所了解,先看個例子:

public enum Season

一個enum是定義一組值的對象,它可以包括零個或多個值成員.它是屬於enum類型的,一個enum對象中不可有兩個或多個相同的屬性或值.在次之前的java程序員一般是 用接口的方法實現列舉的,如 :

public interface Season {

static winter = 0;

static spring = 1; //etc..

}

引入了enum的java的列舉的編寫方便了許多,只須定義一個enum型的對象.enum對象的值都回自動獲得一個數字值,從0開始,依次遞增.看一個比較簡單的enum實現的例子:

EnumDemo.java

package net.javagarage.enums;

/*

We can loop over the values we put into the enum

using the values() method.

Note that the enum Seasons is compiled into a

separate unit, called EnumDemo$Seasons.class

*/

public class EnumDemo {

/*declare the enum and add values to it. note that, like in C#, we don’t use a ; to

end this statement and we use commas to separate the values */

private enum Seasons { winter, spring,

summer, fall }

//list the values

public static void main(String[] args) {

for (Seasons s : Seasons.values()){

System.out.println(s);

}

}

}

運行上述代碼你回得到 以下結果:

winter

spring

summer

fall