Profile

我們是否一樣？

估計很多小伙伴（也包括我自己）都有這種情況，在自學(xué)Java語言看書時，關(guān)于枚舉enum這一塊的知識點(diǎn)可能都有點(diǎn) “輕敵” ，覺得這塊內(nèi)容非常簡單，一帶而過，而且在實際寫代碼過程中也不注意運(yùn)用。

是的，我也是這樣！直到有一天我提的代碼審核沒過，被技術(shù)總監(jiān)一頓批，我才重新拿起了《Java編程思想》，把枚舉這塊的知識點(diǎn)重新又審視了一遍。

為什么需要枚舉

常量定義它不香嗎？為啥非得用枚舉？

舉個栗子，就以B站上傳視頻為例，視頻一般有三個狀態(tài)：草稿、審核和發(fā)布，我們可以將其定義為靜態(tài)常量：

public class VideoStatus {
    
    public static final int Draft = 1; //草稿
    
    public static final int Review = 2; //審核
    
    public static final int Published = 3; //發(fā)布
}

對于這種單值類型的靜態(tài)常量定義，本身也沒錯，主要是在使用的地方?jīng)]有一個明確性的約束而已，比如：

void judgeVideoStatus( int status ) {
    
    ...
    
}

比如這里的 judgeVideoStatus 函數(shù)的本意是傳入 VideoStatus 的三種靜態(tài)常量之一，但由于沒有類型上的約束，因此傳入任意一個int值都是可以的，編譯器也不會提出任何警告。

但是在枚舉類型出現(xiàn)之后，上面這種情況就可以用枚舉嚴(yán)謹(jǐn)?shù)厝ゼs束，比如用枚舉去定義視頻狀態(tài)就非常簡潔了：

public enum VideoStatus {
    Draft, Review, Published
}

而且主要是在用枚舉的地方會有更強(qiáng)的類型約束：

// 入?yún)⒕陀忻鞔_類型約束
void judgeVideoStatus( VideoStatus status ) {
    
    ...
    
}

這樣在使用 judgeVideoStatus 函數(shù)時，入?yún)㈩愋途蜁艿矫鞔_的類型約束，一旦傳入無效值，編譯器就會幫我們檢查，從而規(guī)避潛在問題。

除此之外，枚舉在擴(kuò)展性方面比普常量更方便、也更優(yōu)雅。

重新系統(tǒng)認(rèn)識一下枚舉

還是拿前文《答應(yīng)我，別再if/else走天下了可以嗎》中的那個例子來說：比如，在后臺管理系統(tǒng)中，肯定有用戶角色一說，而且角色一般都是固定的，適合定義成一個枚舉：

public enum UserRole {

    ROLE_ROOT_ADMIN,  // 系統(tǒng)管理員

    ROLE_ORDER_ADMIN, // 訂單管理員

    ROLE_NORMAL       // 普通用戶
}

接下來我們就用這個UserRole為例來說明枚舉的所有基本用法：

UserRole role1 = UserRole.ROLE_ROOT_ADMIN;
UserRole role2 = UserRole.ROLE_ORDER_ADMIN;
UserRole role3 = UserRole.ROLE_NORMAL;

// values()方法：返回所有枚舉常量的數(shù)組集合
for ( UserRole role : UserRole.values() ) {
    System.out.println(role);
}
// 打?。?// ROLE_ROOT_ADMIN
// ROLE_ORDER_ADMIN
// ROLE_NORMAL

// ordinal()方法：返回枚舉常量的序數(shù)，注意從0開始
System.out.println( role1.ordinal() ); // 打印0
System.out.println( role2.ordinal() ); // 打印1
System.out.println( role3.ordinal() ); // 打印2

// compareTo()方法：枚舉常量間的比較
System.out.println( role1.compareTo(role2) ); //打印-1
System.out.println( role2.compareTo(role3) ); //打印-2
System.out.println( role1.compareTo(role3) ); //打印-2

// name()方法：獲得枚舉常量的名稱
System.out.println( role1.name() ); // 打印ROLE_ROOT_ADMIN
System.out.println( role2.name() ); // 打印ROLE_ORDER_ADMIN
System.out.println( role3.name() ); // 打印ROLE_NORMAL

