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
分手在那个秋天

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

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<Integer, Type> valueStore = new HashMap<>();
    private static Map<String, Type> 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
        });
    }
}