java中的枚舉類

阿新 • • 發佈：2018-02-01

args add ping 觀察 ros ann 不能 false ide

初識枚舉類，我們也許會提出疑問，枚舉它是一種新的類型嗎？不同於基本數據類型，引用

類型？？為了更好地理解，我們從反編譯一個enum類開始：

原java代碼

import java.util.Arrays;  
import java.util.List;  
  
public enum Weather {  
  
    Sunny(1, "晴天"), Rainy(2, "雨天"), Cloudy(3, "多雲");  
    private int value;  
    private String label;  
  
    private Weather(int value, String label) {  
        this.value = value;  
        this.label = label;  
    }  
  
    public int getValue() {  
        return value;  
    }  
  
    public String getLabel() {  
        return label;  
    }  
  
    public static Weather parse(int value) {  
        Weather result = Weather.Sunny;  
        switch (value) {  
        case 1:  
            result = Weather.Sunny;  
            break;  
        case 2:  
            result = Weather.Rainy;  
            break;  
        case 3:  
            result = Weather.Cloudy;  
            break;  
        }  
        return result;  
    }  
  
    public static List<Weather> getEnumValues() {  
        return Arrays.asList(values());  
    }  
  
    public static void main(String[] args) {  
        System.out.println(Weather.Sunny.getValue() + ":" + Weather.Sunny.getLabel());  
        Weather weather = Weather.Cloudy;  
        System.out.println(weather.getValue() + ":" + weather.getLabel());  
        List<Weather> list = getEnumValues();  
        for (Weather sw : list) {  
            System.out.println(sw.value + "--" + sw.label);  
        }  
    }  
}

反編譯之後：

import java.io.PrintStream; 
import java.util.*;  
  
public final class Weather extends Enum{  
      
    private Weather(String s, int i, int value, String label){  
        super(s, i);  
        this.value = value;  
        this.label = label;  
    }  
      
    public int getValue(){  
        return value;  
    }  
      
    public String getLabel(){  
        return label;  
    }  
      
    public static Weather parse(int value){  
        Weather result = Sunny;  
        switch(value){  
            case 1: /*// '\001'*/  
                result = Sunny;  
                break;  
            case 2: /*// '\002'*/  
                result = Rainy;  
                break;  
            case 3: /*// '\003'*/  
                result = Cloudy;  
                break;  
        }  
        return result;  
    }  
      
    public static List getEnumValues(){  
        return Arrays.asList(values());  
    }  
      
    public static void main(String args[]){  
        System.out.println((new StringBuilder(String.valueOf(Sunny.getValue()))).append(":").append(Sunny.getLabel()).toString());  
        Weather weather = Cloudy;  
        System.out.println((new StringBuilder(String.valueOf(weather.getValue()))).append(":").append(weather.getLabel()).toString());  
        List list = getEnumValues();  
        Weather sw;  
        for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println((new StringBuilder(String.valueOf(sw.value))).append("--").append(sw.label).toString()))  
            sw = (Weather)iterator.next();  
    }  
      
    public static Weather[] values(){ 
        Weather aweather[]; 
        int i; 
        Weather aweather1[]; 
        System.arraycopy(aweather = ENUM$VALUES, 0, aweather1 = new Weather[i = aweather.length], 0, i); 
        return aweather1; 
    }  
      
    public static Weather valueOf(String s){ 
        return (Weather)Enum.valueOf(Weather, s); 
    }  
      
    public static final Weather Sunny;  
    public static final Weather Rainy;  
    public static final Weather Cloudy;  
    private int value;  
    private String label;  
    private static final Weather ENUM$VALUES[];  
    static {  
        Sunny = new Weather(/*"Sunny", 0,*/ 1, "\u6674\u5929");  
        Rainy = new Weather(/*"Rainy", 1,*/ 2, "\u96E8\u5929");  
        Cloudy = new Weather(/*"Cloudy", 2,*/ 3, "\u591A\u4E91");  
        ENUM$VALUES = (new Weather[] { 
            Sunny, Rainy, Cloudy 
        });  
    }  
}

通過觀察代碼我們會發現enum關鍵字的含義其實就是使類被final修飾並繼承抽象類Enum，它是java枚舉類型的公共基本類，裏面提供了一些