// valueOf()方法：返回指定名稱的枚舉常量
System.out.println( UserRole.valueOf( "ROLE_ROOT_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_ORDER_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_NORMAL" ) );

除此之外，枚舉還可以用于switch語句中，而且意義更加明確：

UserRole userRole = UserRole.ROLE_ORDER_ADMIN;
switch (userRole) {
    case ROLE_ROOT_ADMIN:  // 比如此處的意義就非常清晰了，比1，2，3這種數(shù)字好！
        System.out.println("這是系統(tǒng)管理員角色");
        break;
    case ROLE_ORDER_ADMIN:
        System.out.println("這是訂單管理員角色");
        break;
    case ROLE_NORMAL:
        System.out.println("這是普通用戶角色");
        break;
}

自定義擴(kuò)充枚舉

上面展示的枚舉例子非常簡單，僅僅是單值的情形，而實際項目中用枚舉往往是多值用法。

比如，我想擴(kuò)充一下上面的UserRole枚舉，在里面加入 角色名 -- 角色編碼 的對應(yīng)關(guān)系，這也是實際項目中常用的用法。

這時候我們可以在枚舉里自定義各種屬性、構(gòu)造函數(shù)、甚至各種方法：

public enum UserRole {

    ROLE_ROOT_ADMIN( "系統(tǒng)管理員", 000000 ),
    ROLE_ORDER_ADMIN( "訂單管理員", 100000 ),
    ROLE_NORMAL( "普通用戶", 200000 ),
    ;

    // 以下為自定義屬性
    
    private final String roleName;  //角色名稱

    private final Integer roleCode; //角色編碼

    // 以下為自定義構(gòu)造函數(shù)
    
    UserRole( String roleName, Integer roleCode ) {
        this.roleName = roleName;
        this.roleCode = roleCode;
    }

    // 以下為自定義方法
    
    public String getRoleName() {
        return this.roleName;
    }

    public Integer getRoleCode() {
        return this.roleCode;
    }

    public static Integer getRoleCodeByRoleName( String roleName ) {
        for( UserRole enums : UserRole.values() ) {
            if( enums.getRoleName().equals( roleName ) ) {
                return enums.getRoleCode();
            }
        }
        return null;
    }

}

從上述代碼可知，在enum枚舉類中完全可以像在普通Class里一樣聲明屬性、構(gòu)造函數(shù)以及成員方法。

枚舉 + 接口 = ?

比如在我的前文《答應(yīng)我，別再if/else走天下了可以嗎》中講煩人的if/else消除時，就講過如何通過讓枚舉去實現(xiàn)接口來方便的完成。

這地方不妨再回顧一遍：

什么角色能干什么事，這很明顯有一個對應(yīng)關(guān)系，所以我們首先定義一個公用的接口RoleOperation，表示不同角色所能做的操作：

public interface RoleOperation {
    String op();  // 表示某個角色可以做哪些op操作
}

接下來我們將不同角色的情況全部交由枚舉類來做，定義一個枚舉類RoleEnum，并讓它去實現(xiàn)RoleOperation接口：

public enum RoleEnum implements RoleOperation {

    // 系統(tǒng)管理員(有A操作權(quán)限)
    ROLE_ROOT_ADMIN {
        @Override
        public String op() {
            return "ROLE_ROOT_ADMIN:" + " has AAA permission";
        }
    },

    // 訂單管理員(有B操作權(quán)限)
    ROLE_ORDER_ADMIN {
        @Override
        public String op() {
            return "ROLE_ORDER_ADMIN:" + " has BBB permission";
        }
    },

    // 普通用戶(有C操作權(quán)限)
    ROLE_NORMAL {
        @Override
        public String op() {
            return "ROLE_NORMAL:" + " has CCC permission";
        }
    };
}

這樣，在調(diào)用處就變得異常簡單了，一行代碼就行了，根本不需要什么if/else：

public class JudgeRole {
    public String judge( String roleName ) {
        // 一行代碼搞定！之前的if/else灰飛煙滅
        return RoleEnum.valueOf(roleName).op();
    }
}

而且這樣一來，以后假如我想擴(kuò)充條件，只需要去枚舉類中加代碼即可，而不用改任何老代碼，非常符合開閉原則！

