Java -枚举类型 知识点总结和案例分享

1. 枚举类型-知识点总结：

枚举类型类的定义:

public enum Day{...}

Java使用关键字enum 声明定义类（该类被称为枚举类型-enum type），每个枚举类型的类都隐式的继承了Java中Enum类。同时也继承了Enum类中定义的所有方法。Java是单继承，所以所有枚举类都不能在继承其他类。

下表列出了在Enum类中定义的方法。

• public final String name()
  返回枚举常量的名称。
• public final int ordinal()
  返回枚举常量的顺序。
• public final boolean equals(Object other)
  如果指定的对象等于枚举常量，则返回true。否则，它返回false。 ==运算符和equals()方法返回相同的结果，当它们用于两个枚举常量。
• public final int hashCode()
  返回枚举常量的哈希码值。
• public final int compareTo(E o)
  将此枚举常量与指定的枚举常量进行比较。它返回此枚举常量和指定的枚举常量的序数值的差异。
• public final Class getDeclaringClass()
  返回声明枚举常量的类的类对象。
• public String toString()
  默认情况下，它返回枚举常量的名称，这与name()方法相同。
• public static valueOf（Class enumType，String name）返回指定的枚举类型和名称的枚举常量。

例子

Level  lowLevel = Enum.valueOf(Level.class, "LOW")

以下代码显示了如何比较两个枚举常量的前后顺序:

enum Level {
  LOW, MEDIUM, HIGH, URGENT;
}

public class Main {
  public static void main(String[] args) {
    Level s1 = Level.LOW;
    Level s2 = Level.HIGH;

    // s1.compareTo(s2) returns s1.ordinal() - s2.ordinal()
    int diff = s1.compareTo(s2);
    if (diff > 0) {
      System.out.println(s1 + "  occurs after  " + s2);
    } else {
      System.out.println(s1 + "  occurs before " + s2);
    }

  }
}
上面的代码生成以下结果:
LOW occurs before HIGH
 

Note：Values() 方法：

该方法不是从Enum类继承而来的，这个方法是编译器插入到enum定义中的static方法，因此也可以通过枚举类名直接调用values()方法。

2. 枚举类型 - 类体中常量，字段，方法的定义。

在enum关键字定义的枚举类类体中，也可以定义变量，构造函数，方法。

常量（constant）：

• 枚举类常量一般定义在类体开头部分，并且最好是全大写方式，如果枚举类中不包含自定义属性和方法，那么可以简写成如下格式。
• 在创建枚举类 常量时，默认调用Enum类的构造函数 Enum(String name, int ordinal)  name 以常量名传入，ordinal是按照定义常量的顺序，依次从0开始递增。
  
• SUNDAY 表示调用Day枚举类无参构造函数创建名为SUNDAY的常量。如果是调用有参函数创建，则可以用SUNDAY（args）来创建枚举类常量。
  

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY 
}

•  如果枚举类中包含自定义的变量和方法，那么在枚举类常量末尾必须以分号；作为结束。如下面示例

public enum Level { 

LOW(30), MEDIUM(15), HIGH(7), URGENT(1); 

// Declare an instance variable 
private int levelValue; 

// Declare a private constructor 
private Level(int levelValue) { 
    this.levelValue = levelValue; 
}
 public int getLevelValue() {
    return levelValue; 
}
}

构造函数(constructor)：

枚举类型的类体中可以创建多个构造函数，但是构造函数的访问修饰符必须是private， 不能使用protected和public 定义。我们不能使用new constructor（）的方式去创建枚举类型的实例。

即：

Level level = new Level(1); // 这段代码将会引起编译错误。

在枚举类型中，它的实例只有在类体开头定义的枚举常量，可以通过如下方式，定义枚举类型的变量。

Level low = Level.LOW; 
Level medium = Level.MEDIUM; 
Level high = Level.HIGH; 
Level urgent = Level.URGENT;

示例：

public enum Level { 

LOW(30), MEDIUM(15), HIGH(7), URGENT(1); 

// Declare an instance variable 
private int levelValue; 

// Declare a private constructor 
private Level(int levelValue) { 
    this.levelValue = levelValue; 
}
 public int getLevelValue() {
    return levelValue; 
}
}

2. 枚举类型 -案例使用

1. 枚举类型的类因为已经继承了Enum类，所以不能继承其他类，但是可以实现接口。如下代码

public interface Behaviour {
    void print();

    String getInfo();
}

public enum Color implements Behaviour {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;

    // 构造方法
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }

    // 接口方法
    @Override
    public String getInfo() {
        return this.name;
    }

    // 接口方法
    @Override
    public void print() {
        System.out.println(this.index + ":" + this.name);
    }
}

2. 枚举类型的类因为构造函数是私有化，不能被外部继承，但是可以通过内部类方式实现枚举类中的抽象方法。

package com.test;

public enum Operator {
    
    PLUS("+"){
        
        @Override
        public String execute(String value1, String value2) {
            int oper1=Integer.parseInt(value1);
            int Oper2=Integer.parseInt(value2);
            return Integer.valueOf(oper1+Oper2).toString();
        }

    }, SUBSTRACT("-"){
        
        @Override
        public String execute(String value1, String value2){
            int oper1=Integer.parseInt(value1);
            int Oper2=Integer.parseInt(value2);
            return Integer.valueOf(oper1-Oper2).toString();
        }
    }, MULTIPLY("×"){
        
        @Override
        public String execute(String value1, String value2){
            int oper1=Integer.parseInt(value1);
            int Oper2=Integer.parseInt(value2);
            return Integer.valueOf(oper1*Oper2).toString();
        }
    },DEVIDE("÷"){
        
        @Override
        public String execute(String value1, String value2){
            int oper1=Integer.parseInt(value1);
            int Oper2=Integer.parseInt(value2);
            return Integer.valueOf(oper1/Oper2).toString();
        }
    };
    
    private String desc;
    
    private Operator(String desc){
        this.desc=desc;
    }

    @Override
    public String toString() {
        return desc;
    }
    
    
    public abstract String execute(String value1, String value2);
}

3. 使用接口组织枚举

public interface Food {
    enum Coffee implements Food {
        BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
    }

    enum Dessert implements Food {
        FRUIT, CAKE, GELATO
    }
}

如果需要扩展enum中的元素，在一个接口的内部，创建实现该接口的枚举，以此将元素进行分组。达到将枚举元素进行分组。

4. 使用枚举创建的单例模式：

public enum EasySingleton{
    INSTANCE;
}

• 1
• 2
• 3

代码就这么简单，你可以使用EasySingleton.INSTANCE调用它，比起你在单例中调用getInstance()方法容易多了。