java----枚举

 枚举：

枚举这种类型占用内存空间大，根据需要选择枚举或者常量

每一个枚举元素都是一个对象

基本使用

class  ColorTest{
    //如果使用枚举，不需要再本类中定义...即使定义了，也用不到
//    private int red;
//    private int blue;
//    private int black;
//    private int color;
    private Color colorenum;
//    public void test(){
//        color = red;
//        color = 1;
//    }
    //从编码的角度(编译期)，限制了colorenum的选择范围;
    public void test2(){
        //如果希望color强制只能为red，blue，black中的一种；不能是color = 1;
        colorenum = Color.red;
        //colorenum = 1;  此时会报错，编辑期不给通过

        System.out.println(colorenum);  //red
        System.out.println(colorenum.name()); //red
        System.out.println(colorenum.ordinal()); //2,枚举的序号;
        System.out.println(colorenum.toString());//red

        for (Color s:Color.values()) {
            System.out.println(s);
        }
    }
    public void test3(){
        //存放枚举的集合
        EnumSet<Color> colors = EnumSet.allOf(Color.class);
        for (Color c:colors){
            System.out.println(c);
        }
    }
    public void test4() {
        EnumMap<Color,String> map = new EnumMap<Color, String>(Color.class);
        map.put(Color.red,"111");
        map.put(Color.blue,"222");
        for (Color c:map.keySet()){
            System.out.println(c);
        }
    }
}

 

枚举构造方法

public class Demo{
    public static void main(String[] args) {
        ColorTest colorTest = new ColorTest();
        colorTest.test();
    }
}
enum Color {
    blue,black(10),red;
    //可以定义属性
    private int color;
    //只能定义私有的构造方法
    private Color(){
        System.out.println("无参构造器");
    }
    private Color(int color){
        this.color = color;
        System.out.println("有参构造器");
    }
}
class  ColorTest{
    private Color colorenum;
    public void test(){
        //用到枚举类型Color，所有的构造方法都会被调用
        colorenum = Color.red;
    }
}

 

让枚举实现接口 

Color.red  是一个对象，对象可以调用方法；

public class  Demo{
    public static void main(String[] args) {
        ColorTest colorTest = new ColorTest();
        colorTest.test();
    }
}
interface info{
    int getColor();
}
enum Color implements info{
    blue,black(10),red;
    //可以定义属性
    private int color;
    //只能定义私有的构造方法
    private Color(){
        System.out.println("无参构造器");
    }
    private Color(int color){
        this.color = color;
        System.out.println("有参构造器");
    }
    @Override
    public int getColor() {
        return this.color;
    }
}
class  ColorTest{
    private Color colorenum;
    public void test(){
        int num = Color.red.getColor();
        System.out.println(num);
        int num2 = Color.black.getColor();
        System.out.println(num2);
    }
}

再枚举中定义抽象方法

public class Demo{
    public static void main(String[] args) {
        ColorTest colorTest = new ColorTest();
        colorTest.test();
    }
}
enum Color {
    blue {
        @Override
        public String getColorName() {
            return "blue";
        }
    },black() {
        @Override
        public String getColorName() {
            return "black";
        }
    },red {
        @Override
        public String getColorName() {
            return "red";
        }
    };
    public abstract String getColorName();
}
class  ColorTest{
    public void test(){
        String name = Color.red.getColorName();
        System.out.println(name);
    }
}

枚举实现单例模式

默认 public static final来修饰枚举

public class Demo{
    public static void main(String[] args) {
        //通过SINGLETON对象调用method方法;
        EnumSingleton instance = EnumSingleton.INSTANCE.getInstance();
        EnumSingleton instance1 = EnumSingleton.INSTANCE.getInstance();
        System.out.println(instance==instance1);
    }
}
enum  EnumSingleton {
    INSTANCE;
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}

枚举用途

public interface ResultCode {
    //操作是否成功,true为成功，false操作失败
    boolean success();
    //操作代码
    int code();
    //提示信息
    String message();
}

 

@ToString
public enum CommonCode implements ResultCode{
    SUCCESS(true,10000,"操作成功！"),
    FAIL(false,11111,"操作失败！"),
    UNAUTHENTICATED(false,10001,"此操作需要登陆系统！"),
    UNAUTHORISE(false,10002,"权限不足，无权操作！"),
    SERVER_ERROR(false,99999,"抱歉，系统繁忙，请稍后重试！");
    //private static ImmutableMap<Integer, CommonCode> codes ;
    //操作是否成功
    boolean success;
    //操作代码
    int code;
    //提示信息
    String message;
    
    private CommonCode(boolean success,int code, String message){
        this.success = success;
        this.code = code;
        this.message = message;
    }

    @Override
    public boolean success() {
        return success;
    }
    @Override
    public int code() {
        return code;
    }

    @Override
    public String message() {
        return message;
    }
}

获取所有的枚举对象

enum HandlerBeanEnum {
	//给Name赋值
    AHandler("a"),
    BHandler("b"),
    CHandler("c");
    private String Name;
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	private HandlerBeanEnum(String beanName) {
		this.Name = beanName;
	}
	private HandlerBeanEnum() {
	}
	
}
public class demo {
	@Test
	public void a(){
		//获取所有的枚举对象
		HandlerBeanEnum[] values = HandlerBeanEnum.values();
        for (HandlerBeanEnum value : values) {
            String aString = value.getName();
            System.out.print(aString);
        }
	}
}

　　

 

枚举优点？

可以避免反射攻击

参考：https://www.cnblogs.com/chiclee/p/9097772.html