枚舉與設(shè)計模式

什么？枚舉還能實現(xiàn)設(shè)計模式？

是的！不僅能而且還能實現(xiàn)好幾種！

1、單例模式

public class Singleton {

    // 構(gòu)造函數(shù)私有化，避免外部創(chuàng)建實例
    private Singleton() {

    }

    //定義一個內(nèi)部枚舉
    public enum SingletonEnum{

        SEED;  // 唯一一個枚舉對象，我們稱它為“種子選手”！

        private Singleton singleton;

        SingletonEnum(){
            singleton = new Singleton(); //真正的對象創(chuàng)建隱蔽在此！
        }

        public Singleton getInstnce(){
            return singleton;
        }
    }

    // 故意外露的對象獲取方法，也是外面獲取實例的唯一入口
    public static Singleton getInstance(){
        return SingletonEnum.SEED.getInstnce(); // 通過枚舉的種子選手來完成
    }
}

2、策略模式

這個也比較好舉例，比如用枚舉就可以寫出一個基于策略模式的加減乘除計算器

public class Test {

    public enum Calculator {

        ADDITION {
            public Double execute( Double x, Double y ) {
                return x + y; // 加法
            }
        },

        SUBTRACTION {
            public Double execute( Double x, Double y ) {
                return x - y; // 減法
            }
        },

        MULTIPLICATION {
            public Double execute( Double x, Double y ) {
                return x * y; // 乘法
            }
        },


        DIVISION {
            public Double execute( Double x, Double y ) {
                return x/y;  // 除法
            }
        };

        public abstract Double execute(Double x, Double y);
    }
    
    public static void main(String[] args) {
        System.out.println( Calculator.ADDITION.execute( 4.0, 2.0 ) );       
        // 打印 6.0
        System.out.println( Calculator.SUBTRACTION.execute( 4.0, 2.0 ) );    
        // 打印 2.0
        System.out.println( Calculator.MULTIPLICATION.execute( 4.0, 2.0 ) ); 
        // 打印 8.0
        System.out.println( Calculator.DIVISION.execute( 4.0, 2.0 ) );       
        // 打印 2.0
    }
}

專門用于枚舉的集合類

我們平常一般習(xí)慣于使用諸如：HashMap 和 HashSet等集合來盛放元素，而對于枚舉，有它專門的集合類：EnumSet和EnumMap

1、EnumSet

EnumSet 是專門為盛放枚舉類型所設(shè)計的 Set 類型。

還是舉例來說，就以文中開頭定義的角色枚舉為例：

public enum UserRole {

    ROLE_ROOT_ADMIN,  // 系統(tǒng)管理員

    ROLE_ORDER_ADMIN, // 訂單管理員

    ROLE_NORMAL       // 普通用戶
}

比如系統(tǒng)里來了一批人，我們需要查看他是不是某個角色中的一個：

// 定義一個管理員角色的專屬集合
EnumSet<UserRole> userRolesForAdmin 
    = EnumSet.of( 
        UserRole.ROLE_ROOT_ADMIN,
        UserRole.ROLE_ORDER_ADMIN 
    );

// 判斷某個進(jìn)來的用戶是不是管理員
Boolean isAdmin( User user ) {
    
    if( userRoles.contains( user.getUserRole() ) )
        return true;
    
    return false;
}

2、EnumMap

同樣，EnumMap 則是用來專門盛放枚舉類型為key的 Map 類型。

比如，系統(tǒng)里來了一批人，我們需要統(tǒng)計不同的角色到底有多少人這種的話：

Map<UserRole,Integer> userStatisticMap = new EnumMap<>(UserRole.class);

for ( User user : userList ) {
    Integer num = userStatisticMap.get( user.getUserRole() );
    if( null != num ) {
        userStatisticMap.put( user.getUserRole(), num+1 );
    } else {
        userStatisticMap.put( user.getUserRole(), 1 );
    }
}

用EnumMap可以說非常方便了。

總 結(jié)

小小的枚舉就玩出這么多的花樣，不過好在探索和總結(jié)的過程還挺有意思的，也復(fù)習(xí)了很多知識，慢慢來吧。