列舉與介面常量、類常量有什么區別？-有解無憂

一個簡單的需求
- 介面常量
- 類常量
列舉
- 什么是列舉？
- 列舉常量
- 限制輸入的型別
- 列舉可以使用==來比較嗎？
- 列舉實作單例

作者：小牛呼嚕嚕 | 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());
    }
}

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

列舉其實是一種特殊的類，可以承接物件的多維資訊，但是常量類往往只能承接欄位，資訊比較單一
列舉可以搭配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("未找到匹配型別");
}

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

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

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

限制輸入的型別

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

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/518800.html

標籤：Java

上一篇：Java I/O（4）：AIO和NIO中的Selector

下一篇：音視頻進階教程｜如何實作游戲中的實時語音