公共方法，同時對象Sunny、Rainy、Cloudy都是使用static final修飾的不可變引用，他們在靜態塊中被用new的方式實例化並初始化。因此

得出結論：實際上枚舉類型就是以Java類來實現的，沒有什麽新的特點，只不過java編譯器幫我們做了語法的解析和編譯。同時反編譯之後，

代碼中還自動生成了兩個方法values()和valueOf(String name),這兩個方法存在於

java.lang.annotation.ElementType

類下面：

valueOf(String name)返回指定枚舉常量

values()返回枚舉類型的數據，用於遍歷枚舉

public enum Test {

	RED,YELLOW,GREEN,BLACK;
	public static void main(String[] args) {
		Test t[] = Test.values();
		for (int i = 0; i < t.length; i++) {
			System.out.println(t[i] + ":" + t[i].ordinal());
		}
	}
}

結果：

RED:0
YELLOW:1
GREEN:2
BLACK:3

通過反編譯也可以看出，枚舉類其實就是簡單的java類構成的，不過它已經繼承了Enum類，由於單繼承特性，他不能再繼承

其它類了，但可以實現接口。

以下是一個含有抽象方法的枚舉類：

import java.util.Arrays;  
import java.util.List;  
  
public enum Weather {  
      
    Sunny(1, "晴天") {  
        @Override  
        public String test() {  
            return "今天陽光明媚！！！\n";  
        }  
    },  
    Rainy(2, "雨天") {  
        @Override  
        public String test() {  
            return "出門別忘帶把雨傘哦！！！\n";  
        }  
    },  
    Cloudy(3, "多雲") {  
        @Override  
        public String test() {  
            return "別出去登高望遠了，你看不遠的，呵呵呵！！！\n";  
        }  
    };  
  
    private int value;  
    private String label;  
  
    private Weather(int value, String label) {  
        this.value = value;  
        this.label = label;  
    }  
  
    public int getValue() {  
        return value;  
    }  
  
    public String getLabel() {  
        return label;  
    }  
  
    public abstract String test();  
  
    public static Weather parse(int value) {  
        Weather result = Weather.Sunny;  
        switch (value) {  
        case 1:  
            result = Weather.Sunny;  
            break;  
        case 2:  
            result = Weather.Rainy;  
            break;  
        case 3:  
            result = Weather.Cloudy;  
            break;  
        }  
        return result;  
    }  
  
    public static List<Weather> getEnumValues() {  
        return Arrays.asList(values());  
    }  
  
    public static void main(String[] args) {  
        System.out.println(Weather.Sunny.getValue() + ":" + Weather.Sunny.getLabel());  
        Weather weather = Weather.Cloudy;  
        System.out.println(weather.getValue() + ":" + weather.getLabel() + "\n\n");  
        List<Weather> list = getEnumValues();  
        for (Weather sw : list) {  
            System.out.println(sw.value + "--" + sw.label + "--" + sw.test());  
        }  
    }  
}

反編譯之後：

import java.io.PrintStream;  
import java.util.*;  
  
public abstract class Weather extends Enum {  
  
    private Weather(String s, int i, int value, String label) {  
        super(s, i);  
        this.value = value;  
        this.label = label;  
    }  
  
    public int getValue() {  
        return value;  
    }  
  
    public String getLabel() {  
        return label;  
    }  
  
    public abstract String test();  
  
    public static Weather parse(int value) {  
        Weather result = Sunny;  
        switch (value) {  
        case 1: // '\001'  
            result = Sunny;  
            break;  
        case 2: // '\002'  
            result = Rainy;  
            break;  
        case 3: // '\003'  
            result = Cloudy;  
            break;  
        }  
        return result;  
    }  
  
    public static List getEnumValues() {  
        return Arrays.asList(values());  
    }  
  
    public static void main(String args[]) {  
        System.out.println((new StringBuilder(String.valueOf(Sunny.getValue()))).append(":").append(Sunny.getLabel()).toString());  
        Weather weather = Cloudy;  
        System.out.println((new StringBuilder(String.valueOf(weather.getValue()))).append(":").append(weather.getLabel()).append("\n\n").toString());  
        List list = getEnumValues();  
        Weather sw;  
        for (Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println((new StringBuilder(String.valueOf(sw.value))).append("--").append(sw.label).append("--").append(sw.test()).toString()))  
            sw = (Weather) iterator.next();  
    }  
  
