Enum源码：
Enum.java
/** Copyright (c) 2003, 2009, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.*/
packagejava.lang;importjava.io.Serializable;importjava.io.IOException;importjava.io.InvalidObjectException;importjava.io.ObjectInputStream;importjava.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
* The Java™ Language Specification.
*
*
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
* {@linkplainjava.util.EnumSet set} and {@linkplain* java.util.EnumMap map} implementations are available.
*
*@param The enum type subclass
*@authorJosh Bloch
*@authorNeal Gafter
*@seeClass#getEnumConstants()
*@seejava.util.EnumSet
*@seejava.util.EnumMap
*@since1.5*/
public abstract class Enum>
implements Comparable, 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 finalString name;/*** Returns the name of this enum constant, exactly as declared in its
* enum declaration.
*
* Most programmers should use the {@link#toString} method in
* preference to this one, as the toString method may return
* a more user-friendly name. 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.
*
*@returnthe name of this enum constant*/
public finalString name() {returnname;
}/*** 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
* {@linkjava.util.EnumSet} and {@linkjava.util.EnumMap}.*/
private final intordinal;/*** 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 {@linkjava.util.EnumSet} and {@linkjava.util.EnumMap}.
*
*@returnthe ordinal of this enumeration constant*/
public final intordinal() {returnordinal;
}/*** Sole constructor. Programmers cannot invoke this constructor.
* It is for use by code emitted by the compiler in response to
* enum type declarations.
*
*@paramname - The name of this enum constant, which is the identifier
* used to declare it.
*@paramordinal - 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, intordinal) {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.
*
*@returnthe name of this enum constant*/
publicString toString() {returnname;
}/*** Returns true if the specified object is equal to this
* enum constant.
*
*@paramother the object to be compared for equality with this object.
*@returntrue if the specified object is equal to this
* enum constant.*/
public final booleanequals(Object other) {return this==other;
}/*** Returns a hash code for this enum constant.
*
*@returna hash code for this enum constant.*/
public final inthashCode() {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() throwsCloneNotSupportedException {throw newCloneNotSupportedException();
}/*** 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 intcompareTo(E o) {
Enum other=(Enum)o;
Enum self= this;if (self.getClass() != other.getClass() && //optimization
self.getDeclaringClass() !=other.getDeclaringClass())throw newClassCastException();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 {@linkObject#getClass} method for enum constants with
* constant-specific class bodies.)
*
*@returnthe Class object corresponding to this enum constant's
* enum type*/
public final ClassgetDeclaringClass() {
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.)
*
*
Note that for a particular enum type {@codeT}, the
* implicitly declared {@codepublic 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 {@codepublic static T[] values()} method of that
* type.
*
*@param The enum type whose constant is to be returned
*@paramenumType the {@codeClass} object of the enum type from which
* to return a constant
*@paramname the name of the constant to return
*@returnthe enum constant of the specified enum type with the
* specified name
*@throwsIllegalArgumentException if the specified enum type has
* no constant with the specified name, or the specified
* class object does not represent an enum type
*@throwsNullPointerException if {@codeenumType} or {@codename}
* is null
*@since1.5*/
public static > T valueOf(ClassenumType,
String name) {
T result=enumType.enumConstantDirectory().get(name);if (result != null)returnresult;if (name == null)throw new NullPointerException("Name is null");throw newIllegalArgumentException("No enum constant " + enumType.getCanonicalName() + "." +name);
}/*** enum classes cannot have finalize methods.*/
protected final voidfinalize() { }/*** prevent default deserialization*/
private void readObject(ObjectInputStream in) throwsIOException,
ClassNotFoundException {throw new InvalidObjectException("can't deserialize enum");
}private void readObjectNoData() throwsObjectStreamException {throw new InvalidObjectException("can't deserialize enum");
}
}
我们自定义一个枚举类：
并且需要注意的是枚举类不允许继承别的类
public enumWeek {
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{public static finalenums.Week MONDAY;public static finalenums.Week TUESDAY;public static finalenums.Week WEDNESDAY;public static finalenums.Week THURSDAY;public static finalenums.Week FRIDAY;public staticenums.Week[] values();public staticenums.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, intordinal) {this.name =name;this.ordinal =ordinal;
}
枚举类型的其他应用：
1、扩展枚举值与自定义构造函数
我们可以给每个枚举值赋予更多的属性，然后覆盖原来默认的构造方法即可。
最简单的枚举值的默认构造是枚举值字符串和顺序下标，使用这两个值为我们定义的枚举值生成枚举类的对象，如【MONDAY=new Week("MONDAY",0)】
public enumWeek {
MONDAY("周一", "1"),
TUESDAY("周二", "2"),
WEDNESDAY("周三", "3"),
THURSDAY("周四", "4"),
FRIDAY("周五", "5");privateString name;privateString value;publicString getName() {returnname;
}public voidsetName(String name) {this.name =name;
}publicString getValue() {returnvalue;
}public voidsetValue(String value) {this.value =value;
}
Week(String name, String value) {this.name =name;this.value =value;
}
@OverridepublicString toString() {return "Week{" +
"name='" + name + '\'' +
", value='" + value + '\'' +
'}';
}
}
2、覆盖enum类的方法
枚举类最终继承了java.lang.Enum抽象类，我们也可以覆盖其中的方法。
3、枚举类中定义抽象方法
编译期最终将每个枚举值声明为了枚举类的实例，那么在枚举类中定义的抽象方法也可以让枚举值去实现该方法。如：
public enumWeek {
MONDAY("周一", "1") {
@OverridevoidsayHello() {
System.out.println("11");
}
},
TUESDAY("周二", "2") {
@OverridevoidsayHello() {
System.out.println("22");
}
},
WEDNESDAY("周三", "3") {
@OverridevoidsayHello() {
System.out.println("33");
}
},
THURSDAY("周四", "4") {
@OverridevoidsayHello() {
System.out.println("44");
}
},
FRIDAY("周五", "5") {
@OverridevoidsayHello() {
System.out.println("55");
}
};privateString name;privateString value;publicString getName() {returnname;
}public voidsetName(String name) {this.name =name;
}publicString getValue() {returnvalue;
}public voidsetValue(String value) {this.value =value;
}
Week(String name, String value) {this.name =name;this.value =value;
}abstract voidsayHello();
@OverridepublicString toString() {return "Week{" +
"name='" + name + '\'' +
", value='" + value + '\'' +
'}';
}
}
4、枚举实现单例
利用枚举值是枚举类的一个实例，且在类加载的初始化阶段调用相应的构造方法进行初始化
1)只定义一个枚举值
2)枚举类的属性类型为单例类
3)重写构造方法创建单例对象
public enumSingletonEnum {
INSTANCE;privateInstance instance;/*** 重写枚举类的构造方法*/
privateSingletonEnum(){
instance=newInstance();
}publicInstance getInstance() {returninstance;
}public voidsetInstance(Instance instance) {this.instance =instance;
}
}
获取单例对象：
SingletonEnum.INSTANCE.getInstance();
应用实例：
MongoDB连接只需一个MongoClient 实例
importcom.mongodb.MongoClient;importcom.mongodb.MongoClientURI;importcom.mongodb.client.MongoDatabase;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.core.io.support.PropertiesLoaderUtils;importjava.io.IOException;importjava.util.Properties;/***@authoryangyongjie
* @date 2021/1/25
* @desc*/
public enumMongoUtil {/*** 定义一个枚举元素，代表此类的一个实例*/INSTANCE;private static final Logger LOGGER = LoggerFactory.getLogger(MongoUtil.class);privateMongoClient mongoClient;/*** 重写枚举类的构造方法，枚举类经编译后会在将其放在静态代码块中，在类加载的初始化阶段被调用*/
privateMongoUtil() {
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 = newMongoClient(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);
}
}*/
publicMongoDatabase getDB(String dbName) {if (dbName != null && !"".equals(dbName)) {
MongoDatabase database=mongoClient.getDatabase(dbName);returndatabase;
}return null;
}
}
END.
