Enum类源码
package java.lang;
import java.io.Serializable;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
/**
* 这是所有java语言枚举类型的公共基类。
*
*
* 注意,当使用枚举类型作为一个set或者Map的keys,
* {@linkplain java.util.EnumSet set} 和{@linkplain
* java.util.EnumMap map} 专门且高效的实现。
*
* @param <E>枚举类型的子类
* @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 {
/**
* 枚举常量的名称,在其枚举声明中对其进行声明。
* 大多数程序员应该使用 {@link #toString} 方法而不是直接访问此字段。
*/
private final String name;
/**
* 返回此枚举常量的名称,在其枚举声明中对其进行声明。
*
* 与此方法相比,大多数程序员应该优先考虑使用 toString() 方法,因为 toString 方法返回更加用户友好的名称。
* 该方法主要设计用于特殊情形,其正确性取决于获取正确的名称,其名称不会随版本的改变而改变。
*
* @return 返回此枚举常量的名称。
*/
public final String name() {
return name;
}
/**
* 枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。
*
* 大多数程序员不会使用此变量。它被设计用于复杂的基于枚举的数据结构,比如
* {@link java.util.EnumSet} 和 {@link java.util.EnumMap}。
*/
private final int ordinal;
/**
* 返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。
*
* 大多数程序员不会使用此方法。它被设计用于复杂的基于枚举的数据结构,比如
* {@link java.util.EnumSet} 和 {@link java.util.EnumMap}。
*/
public final int ordinal() {
return ordinal;
}
/**
* 唯一的构造函数。程序员不能调用这个构造函数。它是利用由响应枚举类型声明编译器产生的代码。
* @param name - 此枚举常量的名称,它是用来声明该常量的标识符。
* @param ordinal - 枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。
*/
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
/**
* 返回枚举常量的名称,它包含在声明中。可以重写此方法,虽然一般来说没有必要。当存在更加“程序员友好的”字符串形式时,应该使用枚举类型重写此方法。
* 覆盖类 Object 中的 toString
*
* @return 枚举常量的名称
*/
public String toString() {
return name;
}
/**
* 当指定对象等于此枚举常量时,返回 true。
* 覆盖类 Object 中的 equals
*
* @param other 要与此对象进行相等性比较的对象。
* @return 如果指定对象等于此枚举常量,则返回 true。
*/
public final boolean equals(Object other) {
return this==other;
}
/**
* 返回枚举常量的哈希码。
* 覆盖类 Object 中的 hashCode
*
* @return 枚举常量的哈希码。
*/
public final int hashCode() {
return super.hashCode();
}
/**
* 抛出 CloneNotSupportedException。这可保证永远不会复制枚举,以保证枚举是单例的。
* 覆盖类 Object 中的clone
*
* @return (不返回)
*/
protected final Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
/**
* 比较此枚举与指定对象的顺序。在该对象小于、等于或大于指定对象时,分别返回负整数、零或正整数。
* 枚举常量只能与相同枚举类型的其他枚举常量进行比较。该方法实现的自然顺序就是声明常量的顺序。
*
*
*/
public final int compareTo(E o) {
Enum<?> other = (Enum<?>)o;
Enum<E> self = this;
if (self.getClass() != other.getClass() && // optimization
self.getDeclaringClass() != other.getDeclaringClass())
throw new ClassCastException();
return self.ordinal - other.ordinal;
}
/**
* 返回与此枚举常量的枚举类型相对应的 Class 对象。当且仅当 e1.getDeclaringClass() == e2.getDeclaringClass() 时,
* 两个枚举常量 e1 和 e2 的枚举类型才相同。(由该方法返回的值不同于由 Object.getClass() 方法返回的值, Object.getClass()
* 方法用于带有特定常量的类主体的枚举常量。)
*
* @return 与此枚举常量的枚举类型相对应的 Class 对象
*/
@SuppressWarnings("unchecked")
public final Class<E> getDeclaringClass() {
Class<?> clazz = getClass();
Class<?> zuper = clazz.getSuperclass();
return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
}
/**
* 返回带指定名称的指定枚举类型的枚举常量。名称必须与在此类型中声明枚举常量所用的标识符完全匹配(不允许使用额外的空白字符)。
*
* @param 要从中返回常量的枚举类型的 Class 对象
* @param 要返回的常量名称
* @return 带指定名称的指定枚举类型的枚举常量
* @throws IllegalArgumentException 如果指定枚举类型不包含指定名称的常量,或者指定类对象不表示枚举类型
* @throws 如果 enumType 或 name 为空
* @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);
}
/**
* 枚举类不能有 finalize 方法。
* 覆盖类 Object 中的 finalize。
*/
protected final void finalize() { }
/**
* 禁止反序列化
*/
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");
}
}
源码理解
Enum类位于java.lang包下实现了Comparable和Serializable接口,因此可以序列化,可以进行比较,并且Enum类是抽象类,因此不能被实例化,但是不能被继承。之所以不能被继承是因为枚举类使用enum定义后在编译后默认继承了java.lang.Enum类,采用enum声明后,该类会被编译器加上final声明(同String)。Enum<E extends Enum>就是一个Enum只接受一个Enum或者他的子类作为参数。相当于把一个子类或者自己当成参数,传入到自身,引起一些特别的语法效果。Enum类有两个成员变量name和ordinal,protected修饰的构造方法且唯一,重写了toString(),equals(),hashCode(),clone()和finalize()方法。clone()方法保证单例。finalize()方法这保证枚举不会拥有finalize方法(主要是为了在垃圾回收对象的时候做一些额外的清理工作)。readObject和readObjectNoData两个方法为了禁止反序列化。枚举禁止clone和禁止反序列化的原因是单例模式通常可以通过clone和反序列化来实现产生一个单例类多个不同的对象,在这里禁止clone和反序列化就能避免这种情况发生。
Javadoc标签
@author 作者
@param 输入参数的名称 说明
@return 输出参数说明
@since JDK版本
@see 链接目标
@throws 异常
@deprecated 解释
@link 链接地址
@linkplain 设定超链接地址,还可以设定其文本。格式是{@linkplain 地址 文本}
enum使用语法
创建枚举类型要使用 enum 关键字,隐含了所创建的类型都是 java.lang.Enum 类的子类。枚举类型符合通用模式 Class Enum<E extends Enum<E>>
,而 E
表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal)
构造函数中,在这里,每个值的名称都被转换成一个字符串,并且序数设置表示了此设置被创建的顺序。
enum的使用
1、常量
package ecut.enums;
/**
* 所有的枚举常量必须 列在 枚举类的 首行 ( 第一个 分号之前 )
* 所有的枚举常量 直接写 常量名称即可 ( 默认全部是 public static final )
* 多个枚举常量之间 用 逗号 隔开
* 所有的枚举常量在声明时已经默认调用了相应的构造方法
*所有的 枚举类型 都继承自 java.lang.Enum
*
*/
public enum Gender {
FEMALE ,MALE
}
2、switch
package ecut.enums;
public class GenderTest2 {
public static void main(String[] args) {
Gender[] genders = Gender.values() ;
int index = ( int )( Math.random() * 2 );
Gender g = genders[ index ];
switch ( g ) {
case FEMALE:
System.out.println( "万寿无疆" );
break;
case MALE:
System.out.println( "一统江湖" );
break;
}
}
}
3、自定义属性和方法
package ecut.enums;
/**
* 所有的枚举常量必须 列在 枚举类的 首行 ( 第一个 分号之前 )
* 所有的枚举常量 直接写 常量名称即可 ( 默认全部是 public static final )
* 多个枚举常量之间 用 逗号 隔开
* 所有的枚举常量在声明时已经默认调用了相应的构造方法
*
* public static final Gender MALE = new Gender( "靓仔" );
*
*所有的 枚举类型 都继承自 java.lang.Enum
*
*/
public enum Gender {
FEMALE( "靓妹") ,
MALE( "靓仔" )
;
private String genderName ;
private Gender( String name ){
System.out.println( "Gender");
this.genderName = name ;
}
public String getGenderName() {
return genderName;
}
}
4、遍历
package ecut.enums;
public class GenderTest1 {
public static void main(String[] args) {
Gender g = Gender.FEMALE ;
System.out.println( g.getGenderName() );
// 所有的枚举类型 都有一个 valueOf 方法
// 该方法可以根据给定的 枚举常量的名称 获得 相应的枚举常量
g = Gender.valueOf( "MALE" );
System.out.println( g.getGenderName() );
// 所有的枚举类型 都有一个 values 方法 返回该枚举类内部的所有枚举常量
Gender[] gs = Gender.values();
for( Gender e : gs ) {
System.out.println( e.ordinal() + " , " + e.name() + " , " + e.getGenderName() );
}
}
}
运行结果如下:
Gender
Gender
靓妹
靓仔
0 , FEMALE , 靓妹
1 , MALE , 靓仔
从源码中我们可以看到是没有values()方法的,但所有的枚举类型 都有一个 values 方法,这是是因为java编译器在对enum关键字进行处理时,实际上是将enum转换成为了java.lang.Enum类的一个子类来完成,而这个子类中含有values()静态方法。
enum Color {RED, BLUE, GREEN}
编译器将会把他转成如下内容:
public final class Color extends Enum<Color> {
public static final Color[] values() { return (Color[])$VALUES.clone(); }
public static Color valueOf(String name) { ... }
private Color(String s, int i) { super(s, i); }
public static final Color RED;
public static final Color BLUE;
public static final Color GREEN;
private static final Color $VALUES[];
static {
RED = new Color("RED", 0);
BLUE = new Color("BLUE", 1);
GREEN = new Color("GREEN", 2);
$VALUES = (new Color[] { RED, BLUE, GREEN });
}
}
5、使用接口组织枚举
public interface Food {
enum Coffee implements Food {
BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
}
enum Dessert implements Food {
FRUIT, CAKE, GELATO
}
}
EnumSet和EnumMap的使用
package ecut.enums;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.Map.Entry;
public class GenderTest3 {
public static void main(String[] args) {
// EnumSet的使用
EnumSet<Gender> genderSet = EnumSet.allOf(Gender.class);
for (Gender gender : genderSet) {
System.out.println(gender);
}
// EnumMap的使用
EnumMap<Gender, String> genderMap = new EnumMap<Gender, String>(Gender.class);
genderMap.put(Gender.FEMALE, "妹纸");
genderMap.put(Gender.MALE, "汉纸");
// 迭代器遍历
for (Iterator<Entry<Gender, String>> iter = genderMap.entrySet().iterator(); iter.hasNext();) {
Entry<Gender, String> entry = iter.next();
System.out.println(entry.getKey().name() + ":" + entry.getValue());
}
}
}
运行结果如下:
Gender
Gender
FEMALE
MALE
FEMALE:妹纸
MALE:汉纸
枚举和常量定义的区别
1、从源码equals方法中可以看出枚举可以用==直接对比,常量值地址唯一,性能比常量高,因为常量是由于开发人员可以直接写,所以不能用==对比,只能用equals对比。
2、枚举定义方法的参数时,必须用枚举常量类类型,,这样就转变成了强类型,不会出现弱类型引用的问题。而常量作为参数时,是String,int等弱类型,开发人员可以传入没有在常量接口里定义的值,这个问题无法通过编译器发现。
3、枚举编译时,没有把常量值编译到代码里,即使常量的值发生变化,也不会影响引用常量的类,而常量编译时,是直接把常量的值编译到类的二进制代码里,常量的值在升级中变化后,需要重新编译引用常量的类,因为里面存的是旧值。
待解决问题
使用接口组织枚举
参考博客链接
https://www.cnblogs.com/todaylovegoaway/p/6023609.html
http://www.hollischuang.com/archives/92
http://www.cnblogs.com/hemingwang0902/archive/2011/12/29/2306263.html
https://www.cnblogs.com/happyPawpaw/archive/2013/04/09/3009553.html
http://blog.csdn.net/wangqisen/article/details/34072821
http://blog.csdn.net/yin_pisces/article/details/52050427
转载请于明显处标明出处