列舉與介面常數、類常數有什麼區別？

作者：小牛呼嚕嚕 | https://xiaoniuhululu.com
計算機內功、JAVA底層、面試相關資料等更多精彩文章在公眾號「小牛呼嚕嚕 」

一個簡單的需求

在我們實際開發java專案過程中，突然有一天"領導老王"給了個任務, 公司系統需要支援商品管理的需求
比如水果有：蘋果，香蕉，葡萄等等，電子產品有：電腦，手機，攝像機等等

我們一般新建商品類Goods:

public class Goods {
    /**
     * 商品名稱
     */
    private String name;
    /**
     * 商品型別
     */
    private Integer type;

    public Goods(String name, Integer type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }

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

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }
}

然後我們就直接可以使用它：

public class GoodsTest {
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods("水果",1);//1代表蘋果，2：香蕉，3：葡萄
        System.out.println(goods.getName());
    }
}

但是有個問題，業務程式碼不清晰，有時候開發人員並不知道1、2、3代表什麼意思，而且在業務程式碼層裡面直接寫數位或者字串也是非常危險的時，我們需要一種方案，既能將相關的狀態，型別放在一起，又可以限制類的輸入值，提升專案的安全性

介面常數

我們可以使用介面常數來解決上面的問題

public interface StatusContentFace {
    public static final String fruit  = "fruit";

    public static final Integer apple  = 1;

    public static final Integer banana  = 2;

    public static final Integer grape  = 3;

    //==========================

    public static final String eleProduct  = "eleProduct";

    public static final Integer computer  = 101;

    public static final Integer phone  = 102;

    public static final Integer camera  = 103;
}

我們再來看下測試類：

public class GoodsTest1 {
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods(StatusContentFace.fruit,StatusContentFace.apple);
        Goods goods_2 = new Goods(StatusContentFace.eleProduct,StatusContentFace.computer);
        System.out.println(goods.getName());
        System.out.println(goods_2.getName());
    }
}

這樣能夠讓相關的常數都在同一個介面檔案中，介面常數，寫起來比較簡潔，但是為了讓其他人知道每個常數的含義，最好寫上註釋。
但它同時有個問題，由於java中介面是支援多繼承的

• 我們可以將內容深入到其實現類程式碼中，這樣對於一個常數類介面來說顯然是不合理。
• 我們還可以在其子介面裡繼續新增常數，這樣在祖先介面中就無法控制所有常數，這樣無疑是非常危險的。

一般不建議用的，但介面常數也不是一無是處的，可以通過內部介面來實現分組效果

public class GoodsTest2 {
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods(Fruit.type,Fruit.banana);
        Goods goods_2 = new Goods(EleProduct.type,EleProduct.phone);
        System.out.println(goods.getName());
        System.out.println(goods_2.getName());
    }
    
    //常數分組
    public interface Fruit {
        String type = "fruit";
        Integer apple = 1;
        Integer banana = 2;
        Integer grape = 3;
    }

    public interface EleProduct {
        String type = "eleProduct";
        Integer computer = 101;
        Integer phone = 102;
        Integer camera = 103;
    }
    
}

這樣我們可以把相關的常數都歸為一類，更加簡潔明瞭

類常數

我們一般常用的是類常數方式：

public final class StatusConstant {
    private StatusConstant() {} //防止該類範例化

    public static final String fruit  = "fruit";

    public static final Integer apple  = 1;

    public static final Integer banana  = 2;

    public static final Integer grape  = 3;

    //==========================

    public static final String eleProduct  = "eleProduct";

    public static final Integer computer  = 101;

    public static final Integer phone  = 102;

    public static final Integer camera  = 103;
}

注意：一般用final關鍵字修飾 class 防止其被繼承，並將其建構函式 private 化，防止被範例化

測試類：

public class GoodsTest3 {
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods(StatusConstant.fruit, StatusConstant.banana);
        Goods goods_2 = new Goods(StatusConstant.eleProduct, StatusConstant.phone);
        System.out.println(goods.getName());
        System.out.println(goods_2.getName());
    }
}

我們可以發現類常數的方式，的確很方便，也沒有介面常數多繼承的煩惱。但是她所能承接的資訊，維度不夠，只能一個欄位的去承接資訊，然而當專案複雜的話，我們希望往往其能承接更多維度的資訊，類似於物件一樣，擁有更多的屬性

{
    "name": ...,
    "type": ...,
     ... 
}

這時候，我們本文的主角，列舉就閃亮登場了！

列舉

什麼是列舉？

