枚举enum与多例设计

枚举的主要作用是定义有限个数对象的一种结构（多例设计），枚举就属于多例设计，其结构比多例结构更简单

1 枚举的基本定义

从jdk1.5之后程序之中提供了enum的关键字，此关键字可以实现枚举的定义

范例：

public enum Color {
    RED,GREEN,BLUE;  //实例化对象
}

public class Test {
    public static void main(String[] args) {
        Color c = Color.RED;      //获取实例化对象
        System.out.println(c);
    }
}

输出：RED

如果此时采用多例设计模式来进行设计，那么需要编写很多的程序代码，这样对于开发的复杂度是比较高的，因为里面毕竟牵扯到构造方法的私有化以及静态方法。多例设计与枚举设计虽然可以实现相同的功能，但是使用枚举可以在程序编译时就能判断所使用的实例化对象是否存在。

在进行枚举处理的时候还可以利用values()方法获取所有的枚举对象进行输出。

范例：获取所有的枚举对象

public enum Color {
    RED,GREEN,BLUE;  //实例化对象
}

public class Test {
    public static void main(String[] args) {
        for(Color c :Color.values()){
            System.out.println(c);
        }
    }
}

输出：RED
GREEN
BLUE

扫描二维码关注公众号，回复： 2681573 查看本文章

如果此时同样的功能需要通过多例设计来解决的话，那么就需要使对象数组了。

从jdk1.5追加了枚举结构之后，就可以在switch之中进行枚举项的判断。

范例：观察枚举与switch处理

public enum Color {
    RED,GREEN,BLUE;  //实例化对象
}

public class Test {
    public static void main(String[] args) {
        Color c = Color.RED;
        switch (c){
            case RED :
                System.out.println("红色");
                break;
            case GREEN :
                System.out.println("绿色");
                break;
            case BLUE :
                System.out.println("蓝色");
                break;
        }
    }
}

输出：RED

多例上是无法实现这种与switch直接连接的，多例要想实现它就需要编写大量的if判断了。

2 Enum类

严格意义上来讲枚举并不属于一种新的结构，它的本质相当于一个类，但是这个类默认会继承Enum类

类的基本定义：

public abstract class Enum<E extends Enum<E>> entends Object implements Comparable<E>,Serializable

现在定义的枚举类的类型就是Enum中所使用的E

面试题：请解释enum与Enum的区别

enum：是从jdk1.5之后提供的一个关键字，用于定义枚举类

Enum：是一个抽象类，所以使用enum关键字定义的类就默认继承了此类

3 枚举结构定义

枚举属于一种多例设计模式，那么既然是多例设计模式，那么在一个类之中可以定义的结构是非常多的：列如：构造方法、普通方法、属性等，那么这些内容在枚举类中依然可以直接定义，但是需要注意的是：枚举类中定义的构造方法不能够采用非私有化定义（public 无法使用）。

范例：在枚举类中定义其他结构

public enum Color {
    RED("红色"),GREEN("绿色"),BLUE("蓝色");  //枚举对象一定要写在首行(多例设计里面的每个实例都是static final的常量，所以要大写)
    private String title;
    
    private Color(String title){
        this.title = title;
    }
    public String toString(){
        return this.title;
    }
}

public class Test {
    public static void main(String[] args) {
        for(Color c : Color.values()){
            System.out.println(c.ordinal()+"-"+c.name()+"-"+c.toString());
        }
    }
}

输出：0-RED-红色
1-GREEN-绿色
2-BLUE-蓝色

本程序在简化程度上一定要远远高于多例设计模式。除了这种基本的结构之外，在枚举类中也可以实现接口的继承。

范例：让枚举实现接口

public interface IMessage {
    public String getMessage();
}

public enum Color implements IMessage{
    RED("红色"),GREEN("绿色"),BLUE("蓝色");  //枚举对象一定要写在首行(多例设计里面的每个实例都是static final的常量，所以要大写)
    private String title;

    private Color(String title){
        this.title = title;
    }
    public String toString(){
        return this.title;
    }
    public String getMessage(){
        return this.title;
    }
}

public class Test {
    public static void main(String[] args) {
        IMessage msg = Color.RED;
        System.out.println(msg.getMessage());
    }
}

输出：红色

在枚举类里面最有意思的是它直接定义抽象方法，并且要求每个一个枚举对象都要独立复写该抽象方法

范例：让枚举实现抽象方法

public enum Color{
    RED("红色"){
        @Override
        public String getMessage() {
            return this.toString();
        }
    },GREEN("绿色"){
        @Override
        public String getMessage() {
            return this.toString();
        }
    },BLUE("蓝色"){
        @Override
        public String getMessage() {
            return this.toString();
        }
    };  //枚举对象一定要写在首行(多例设计里面的每个实例都是static final的常量，所以要大写)
    private String title;

    private Color(String title){
        this.title = title;
    }
    public String toString(){
        return this.title;
    }
    public abstract String getMessage();
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Color.RED.getMessage());
    }
}

输出：红色

看了之后只有一个感觉，麻烦，所以这个一般不用

4 枚举的实例应用

public enum Sex {
    MALE("男"),FEMALE("女");
    private String title;
    private Sex(String title){
        this.title = title;
    }
    public String toString(){
        return this.title;
    }
}

public class Person {
    private String name;
    private int age;
    private Sex sex;
    public Person(String name,int age,Sex sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public String toString(){
        return "姓名：" + this.name + "、年级：" + this.age + "、性别：" + this.sex;
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(new Person("张三",20,Sex.MALE));
    }
}

输出：姓名：张三、年级：20、性别：男

5 多例设计

最后我们来看看多例设计。单例设计指的是只保留有一个实例化对象，而多例设计是可以保留有多个实例化对象。例如：如果现在要定义一个描述性别的类，那么该对象只有两个：男、女。或者描述颜色基色的类：红色，绿色。这种情况我们就可以利用多例设计来解决。

范例：实现多例设计

public class Color{
    private static final Color RED = new Color("红色");
    private static final Color GREEN = new Color("绿色");
    private static final Color BLUE = new Color("蓝色");
    private String title;
    private Color(String title){   //构造方法私有化
        this.title = title;
    }
    public static Color getInstance(String color){
        switch(color){
            case "red": return RED;
            case "green" : return GREEN;
            case "blue" : return  BLUE;
            default:return  null;
        }
    }
    public String toString(){
        return this.title;
    }
}

public class Test {
    public static void main(String[] args) {
        Color c = Color.getInstance("green");
        System.out.println(c);
    }
}

输出：绿色

多例设计与单例设计的本质是相同的，一定都会在内部提供有static方法以返回实例化对象。

另外注意一点：构造方法私有化不仅仅是指private，还有protected，default。