簡單看看java之枚舉

時間 2019-12-09

標籤簡單看看 java 枚舉欄目 Java 简体版

原文原文鏈接

　　枚舉類這個類用的比較少，對這個不怎麼熟悉，最近看源碼恰好能夠好好了解一下，那麼，枚舉Enum是什麼呢？在jdk中，Enum是一個抽象類下圖所示，這就說明這個類是不能進行實例化的，那麼咱們應該怎麼使用呢？html

1.枚舉類的基本使用java

　　簡單的使用一下（隨便借用的一個栗子），咱們能夠直接把枚舉類看成一個常量同樣來使用這個類，那麼問題來了，下面的這個枚舉類和上面說的那麼Enum抽象類是什麼關係呢？數組

　　確定是繼承啊，這裏很像Cglib動態代理，但確定不是代理。。。反正下面這個類通過編譯，就會編譯出兩個字節碼文件，一個是TestEnum類。另一個就是Week類（這個類自動繼承Enum抽象類）；ide

public class TestEnum{
        
    public static void main(String[] args) {
        System.out.println(Week.MON);
    }
}
//這個枚舉也能夠放在TestEnum裏面，充當一個靜態內部類
enum Week{
        MON,TUE,WED,THU,FRI,SAT,SUN
    }

　　咱們能夠反編譯一下看看Week類中究竟是些什麼東西；this

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   TestEnum.java

//自動的將枚舉類Week繼承Enum
final class Week extends Enum{
 
    public static final Week MON;
    public static final Week TUE;
    public static final Week WED;
    public static final Week THU;
    public static final Week FRI;
    public static final Week SAT;
    public static final Week SUN;
    private static final Week $VALUES[];
  
  //靜態代碼塊中會實例化七個對象和一個Week數組，用於存放這些實例化對象
     static {
        MON = new Week("MON", 0);
        TUE = new Week("TUE", 1);
        WED = new Week("WED", 2);
        THU = new Week("THU", 3);
        FRI = new Week("FRI", 4);
        SAT = new Week("SAT", 5);
        SUN = new Week("SUN", 6);
        $VALUES = (new Week[] {
            MON, TUE, WED, THU, FRI, SAT, SUN
        });
    }
     //構造器
    private Week(String s, int i){
        super(s, i);
    }

    //生成靜態方法values，克隆一份數組，也就是調用這個方法以後就會返回一份包括枚舉類中全部實例的數組
    public static Week[] values(){
        return (Week[])$VALUES.clone();
    }
    //生成靜態方法valueOf，經過指定一個枚舉類型和實例的名稱（字符串），能夠轉化爲一個該枚舉類型的對象
    public static Week valueOf(String s){
        return (Week)Enum.valueOf(Week, s);
    }
   
}

　　能夠看到Enum雖然咱們用的時候是用Enum來聲明的，可是實際上就是一個類，是爲了讓咱們用起來方便簡潔，才這樣設計的（雖然我仍是以爲枚舉很怪。。。）；spa

2.看看Enum抽象類設計

　　咱們發現生成的Week類中構造器會調用父類的構造器，其中i表示每一個實例在數組中的位置，還有values和valueof方法也會調用父類的方法，咱們看看父類全部方法實現，而後再回頭看看就清楚了；代理

package java.lang;

import java.io.Serializable;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;

//這是一個抽象類，只能被繼承
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    //枚舉類中的實例名稱
    private final String name;

    //獲取實例名稱
    public final String name() {
        return name;
    }

    //該實例在實例數組中的位置
    private final int ordinal;

    //獲取該實例所在位置
    public final int ordinal() {
        return ordinal;
    }

    //此構造器只能由子類本身調用，咱們是不能調用，看到子類Week中的構造器中的super(s, i);
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

    //輸出實例名稱
    public String toString() {
        return name;
    }

    //重寫equal方法和hashcode方法，因爲枚舉類中都是對象，那麼比較的確定就是引用是否是同樣了
    public final boolean equals(Object other) {
        return this==other;
    }
    public final int hashCode() {
        return super.hashCode();
    }

    //克隆，這裏會直接報錯，子類中調用的是Object中的clone方法
    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    //比較一個枚舉類中實例名稱的先後順序
    public final int compareTo(E o) {
        Enum other = (Enum)o;
        Enum self = this;
        if (self.getClass() != other.getClass() && 
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

    //獲取枚舉實例的Class對象和父類的Class對象，而後判斷是否是一個對象，我也不知道幹嗎用的
    public final Class<E> getDeclaringClass() {
        Class clazz = getClass();
        Class zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? clazz : zuper;
    }

    //這個方法就是當存在多個枚舉類的時候，每一個枚舉類都有各自對應的多個實例，這個方法就是將
    //根據對應的枚舉類的類型，該枚舉類中的實例名稱，以此來返回該枚舉類型的對象
    public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
            throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

    //最沒用的方法，Object中也有
    protected final void finalize() { }

    //這兩個方法不知道幹嗎用的。。。都會直接拋異常
    private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException {
        throw new InvalidObjectException("can't deserialize enum");
    }
    private void readObjectNoData() throws ObjectStreamException {
        throw new InvalidObjectException("can't deserialize enum");
    }
}

　　這個抽象類方法也不是不少，很容易，如今再來看看枚舉類應該就很容易了；code

　　咱們理一下思路：當咱們在一個日常的類中使用了枚舉類的話，並且這個枚舉類中定義了不少個實例，那麼在使用的時候就會將枚舉類拿出來和類分開編譯，這個枚舉類中的多個實例（這裏每一個實例都有本身的數組下標）都給實例化出來，而且放到一個實例數組中；其中每一個枚舉類都會自動繼承Enum這個抽象類，咱們能夠根據對應的枚舉類來獲取每一個實例的對象，固然枚舉類可能也有多個，那麼也能夠根據Enum這個抽象類來獲取對應枚舉類中的實例，並轉化爲該枚舉類的類型返回。。。htm

　　原理就這麼多吧！下面來看看枚舉類的一些其餘用法；

3.枚舉類的簡單用法

　　首先，枚舉類能夠實現接口：

public interface MyEnum {
    public void say();
}

//實現接口
public enum TestEnum implements MyEnum{
    //注意，
    MON, TUE, WED, THU, FRI, SAT, SUN;

    @Override
    public void say() {
        System.out.println("實現接口--------say");
    }
    
    public static void main(String[] args) {
        TestEnum.MON.say();
    }

}

　　而後在枚舉類中還能有一些屬性，以及set/get方法；

package com.wyq.test;

public enum TestEnum implements MyEnum{
    //注意，這裏最後要加分號
    MON("mon",12), TUE("tue",12), WED("wed",12), THU("thu",12);
    
    private String name;
    private Integer age;
    
    private TestEnum(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public void say() {
        System.out.println("實現接口--------say");
    }
    
    
    public static void main(String[] args) {
        System.out.println(TestEnum.MON.getName()+TestEnum.MON.getAge());
        
    }

}