java枚举比较大小写_Java 枚举（enum）的学习

Java 枚举(enum)的学习

枚举的定义

在定义枚举类型时我们使用的关键字是enum，与class关键字类似，只不过前者是定义枚举类型，后者是定义类类型。枚举类型Day中分别定义了从周一到周日的值，这里要注意，值一般是大写的字母，多个值之间以逗号分隔。同时我们应该知道的是枚举类型可以像类(class)类型一样，定义为一个单独的文件，当然也可以定义在其他类内部，更重要的是枚举常量在类型安全性和便捷性都很有保证，如果出现类型问题编译器也会提示我们改进，但务必记住枚举表示的类型其取值是必须有限的，也就是说每个值都是可以枚举出来的。

//枚举类型，使用关键字enum

enum Day {

MONDAY, TUESDAY, WEDNESDAY,

THURSDAY, FRIDAY, SATURDAY, SUNDAY

}

枚举实现原理

public class EnumDemo {

public static void main(String[] args){

Day day =Day.MONDAY;

}

}

enum Day {

MONDAY,

TUESDAY,

WEDNESDAY,

THURSDAY,

FRIDAY,

SATURDAY,

SUNDAY;

}

编译前面定义的EnumDemo.java文件后分别生成了Day.class和EnumDemo.class文件，而Day.class就是枚举类型，这也就验证前面所说的使用关键字enum定义枚举类型并编译后，编译器会自动帮助我们生成一个与枚举相关的类。我们再来看看反编译Day.class文件：

//反编译Day.class

final class Day extends Enum

{

//编译器为我们添加的静态的values()方法

public static Day[] values()

{

return (Day[])$VALUES.clone();

}

//编译器为我们添加的静态的valueOf()方法，注意间接调用了Enum也类的valueOf方法

public static Day valueOf(String s)

{

return (Day)Enum.valueOf(com/zejian/enumdemo/Day, s);

}

//私有构造函数

private Day(String s, int i)

{

super(s, i);

}

//前面定义的7种枚举实例

public static final Day MONDAY;

public static final Day TUESDAY;

public static final Day WEDNESDAY;

public static final Day THURSDAY;

public static final Day FRIDAY;

public static final Day SATURDAY;

public static final Day SUNDAY;

private static final Day $VALUES[];

static

{

//实例化枚举实例

MONDAY = new Day("MONDAY", 0);

TUESDAY = new Day("TUESDAY", 1);

WEDNESDAY = new Day("WEDNESDAY", 2);

THURSDAY = new Day("THURSDAY", 3);

FRIDAY = new Day("FRIDAY", 4);

SATURDAY = new Day("SATURDAY", 5);

SUNDAY = new Day("SUNDAY", 6);

$VALUES = (new Day[] {

MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY

});

}

}

从反编译的代码可以看出编译器确实帮助我们生成了一个Day类(注意该类是final类型的，将无法被继承)而且该类继承自java.lang.Enum类，该类是一个抽象类(稍后我们会分析该类中的主要方法)，除此之外，编译器还帮助我们生成了7个Day类型的实例对象分别对应枚举中定义的7个日期，这也充分说明了我们前面使用关键字enum定义的Day类型中的每种日期枚举常量也是实实在在的Day实例对象，只不过代表的内容不一样而已。注意编译器还为我们生成了两个静态方法，分别是values()和 valueOf()，稍后会分析它们的用法，到此我们也就明白了，使用关键字enum定义的枚举类型，在编译期后，也将转换成为一个实实在在的类，而在该类中，会存在每个在枚举类型中定义好变量的对应实例对象，如上述的MONDAY枚举类型对应public static final Day MONDAY;，同时编译器会为该类创建两个方法，分别是values()和valueOf()

枚举常见方法

枚举类的valueOf() 方法：

它的作用是传来一个字符串，然后将它转变为对应的枚举变量。前提是你传的字符串和定义枚举变量的字符串一抹一样，区分大小写。如果你传了一个不存在的字符串，那么会抛出异常。

枚举类的values()方法。

这个方法会返回包括所有枚举变量的数组。在该例中，返回的就是包含了七个星期的Day[]。可以方便的用来做循环。

枚举变量的toString()方法。

该方法直接返回枚举定义枚举变量的字符串，比如MONDAY就返回【”MONDAY”】。

枚举变量的.ordinal()方法。

默认情况下，枚举类会给所有的枚举变量一个默认的次序，该次序从0开始，类似于数组的下标。而.ordinal()方法就是获取这个次序(或者说下标)

枚举变量的compareTo()方法。