    public static Weather[] values() {  
        Weather aweather[];  
        int i;  
        Weather aweather1[];  
        System.arraycopy(aweather = ENUM$VALUES, 0, aweather1 = new Weather[i = aweather.length], 0, i);  
        return aweather1;  
    }  
  
    public static Weather valueOf(String s) {  
        return (Weather) Enum.valueOf(Weather, s);  
    }  
  
    Weather(String s, int i, int j, String s1, Weather weather) {  
        this(s, i, j, s1);  
    }  
  
    public static final Weather Sunny;  
    public static final Weather Rainy;  
    public static final Weather Cloudy;  
    private int value;  
    private String label;  
    private static final Weather ENUM$VALUES[];  
  
    static {  
        Sunny = new Weather("Sunny", 0, 1, "\u6674\u5929") {  
            public String test() {  
                return "\u4ECA\u5929\u9633\u5149\u660E\u5A9A\uFF01\uFF01\uFF01\n";  
            }  
        };  
        Rainy = new Weather("Rainy", 1, 2, "\u96E8\u5929") {  
            public String test() {  
                return "\u51FA\u95E8\u522B\u5FD8\u5E26\u628A\u96E8\u4F1E\u54E6\uFF01\uFF01\uFF01\n";  
            }  
        };  
        Cloudy = new Weather("Cloudy", 2, 3, "\u591A\u4E91") {  
            public String test() {  
                return "\u522B\u51FA\u53BB\u767B\u9AD8\u671B\u8FDC\u4E86\uFF0C\u4F60\u770B\u4E0D\u8FDC\u7684\uFF0C\u5475\u5475\u5475\uFF01\uFF01\uFF01\n";  
            }  
        };  
        ENUM$VALUES = (new Weather[] { Sunny, Rainy, Cloudy });  
    }  
}

由此可得出：

“不含抽象方法”的class反編譯文件：public final class Weather extends Enum

“含有抽象方法”的class反編譯文件：public abstract class Weather extends Enum

java中的枚舉類

Java中枚舉的寫法和用法

一個 lang 公司 nbsp -h Language integer com bsp 在公司代碼中，用了一大堆的枚舉，看得我好懵逼。下面開始看看枚舉怎麽寫和怎麽用。一、枚舉的寫法關於枚舉的寫法，網上好多這方面的知識。這裏直接貼一個我自己寫的

Java一個枚舉類的2種實現。

