枚举基本用法

枚举（enum）：
在JDK1.5提出，单例模式写的代码枚举也可以实现，并且代码量少要很多，但同时枚举可以做到的单例也可以做到，这就很尴尬，两种都可以使用，看自己喜好。

Enum和enum的区别：enum是yige1关键字，而以enum定义的类是继承自Enum抽象类，两者属于继承（父子）关系。

单例模式：
饿汉式：在类加载时进行实例化，但如果没有进行使用，就会浪费内存(JVM启动就会加载)

class Animal {
    private static final Animal ANIMAL = new Animal();  //饿汉式单例
    private Animal(){

    }
    public void print(){
        System.out.println("你好！");
    }
    public static Animal getAnimal(){
        return ANIMAL;
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Animal animalA = Animal.getAnimal();
        Animal animalB = Animal.getAnimal();
        animalA.print();
    }
}

懒汉式：只有在第一次调用时才会进行实例化（在需要的时候加载）

在这里插入代码片class Person{
    private static Person person;   //懒汉式单例模式
    private Person(){

    }
    public void print(){
        System.out.println("新年好！");
    }
    public static Person getPerson(){
        if(person == null){
            person = new Person();
        }
        return person;
    }
}
public class Demo02 {
    public static void main(String[] args) {
        Person person = Person.getPerson();
        person.print();

    }
}

单例模式实现输出还是比较繁琐的，相比之下枚举就轻便许多，但枚举一般用的不深，单例模式用的比枚举多。
枚举：

enum ColorA{     //枚举	关键字enum
    RED,GREEN,BLUE;
}
public class Demo01 {
    public static void main(String[] args) {
        ColorA colora = ColorA.RED;         //枚举直接调用
        ColorA colorb = ColorA.GREEN;       //枚举直接调用
        ColorA colorc = ColorA.BLUE;        //枚举直接调用
        for(ColorA temp : colora.values()){   //colora.values()获取全部的数据,以定义的顺序输出
            System.out.println(temp.name()+":"+temp.ordinal()); //temp.name()获取名字 temp.ordinal()获取序列号
        }

        //System.out.println(colora);    //输出枚举调用的数据
        //System.out.println(colorb);    //输出枚举调用的数据
        //System.out.println(colorc);    //输出枚举调用的数据
    }
}

枚举可以在数据后边写一个类似别名的数据，利用定义一个属性info，输出括号内的数据。

enum ColorB{     //枚举
    RED("红色"),GREEN("绿色"),BLUE("蓝色");
    private String info;
    private ColorB(String info){
        this.info = info;
    }
    public String toString(){   //重写toString()方法
        return this.info;
    }
}
public class Demo02 {
    public static void main(String[] args) {
        ColorB color = ColorB.RED;    //枚举直接调用
System.out.println(color);  //调用重写的toString()方法输出枚举数据后面括号的数据
    }
}

枚举也可以实现接口：

interface IColor {      //接口
    public String getInfo();
}

enum ColorImpl implements IColor {     //枚举实现接口
    RED("红色"), GREEN("绿色"), BLUE("蓝色");
    private String info;

    private ColorImpl(String info) {
        this.info = info;
    }

    public String toString() {   //重写toString()方法
        return this.info;
    }

    public String getInfo() {
        return this.info;
    }
}

public class Demo03 {
    public static void main(String[] args) {
        IColor colora = ColorImpl.RED;
        IColor colorb = ColorImpl.GREEN;
        IColor colorc = ColorImpl.BLUE;
        System.out.println(colora.getInfo());	//调用getInfo()输出对应的数据
        System.out.println(colorb.getInfo());	//调用getInfo()输出对应的数据
        System.out.println(colorc.getInfo());	//调用getInfo()输出对应的数据
    }
}

枚举也可以定义匿名类，调用枚举数据，输出匿名类方法：

enum ColorC {     //枚举
    RED("红色") {
        public String getInfo() {       //匿名方法
            return "红色";
        }
    }, GREEN("绿色") {
        public String getInfo() {       //匿名方法
            return "绿色";
        }
    }, BLUE("蓝色") {
        public String getInfo() {      //匿名方法
            return "蓝色";
        }
    };
    private String info;

    private ColorC(String info) {
        this.info = info;
    }

    public String toString() {   //重写toString()方法
        return this.info;
    }

    public String getInfo() {
        return this.info;
    }
}

public class Demo04 {
    public static void main(String[] args) {
        System.out.println(ColorC.RED.getInfo());   //直接输出匿名方法
    }
}

枚举虽然很便利，但是单例模式用的比枚举用多些，枚举主要用于定义数据进行调用输出，基本上是它用的最多的地方，不过两者都可以，要怎么用就仁者见仁、智者见智了，反正都可以用，想用就用。