Java枚举使用以及枚举实现单例模式

JDK 1.5 之前需要自定义枚举类

JDK 1.5 新增的enum关键字用于定义枚举类

若枚举只有一个成员，则可以作为一种单例模式的实现方式。

枚举类型是指由一组固定的常量组成合法值的类型，枚举提供了编译时的类型安全，枚举类型还允许添加任意的方法和域，并实现任意的接口。

Java枚举类型背后的基本想法非常简单：她们就是通过共有的静态final域为每个枚举常量导出实际的类。因为没有可以访问的构造器，所以枚举类型是真正的final。

先看一个自定义枚举类的代码：

package com.liu.enumtest;

class Season{
private Season(String seasonName ,String seansonDesc){
this.seasonName=seasonName;
this.seansonDesc=seansonDesc;
}
//final变量要立即初始化或者构造函数初始化
private final String seasonName;
private final String seansonDesc;
//3.通过公共的方法调用属性,只能调出来get方法。
public String getSeasonName() {
return seasonName;
}
public String getSeansonDesc() {
return seansonDesc;
}
//4.创建枚举类的对象
public static final Season SPRING=new Season("春天","春心荡漾");
public static final Season SUMMER=new Season("夏天","热死人了");
public static final Season AUTUMN=new Season("秋天","秋高气爽");
public static final Season WINTER=new Season("冬天","冰天雪地");
@Override
public String toString() {
return "Season [seasonName=" + seasonName + ", seansonDesc=" + seansonDesc + "]";
}

public void show(){
System.out.println("这是一个季节");
}
}
public class TestSeason {

public static void main(String[] args) {
Season spring = Season.SPRING;
System.out.println(spring);
spring.show();

}

}


运行结果：
Season [seasonName=春天, seansonDesc=春心荡漾]

这是一个季节

使用enum关键字定义枚举类

package com.liu.enum2;

interface Info{
<span style="white-space:pre"> </span>void show();
}

enum Season implements Info{
//一旦为枚举类定义了带参数的构造方法后，列举枚举就必须对应的传入参数
//同时必须要放在最前面
SPRING("spring","春心荡漾"),
SUMMER("夏天","热死人了"),
//可以让不同的枚举类的对象重写抽象方法
AUTUMN("秋天","秋高气爽"){
@Override
public void show() {
System.out.println("分手在那个秋天");
}
},
WINTER("冬天","冰天雪地");
//不能用public修饰
private Season(String seasonName ,String seansonDesc){
this.seasonName=seasonName;
this.seansonDesc=seansonDesc;
}
//final变量要立即初始化或者构造函数初始化
private final String seasonName;
private final String seansonDesc;
//3.通过公共的方法调用属性,只能调出来get方法。
public String getSeasonName() {
return seasonName;
}
public String getSeansonDesc() {
return seansonDesc;
}

@Override
public String toString() {
return "Season [seasonName=" + seasonName + ", seansonDesc=" + seansonDesc + "]";
}
@Override
public void show() {
System.out.println("这是一个季节");
}

}

public class TestSeason {

public static void main(String[] args) {

Season spring=Season.SPRING;
spring.show();
//1.values方法 以数组形式返回每个枚举对象
Season[]seasons=Season.values();
for (int i = 0; i < seasons.length; i++) {
System.out.println(seasons[i]);
}
//
String summer ="SUMMER";
Season sea=Season.valueOf(Season.class, summer);
System.out.println(sea);
//线程的状态是一个枚举类，可以打印出这6个状态
Thread.State[] states=Thread.State.values();
for(int i=0;i<states.length;i++){
System.out.println(states[i]);
}
Season autumn=Season.AUTUMN;
autumn.show();

}

}

运行结果：

这是一个季节

Season [seasonName=spring, seansonDesc=春心荡漾]

Season [seasonName=夏天, seansonDesc=热死人了]

Season [seasonName=秋天, seansonDesc=秋高气爽]

Season [seasonName=冬天, seansonDesc=冰天雪地]

Season [seasonName=夏天, seansonDesc=热死人了]

NEW

RUNNABLE

BLOCKED

WAITING

TIMED_WAITING

TERMINATED

分手在那个秋天

使用枚举实现单例模式：

1

package com.liu.enum2;

enum Singleton{
INSTANCE;
}

public class SingletonTest {
public static void main(String[] args) {
Singleton s=Singleton.INSTANCE;
Singleton s2=Singleton.INSTANCE;
System.out.println(s==s2);
}
}


2
package com.liu.enum2;

enum Singleton2{
INSTANCE{
@Override
protected void read() {
System.out.println("read");
}

@Override
protected void write() {
System.out.println("write");
}
};
protected abstract void read();
protected abstract void write();
}
public class SingletonTest2 {

public static void main(String[] args) {
Singleton2 s=Singleton2.INSTANCE;
s.read();
}

}

反编译过后还原的类
public abstract class Singleton extends Enum
{

private Singleton(String s, int i)
{
super(s, i);
}

protected abstract void read();

protected abstract void write();

public static Singleton[] values()
{
Singleton asingleton[];
int i;
Singleton asingleton1[];
System.arraycopy(asingleton = ENUM$VALUES, 0, asingleton1 = new Singleton[i = asingleton.length], 0, i);
return asingleton1;
}

public static Singleton valueOf(String s)
{
return (Singleton)Enum.valueOf(singleton/Singleton, s);
}

Singleton(String s, int i, Singleton singleton)
{
this(s, i);
}

public static final Singleton INSTANCE;
private static final Singleton ENUM$VALUES[];

static
{
INSTANCE = new Singleton("INSTANCE", 0) {

protected void read()
{
System.out.println("read");
}

protected void write()
{
System.out.println("write");
}

};
ENUM$VALUES = (new Singleton[] {
INSTANCE
});
}
}