log specific 2種方法 throw new constant per str 實現方式一： public enum Operation { PLUS, MINUS, TIMES, DIVIDE; double apply(double x,

java之 ------ 枚舉類型

line tis 宋體 rda csdn 枚舉解決方法 trac 枚舉一、枚舉類型具體說明簡單的說。Enum一般用來表示一組同樣類型的常量。如性別、日期、月份、顏色等。對這些屬性用常量的優點是顯而易見的，不僅能夠

Java：枚舉類enum

tail http blank enum pos clas sdn java targe http://blog.csdn.net/qq_31655965/article/details/55049192 http://blog.csdn.net/qq_27093465/a

java基礎 java中枚舉的應用

blog 成員 enume 直接 style com post return print package com.swift.meiju; import org.junit.Test; public class Demo{ @Test public

Java中枚舉的相關應用

ack junit example nal enum dex index pub red package example6;import org.junit.Test;/*1.什麽是枚舉？ * 需要在頤堤港範圍內取值，這個值只能是這個範圍內的一個 * 使用枚舉關鍵字enum

Java之枚舉類

一個核心 bre 全部 image system 知識變量 highlight 有時候，變量的取值只在一個有限的集合內。例如：pizza的大小只有小、中、大和超大這四種尺寸。當然，可以將這些尺寸分別編碼為1、2、3、4或者S、M、L、X。但這樣存在著一定的隱患。在變量

java中枚舉的使用

one account print jdk1.5 成員 ring autumn created disable 在JDK1.5 之前，我們定義常量都是： public static fianl.... 。現在好了，有了枚舉，可以把相關的常量分組到一個枚舉類型裏，而且枚舉提供

java中的枚舉類

args add ping 觀察 ros ann 不能 false ide 初識枚舉類，我們也許會提出疑問，枚舉它是一種新的類型嗎？不同於基本數據類型，引用類型？？為了更好地理解，我們從反編譯一個enum類開始：原java代碼import java.util.Arr

java中String、包裝類、枚舉類的引用傳遞

ron http sta mage bsp 基本數據但是 bool 情況一般情況下，我們認為Java中了除了八種基本數據類型，其他都是對象，進行引用傳遞；但是：String、包裝類、枚舉類作為參數傳遞後發現，沒有達到引用傳遞的效果，很多人認為它是值傳遞！首先，對象肯

java 枚舉類型 enum

man port little edi pack 並不會 nal hot class 　　在java SE5中添加了枚舉類型，即enum關鍵字。在這之前，當你需要創建一個整形常量集時，但是這些枚舉值並不會必然的將其自身的取值限制在這個常量集的範圍之內，因此這樣做的顯得不安全

java基礎知識學習--------之枚舉類型（1）

blog 枚舉類型 csdn 相同名稱枚舉類 java string pac 枚舉類型的概念： 1 /** 2 * 目的:枚舉類型 3 * @author chenyanlong 4 * 日期:2017/10/22 5 * 網址:http://blo

java===java基礎學習（3）---數據類型轉換，運算符級別，枚舉類型

test [] sof 進度如果 nbsp math 否則枚舉數據類型轉換：有的時候，程序需要將數據類型，比如 int + float ，結果是float，這裏的int就被轉換為float類型，屬於合法轉換。 Java中的合法轉換如下圖：紅色表示無信息丟失的轉

java基礎(十一) 枚舉類型

抽象類枚舉類型做了 pre markdown div equal uri ole 枚舉類型Enum的簡介 1.什麽是枚舉類型枚舉類型：就是由一組具有名的值的有限集合組成新的類型。(即新的類)。好像還是不懂，別急，咱們先來看一下為什麽要引入枚舉類型在沒有引入枚舉

Java 枚舉類的基本使用

body 我們 enum string 陌生編程所有一個編譯器 1、常量的使用在JDK1.5之前，我們定義常量都是：public static fianl....。現在好了，有了枚舉，可以把相關的常量分組到一個枚舉類型裏，而且枚舉提供了比常量

JAVA枚舉類型

枚舉類型枚舉類型枚舉類型使用一組常量值來表示特定的數據集合，該集合中數據的數目確定（通常較少），且這些數據只能取預先定義的值。 Java枚舉類型均自動繼承java.lang.Enum類（該類繼承了Object類）。聲明枚舉類型：[public] enum 枚舉類型名稱{枚舉對象1,枚舉對象2,…,枚舉對象

2基本類型數組和枚舉類型——重拾Java

arraycopy 字符第一個 system.in abs xtend 劃線 ann else 2.1 標識符和關鍵字 2.1.1標識符標識符：用來標誌類名、變量名、方法名、類型名、數組名、文件名的有效字符序列稱為標識符。簡單地說，標識符就是一個名字。 Java關於標識

java枚舉類 (近期讀書筆記整理，復習所用，存個檔

對象季節 sum 枚舉 java枚舉類因此 bubuko 遍歷 win 某些情況下，一個類的對象是有限而固定的。如地球上的季節，有春夏秋冬四季，即四個對象。這種實例有限且固定的類，被稱為枚舉類。早期，通過定義類的方式，直接使用簡單的靜態變量來表示枚舉。如publ

JAVA枚舉類型的應用

UC 序列建議 ret TP int 比較 hang public 　　JDK1.5引入了新的類型——枚舉。在 Java 中它雖然算個“小”功能，卻對開發有很大的幫助。枚舉的相關用法　　用法一：　　　在JDK1.5 之前，我們定義常量都是： public stati

Java枚舉類型的用法

sse 需要序列 extends 在那初始引入應該 net JDK1.5引入了新的類型——枚舉。在 Java 中它雖然算個“小”功能，卻給我的開發帶來了“大”方便。 1.用法一:常

java中的枚舉類

相關推薦