15、枚举

1、枚举概念

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个， 否则编译器就会报错，枚举可以让编译器在编译时就可以控制源程序赋给的非法值， 使用普通变量的方式在开发阶段无法实现这一目标。

在JDK 1.5之后， 使用关键字enum定义一种新的类型， 称为枚举类型。

2、Enum类与enum类关键字

使用enum关键字定义的枚举类， 实际上就相当于定义了一个类， 此类继承了Enum类而已。

Enum类中定义了如下的方法：

3、集合对枚举的支持

在JDK 1.5之后， 对于Set和Map接口而言又增加了两个新的子类： EnumSet、 EnumMap两个类。

4、带构造方法的枚举

public enum Color {
    RED(10),BLUE(10);
    private Color() {}
    private int color;
    private Color(int color){
        this.color = color;
    }
}

5、 让枚举实现接口

interface Info {
    public String getColor();
}
public enum Color implements Info {
    RED {
        public String getColor() {return "红色";}
    },
    GREEN {
        public String getColor() {return "绿色";}
    },
    BLUE {
        public String getColor() {return "蓝色";}
    };
}

6、 在枚举中定义抽象方法

public enum Color{
    RED {
        public String getColor() {return "红色";}
    },
    GREEN {
        public String getColor() {return "绿色";}
    },
    BLUE {
        public String getColor() {return "蓝色";}
    };
    public abstract String getColor();
}

Info

package com.vince;
/**
 */
public interface Info {
    public int getColor();
}

Color

package com.vince;
/**
 * 定义一个枚举类型
 */
public enum Color implements Info{
    RED(10) {
        @Override
        public String getColor2() {
            return "red";
        }
    },GREEN(20) {
        @Override
        public String getColor2() {
            return "green";
        }
    },BLUE {
        @Override
        public String getColor2() {
            return "blue";
        }
    };
    private int color;
    private Color(){
        System.out.println("无参构造器");
    }
    private Color(int color){
        this.color = color;
        System.out.println("有参构造器");
    }
    @Override
    public int getColor() {
        return color;
    }
    public abstract String getColor2();
}

EnumDemo

package com.vince;
import org.junit.Test;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.EnumSet;
/**
 */
public class EnumDemo {
    public static final int RED = 0x1;
    public static final int GREEN = 0x2;
    public static final int BLUE = 0x3;
    public int color;
    @Test
    public void test1(){
            color = RED;
            color = 4;
    }
    public Color colorEnum;
    @Test
    public void test2(){
//        colorEnum = Color.RED;
//        colorEnum = Color.BLUE;
        colorEnum = Color.GREEN;
        System.out.println(colorEnum);
        System.out.println(colorEnum.name());
        System.out.println(colorEnum.ordinal());
        System.out.println(colorEnum.toString());
        Color[] values = Color.values();
        System.out.println(Arrays.toString(values));
    }
    @Test
    public void test3(){
        EnumSet<Color> set = EnumSet.allOf(Color.class);
        for(Color c: set){
            System.out.println(c);
        }
        EnumMap<Color,String> map = new EnumMap<>(Color.class);
        map.put(Color.RED,"red");
        map.put(Color.GREEN,"green");
        map.put(Color.BLUE,"blue");
    }
    @Test
    public void test4(){
        System.out.println(Color.RED.getColor());
        System.out.println(Color.RED.getColor2());
    }
    //使用枚举实现单例设计模式
    @Test
    public void test5(){
        Singleton.SINGLETON.method();
    }
}

Singleton

package com.vince;
/**
 */
public enum Singleton {
    SINGLETON;
    public void method(){
        System.out.println("method");
    }
}