该方法用来比较两个枚举变量的”大小”，实际上比较的是两个枚举变量的次序，返回两个次序相减后的结果，如果为负数，就证明变量1”小于”变量2 (变量1.compareTo(变量2)，返回【变量1.ordinal() - 变量2.ordinal()】

枚举变量的name()方法。

它和toString()方法的返回值一样，事实上，这两个方法本来就是一样的： 这两个方法的默认实现是一样的，唯一的区别是，你可以重写toString方法。name变量就是枚举变量的字符串形式。

到此对于抽象类Enum类的基本内容就介绍完了，这里提醒大家一点，Enum类内部会有一个构造函数，该构造函数只能有编译器调用，我们是无法手动操作的，不妨看看Enum类的主要源码：

//实现了Comparable

public abstract class Enum>

implements Comparable, Serializable {

private final String name; //枚举字符串名称

public final String name() {

return name;

}

private final int ordinal;//枚举顺序值

public final int ordinal() {

return ordinal;

}

//枚举的构造方法，只能由编译器调用

protected Enum(String name, int ordinal) {

this.name = name;

this.ordinal = ordinal;

}

public String toString() {

return name;

}

public final boolean equals(Object other) {

return this==other;

}

//比较的是ordinal值

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;//根据ordinal值比较大小

}

@SuppressWarnings("unchecked")

public final Class getDeclaringClass() {

//获取class对象引用，getClass()是Object的方法

Class> clazz = getClass();

//获取父类Class对象引用

Class> zuper = clazz.getSuperclass();

return (zuper == Enum.class) ? (Class)clazz : (Class)zuper;

}

public static > T valueOf(Class enumType,

String name) {

//enumType.enumConstantDirectory()获取到的是一个map集合，key值就是name值，value则是枚举变量值

//enumConstantDirectory是class对象内部的方法，根据class对象获取一个map集合的值

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);

}

//.....省略其他没用的方法

}

编译器生成的Values方法与ValueOf方法

values()方法和valueOf(String name)方法是编译器生成的static方法，因此从前面的分析中，在Enum类中并没出现values()方法，但valueOf()方法还是有出现的，只不过编译器生成的valueOf()方法需传递一个name参数，而Enum自带的静态方法valueOf()则需要传递两个方法，从前面反编译后的代码可以看出，编译器生成的valueOf方法最终还是调用了Enum类的valueOf方法，下面通过代码来演示这两个方法的作用：

Day[] days2 = Day.values();

System.out.println("day2:"+Arrays.toString(days2));

Day day = Day.valueOf("MONDAY");

System.out.println("day:"+day);

/**

输出结果:

day2:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]

day:MONDAY

*/

从结果可知道，values()方法的作用就是获取枚举类中的所有变量，并作为数组返回，而valueOf(String name)方法与Enum类中的valueOf方法的作用类似根据名称获取枚举变量，只不过编译器生成的valueOf方法更简洁些只需传递一个参数。这里我们还必须注意到，由于values()方法是由编译器插入到枚举类中的static方法，所以如果我们将枚举实例向上转型为Enum，那么values()方法将无法被调用，因为Enum类中并没有values()方法，valueOf()方法也是同样的道理，注意是一个参数的。

//正常使用

Day[] ds=Day.values();

//向上转型Enum

Enum e = Day.MONDAY;

//无法调用,没有此方法

//e.values();

枚举与Class对象

上述我们提到当枚举实例向上转型为Enum类型后，values()方法将会失效，也就无法一次性获取所有枚举实例变量，但是由于Class对象的存在，即使不使用values()方法，还是有可能一次获取到所有枚举实例变量的，在Class对象中存在如下方法：

通过getEnumConstants()方法，同样可以轻而易举地获取所有枚举实例变量下面通过代码来演示这个功能：

//正常使用

Day[] ds=Day.values();

//向上转型Enum

Enum e = Day.MONDAY;

//无法调用,没有此方法

//e.values();

//获取class对象引用

Class> clasz = e.getDeclaringClass();

if(clasz.isEnum()) {

Day[] dsz = (Day[]) clasz.getEnumConstants();

System.out.println("dsz:"+Arrays.toString(dsz));

}

/**

输出结果:

dsz:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]

*/

枚举的进阶用法

重新定义一个日期枚举类:

enum Day {

MONDAY("星期一",0),

TUESDAY("星期二",1),

WEDNESDAY("星期三",2),

THURSDAY("星期四",3),

FRIDAY("星期五",4),

SATURDAY("星期六",5),

SUNDAY("星期日",6);

private String desc;

private int index;

/**

* 构造函数必须私有化。事实上，private是多余的，你完全没有必要写，

* 因为它默认并强制是private，如果你要写，也只能写private，写public是不能通过编译的。

* @param desc

* @param index

*/

private Day(String desc, int index) {

this.desc = desc;

this.index = index;

}

// 普通方法

public static String getDesc(int index) {

for (Day day : Day.values()) {

if (day.getIndex() == index) {

return day.desc;

}

}

return null;

}

public String getDesc() {

return desc;

}

public int getIndex() {

return index;

}

public static void main(String[] args){

for (Day day:Day.values()) {

System.out.println("name:"+day.name()+

",desc:"+day.getDesc());

}

}

}

从上述代码可知，在enum类中确实可以像定义常规类一样声明变量或者成员方法。但是我们必须注意到，如果打算在enum类中定义方法，务必在声明完枚举实例后使用分号分开，倘若在枚举实例前定义任何方法，编译器都将会报错，无法编译通过，同时即使自定义了构造函数且enum的定义结束，我们也永远无法手动调用构造函数创建枚举实例，毕竟这事只能由编译器执行。

使用枚举创建单例模式

public enum EasySingleton{

INSTANCE;

}

可以使用EasySingleton.INSTANCE调用它

总结

最后总结一下：

可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类了。(java是单继承，它已经继承了Enum),可以添加其他方法，覆盖它本身的方法

switch()参数可以使用enum

values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问了。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例

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

enum允许程序员为eunm实例编写方法。所以可以为每个enum实例赋予各自不同的行为。