列舉是一種特殊的類，所有的列舉類都是Enum類的子類,就類似Object類一樣，由於java類是單繼承的，所以不能在繼承其他類或者列舉了。
列舉變數不能使用其他的資料，只能使用列舉中常數賦值。能提高程式的安全性。

格式：

public enum 列舉名{ 
  //列舉的取值範圍 
} 

列舉常數

我們先定義一個列舉類,來定義常數：

public enum ContentEnums {
    Apple(1,"蘋果"),
    Banana(2,"香蕉"),
    Grape(3,"葡萄"),

    Computer(101,"電腦"),
    Phone(102,"手機"),
    Camera(103,"攝像機"),
    

    Fruit(10010,"fruit"),
    EleProduct(10020,"eleProduct");


    private Integer code;
    private String desc;

    ContentEnums(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

測試類：

public class GoodsTest4 {
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods(ContentEnums.Fruit.getDesc(), ContentEnums.Apple.getCode());
        Goods goods_2 = new Goods(ContentEnums.EleProduct.getDesc(), ContentEnums.Phone.getCode());
        System.out.println(goods.getName());
        System.out.println(goods_2.getName());
    }
}

看到這大家可能就有疑問了，列舉和常數類相比，有什麼優點嗎？

1. 列舉其實是一種特殊的類，可以承接物件的多維資訊，但是常數類往往只能承接欄位，資訊比較單一
2. 列舉可以搭配switch語句使用，來代替if/else

ContentEnums content = ContentEnums.Apple;

switch (content) {
    case Apple:
        System.out.println("蘋果");
        break;
    case Banana:
        System.out.println("香蕉");
        break;
    case Grape:
        System.out.println("葡萄");
        break;
    default:
        System.out.println("未找到匹配型別");
}

3. enum 有一個非常有趣的特性，它可以為enum範例編寫方法

public enum MethodEnums {
    VERSION {
        @Override
        String getInfo() {
            return System.getProperty("java.version");
        }
    },
    DATE_TIME {
        @Override
        String getInfo() {
            return
                    DateFormat.getDateInstance()
                            .format(new Date());
        }
    };
    abstract String getInfo();

    public static void main(String[] args) {
        for(MethodEnums csm : values()) {
            System.out.println(csm.getInfo());
        }

    }
}

結果：

1.8.0_271

2022-9-21

除了抽象方法，普通方法也是可以的，這裡就不展示了

4. 網上還有其他一些優點，感覺沒啥特別值得說的

限制輸入的型別

我們可以通過列舉來將相關的狀態，型別放在一起，文章一開頭，但我們怎麼才能限制類的輸入值呢？其實很簡單，別被繞進去，我們只需將輸入型別 改為指定的列舉即可
我們改造一下Goods類：

public class Goods {
    /**
     * 商品名稱
     */
    private String name;
    /**
     * 商品型別
     */
    private Integer type;

//    public Goods(String name, Integer type) {
//        this.name = name;
//        this.type = type;
//    }

    public Goods() {//防止外部範例化

    }

    public String getName() {
        return name;
    }

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

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public static Goods addGoods(ContentEnums enums){
        Goods goods = new Goods();
        goods.setName(enums.getDesc());
        goods.setType(enums.getCode());
        return goods;
    }
}

測試類：

public class GoodsTest5 {
    public static void main(String[] args) throws InterruptedException {
        Goods goods = Goods.addGoods(ContentEnums.Apple);
        Goods goods_2 = Goods.addGoods(ContentEnums.Computer);
        System.out.println(goods.getName());
        System.out.println(goods_2.getName());
    }
}

這樣，我們就可以限制建立物件時的輸入值型別了

列舉可以使用==來比較嗎？

可以使用==來比較 enum 範例，編譯器會自動為你提供equals()和 hashCode() 方法。Enum 類實現了 Comparable 介面，所以它具有 compareTo() 方法。同時，它還實現了 Serializable 介面。

列舉實現單例

列舉型別是天生執行緒安全的，並且只會裝載一次，我們可以利用了列舉的這個特性來實現單例

public enum SingleInstance {
    INSTANCE;
    public void funDo() {
          System.out.println("doSomething");
    }
}

使用方式：SingleInstance.INSTANCE.funDo(）
這種方法充分 利用列舉的特性，讓JVM來幫我們保證執行緒安全和單一範例的問題。寫法也極其簡潔。

---

參考：
《On Java 8》
《Effective java》第3版

---

本篇文章到這裡就結束啦，很感謝你能看到最後，如果覺得文章對你有幫助，別忘記關注我！更多精彩的文章