java 枚举与单例模式_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{

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

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

分手在那个秋天

另外在项目中也经常这样使用

public enum Type {

MANAGER(1, "管理员"),

USER(1, "普通用户");

private Integer value;

private String desc;

Type(Integer value, String desc) {

this.value = value;

this.desc = desc;

}

public Integer getValue() {

return value;

}

public void setValue(Integer value) {

this.value = value;

}

public String getDesc() {

return desc;

}

public void setDesc(String desc) {

this.desc = desc;

}

private static Map valueStore = new HashMap<>();

private static Map descStore = new HashMap<>();

static {

Type[] types = Type.values();

for (Type type : types) {

valueStore.put(type.getValue(), type);

descStore.put(type.getDesc(), type);

}

}

public static Type valueof(Integer value) {

return valueStore.get(value);

}

public static Type descof(String desc) {

return descStore.get(desc);

}

}

使用枚举实现单例模式：

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

});

}

}