枚举及其高级用法
Enum源码：
Enum.java
/* * Copyright (c) 2003, 2009, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.lang; import java.io.Serializable; import java.io.IOException; import java.io.InvalidObjectException; import java.io.ObjectInputStream; import java.io.ObjectStreamException; /** * This is the common base class of all Java language enumeration types. * * More information about enums, including descriptions of the * implicitly declared methods synthesized by the compiler, can be * found in section 8.9 of * <cite>The Java™ Language Specification</cite>. * * <p> Note that when using an enumeration type as the type of a set * or as the type of the keys in a map, specialized and efficient * {@linkplain java.util.EnumSet set} and {@linkplain * java.util.EnumMap map} implementations are available. * * @param <E> The enum type subclass * @author Josh Bloch * @author Neal Gafter * @see Class#getEnumConstants() * @see java.util.EnumSet * @see java.util.EnumMap * @since 1.5 */ public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { /** * The name of this enum constant, as declared in the enum declaration. * Most programmers should use the {@link #toString} method rather than * accessing this field. */ private final String name; /** * Returns the name of this enum constant, exactly as declared in its * enum declaration. * * <b>Most programmers should use the {@link #toString} method in * preference to this one, as the toString method may return * a more user-friendly name.</b> This method is designed primarily for * use in specialized situations where correctness depends on getting the * exact name, which will not vary from release to release. * * @return the name of this enum constant */ public final String name() { return name; } /** * The ordinal of this enumeration constant (its position * in the enum declaration, where the initial constant is assigned * an ordinal of zero). * * Most programmers will have no use for this field. It is designed * for use by sophisticated enum-based data structures, such as * {@link java.util.EnumSet} and {@link java.util.EnumMap}. */ private final int ordinal; /** * Returns the ordinal of this enumeration constant (its position * in its enum declaration, where the initial constant is assigned * an ordinal of zero). * * Most programmers will have no use for this method. It is * designed for use by sophisticated enum-based data structures, such * as {@link java.util.EnumSet} and {@link java.util.EnumMap}. * * @return the ordinal of this enumeration constant */ public final int ordinal() { return ordinal; } /** * Sole constructor. Programmers cannot invoke this constructor. * It is for use by code emitted by the compiler in response to * enum type declarations. * * @param name - The name of this enum constant, which is the identifier * used to declare it. * @param ordinal - The ordinal of this enumeration constant (its position * in the enum declaration, where the initial constant is assigned * an ordinal of zero). */ protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; } /** * Returns the name of this enum constant, as contained in the * declaration. This method may be overridden, though it typically * isn't necessary or desirable. An enum type should override this * method when a more "programmer-friendly" string form exists. * * @return the name of this enum constant */ public String toString() { return name; } /** * Returns true if the specified object is equal to this * enum constant. * * @param other the object to be compared for equality with this object. * @return true if the specified object is equal to this * enum constant. */ public final boolean equals(Object other) { return this==other; } /** * Returns a hash code for this enum constant. * * @return a hash code for this enum constant. */ public final int hashCode() { return super.hashCode(); } /** * Throws CloneNotSupportedException. This guarantees that enums * are never cloned, which is necessary to preserve their "singleton" * status. * * @return (never returns) */ protected final Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException(); } /** * Compares this enum with the specified object for order. Returns a * negative integer, zero, or a positive integer as this object is less * than, equal to, or greater than the specified object. * * Enum constants are only comparable to other enum constants of the * same enum type. The natural order implemented by this * method is the order in which the constants are declared. */ public final int compareTo(E o) { Enum other = (Enum)o; Enum self = this; if (self.getClass() != other.getClass() && // optimization self.getDeclaringClass() != other.getDeclaringClass()) throw new ClassCastException(); return self.ordinal - other.ordinal; } /** * Returns the Class object corresponding to this enum constant's * enum type. Two enum constants e1 and e2 are of the * same enum type if and only if * e1.getDeclaringClass() == e2.getDeclaringClass(). * (The value returned by this method may differ from the one returned * by the {@link Object#getClass} method for enum constants with * constant-specific class bodies.) * * @return the Class object corresponding to this enum constant's * enum type */ public final Class<E> getDeclaringClass() { Class clazz = getClass(); Class zuper = clazz.getSuperclass(); return (zuper == Enum.class) ? clazz : zuper; } /** * Returns the enum constant of the specified enum type with the * specified name. The name must match exactly an identifier used * to declare an enum constant in this type. (Extraneous whitespace * characters are not permitted.) * * <p>Note that for a particular enum type {@code T}, the * implicitly declared {@code public static T valueOf(String)} * method on that enum may be used instead of this method to map * from a name to the corresponding enum constant. All the * constants of an enum type can be obtained by calling the * implicit {@code public static T[] values()} method of that * type. * * @param <T> The enum type whose constant is to be returned * @param enumType the {@code Class} object of the enum type from which * to return a constant * @param name the name of the constant to return * @return the enum constant of the specified enum type with the * specified name * @throws IllegalArgumentException if the specified enum type has * no constant with the specified name, or the specified * class object does not represent an enum type * @throws NullPointerException if {@code enumType} or {@code name} * is null * @since 1.5 */ 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); } /** * enum classes cannot have finalize methods. */ protected final void finalize() { } /** * prevent default deserialization */ 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"); } }
我们自定义一个枚举类：
并且需要注意的是枚举类不允许继承别的类
public enum Week { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY }
测试结果：
System.out.println(Week.TUESDAY); // TUESDAY
System.out.println(Week.TUESDAY.name()); // TUESDAY
System.out.println(Week.TUESDAY.ordinal()); // 1
System.out.println(Arrays.asList(Week.values())); // [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
System.out.println(Week.valueOf("TUESDAY")); // TUESDAY
可以看到，我们不用创建枚举类的对象（也不允许创建实例），直接用枚举类名即可访问其枚举元素，且Java自动给按照枚举值出现的顺序，从0开始分配了序号，
通过name()可以获得枚举值的名称，通过ordinal可以获得枚举值的编号。
使用javap反编译后的代码为
public final class enums.Week extends java.lang.Enum<enums.Week> { public static final enums.Week MONDAY; public static final enums.Week TUESDAY; public static final enums.Week WEDNESDAY; public static final enums.Week THURSDAY; public static final enums.Week FRIDAY; public static enums.Week[] values(); public static enums.Week valueOf(java.lang.String); static {
MONDAY=new Week("MONDAY",0);
TUESDAY=new Week("TUESDAY",1);
WEDNESDAY=new Week("WEDNESDAY",2);
THURSDAY=new Week("THURSDAY",3);
FRIDAY=new Week("FRIDAY",4);
} }
1、可以看到enum类型的类在经过编译后生成了一个继承了Enum的类
2、枚举类是final的，这也是为什么其不能再继承其他类的原因，Java不允许多继承
3、我们定义的每个枚举值都是该类中的一个静态final成员，且成员类型为enums.Week
4、默认提供了value()、valueOf()静态方法。
5、在static方法内为我们定义的枚举值都生成了枚举类的对象【MONDAY=new Week("MONDAY",0)】
所以，我们使用enum定义的枚举类型，会在编译后转化为一个继承了java.lang.Enum的类，而我们定义的每个枚举值都会在类的初始化阶段被实例化为我们所定义的枚举类的一个对象。
Enum抽象类常见方法
Enum抽象类的方法，会被定义的枚举类继承。而最终的枚举值被实例化成了Enum对象，因此枚举元素拥有以下的方法。
ordinal()方法：该方法获取的是枚举变量在枚举类中声明的顺序，下标从0开始。位置发生变化，那么ordinal()方法获取到的值也随之变化。
compareTo(E o)方法：比较枚举的大小，注意其内部实现是根据每个枚举的ordinal大小进行比较的
name()方法与toString()：几乎是等同的，都是输出变量的字符串形式
getDeclaringClass()：返回该枚举变量所在的枚举类
默认的构造方法：
protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; }
枚举中根据code获取value，或者根据value获取code
/**
* 放入map中，通过键取值
*/
private static final Map<Integer, String> CATEGORY_MAP = new HashMap<>();
static {
for (CategoryEnum value : CategoryEnum.values()) {
CATEGORY_MAP.put(value.getCode(), value.getValue());
}
}
public static String value(Integer code) {
return CATEGORY_MAP.get(code);
}
枚举类型的其他应用：
1、扩展枚举值与自定义构造函数
我们可以给每个枚举值赋予更多的属性，然后覆盖原来默认的构造方法即可。
最简单的枚举值的默认构造是枚举值字符串和顺序下标，使用这两个值为我们定义的枚举值生成枚举类的对象，如【MONDAY=new Week("MONDAY",0)】
public enum Week { MONDAY("周一", "1"), TUESDAY("周二", "2"), WEDNESDAY("周三", "3"), THURSDAY("周四", "4"), FRIDAY("周五", "5");
private String name; private String value; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } Week(String name, String value) { this.name = name; this.value = value; } @Override public String toString() { return "Week{" + "name='" + name + '\'' + ", value='" + value + '\'' + '}'; } }
2、覆盖enum类的方法
枚举类最终继承了java.lang.Enum抽象类，我们也可以覆盖其中的方法。
3、枚举类中定义抽象方法
编译期最终将每个枚举值声明为了枚举类的实例，那么在枚举类中定义的抽象方法也可以让枚举值去实现该方法。如：
public enum Week { MONDAY("周一", "1") { @Override void sayHello() { System.out.println("11"); } }, TUESDAY("周二", "2") { @Override void sayHello() { System.out.println("22"); } }, WEDNESDAY("周三", "3") { @Override void sayHello() { System.out.println("33"); } }, THURSDAY("周四", "4") { @Override void sayHello() { System.out.println("44"); } }, FRIDAY("周五", "5") { @Override void sayHello() { System.out.println("55"); } }; private String name; private String value; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } Week(String name, String value) { this.name = name; this.value = value; } abstract void sayHello(); @Override public String toString() { return "Week{" + "name='" + name + '\'' + ", value='" + value + '\'' + '}'; } }
4、枚举实现单例
利用枚举值是枚举类的一个实例，且在类加载的初始化阶段调用相应的构造方法进行初始化
1）只定义一个枚举值
2）枚举类的属性类型为单例类
3）重写构造方法创建单例对象
public enum SingletonEnum { INSTANCE; private Instance instance; /** * 重写枚举类的构造方法 */ private SingletonEnum(){ instance=new Instance(); } public Instance getInstance() { return instance; } public void setInstance(Instance instance) { this.instance = instance; } }
获取单例对象：
SingletonEnum.INSTANCE.getInstance();
应用实例：
MongoDB连接只需一个MongoClient 实例
import com.mongodb.MongoClient; import com.mongodb.MongoClientURI; import com.mongodb.client.MongoDatabase; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.core.io.support.PropertiesLoaderUtils; import java.io.IOException; import java.util.Properties; /** * @author yangyongjie * @date 2021/1/25 * @desc */ public enum MongoUtil { /** * 定义一个枚举元素，代表此类的一个实例 */ INSTANCE; private static final Logger LOGGER = LoggerFactory.getLogger(MongoUtil.class); private MongoClient mongoClient; /** * 重写枚举类的构造方法，枚举类经编译后会在将其放在静态代码块中，在类加载的初始化阶段被调用 */ private MongoUtil() { Properties properties = null; try { properties = PropertiesLoaderUtils.loadAllProperties("application.properties"); } catch (IOException e) { e.printStackTrace(); } if (properties != null) { MongoClientURI connectionString = new MongoClientURI(properties.getProperty("mongo.url")); // MongoClient实例表示与数据库的连接池。即使有多个线程，您也只需要一个MongoClient类的实例。 // 所以我们可以在给定的数据库集群创建一个MongoClient实例，并在整个应用程序中使用它 this.mongoClient = new MongoClient(connectionString); } } /*private static MongoClient mongoClient; static { Properties properties = new Properties(); try { InputStream is = ClassLoader.getSystemResourceAsStream("application.properties"); properties.load(is); } catch (IOException e) { e.printStackTrace(); } if (properties != null) { MongoClientURI connectionString = new MongoClientURI(properties.getProperty("mongo.url")); // MongoClient实例表示与数据库的连接池。即使有多个线程，您也只需要一个MongoClient类的实例。 // 所以我们可以在给定的数据库集群创建一个MongoClient实例，并在整个应用程序中使用它 mongoClient = new MongoClient(connectionString); } }*/ public MongoDatabase getDB(String dbName) { if (dbName != null && !"".equals(dbName)) { MongoDatabase database = mongoClient.getDatabase(dbName); return database; } return null; } }
END.
