Java枚举

枚举：在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。通过这句话可以看出，枚举具有的几个特点：一组数据的集合，数据的个数是有限的，数据的值是不变的。
我们要通过类和对象来模拟的话，那么该类不能创建任意多的对象，所以需要构造函数私有化，并且提供静态的内部创建的对象，该对象还需要是常量。
下面的代码通过模拟开关，只有开和关两种状态，来模拟枚举。

/**
 * 模拟枚举的实现方式
 * @author Hong
 *
 */
public class Study01 {
    public static void main(String[] args) {
        Controller01 on = Controller01.ON;
        Controller01 off = Controller01.OFF;
        System.out.println(on);
        System.out.println(off);

    }
}

/**
 * 开关只有开和关两种状态，所以要控制开关这个类只有两个对象
 * 必然要有构造器私有化，提供静态方法来实现
 * @author Hong
 *
 */
class Controller01{
    private Controller01(){}

    public static Controller01 ON = new Controller01();
    public static Controller01 OFF = new Controller01();
}


----------


/**
 * 输出结果：
    hong.study._enum.Controller01@1db9742
    hong.study._enum.Controller01@106d69c
 * */

当然开关还需要有一个必备的功能，按一下就变成相反的状态。下面的代码添加了该功能。

/**
 * 模拟枚举的实现方式
 * @author Hong
 *
 */
public class Study02 {
    public static void main(String[] args) {
        Controller02 on = Controller02.ON;
        Controller02 off = Controller02.OFF;
        on.click();
        off.click();
    }
}

/**
 * 开关只有开和关两种状态，所以要控制开关这个类只有两个对象
 * 必然要有构造器私有化，提供静态方法来实现
 * -----------------
 * 添加开关的功能，开着的状态下按一下就关了，关了的状态下按一下就开了
 * @author Hong
 *
 */
class Controller02{
    private Controller02(){}

    public static Controller02 ON = new Controller02();
    public static Controller02 OFF = new Controller02();

    /*
     * 通过判断是哪个对象来确定点击动作的功能
     */
    public void click(){
        if(this.equals(ON)){
            System.out.println("开关关闭了");
        }else{
            System.out.println("开关打开了");
        }
    }
}


----------


/*
 *输出结果： 
    开关关闭了
    开关打开了
 * /
 */

这里通过if判断当前开关是处于哪种状态，从而按一下变成另一种状态。然而如果类似于周的集合，每天干对应的一件事，那么就需要判断7次，来判断该干什么事，这样效率是很低的。
下面的代码通过匿名内部类来实现高效的不同的变量对应的动作。

/**
 * 模拟枚举的实现方式
 * @author Hong
 *
 */
public class Study03 {
    public static void main(String[] args) {
        Controller03 on = Controller03.ON;
        Controller03 off = Controller03.OFF;
        System.out.println(on.click());
        System.out.println(off.click());
    }
}

/**
 * 开关只有开和关两种状态，所以要控制开关这个类只有两个对象
 * 必然要有构造器私有化，提供静态方法来实现
 * -----------------
 * 添加开关的功能，开着的状态下按一下就关了，关了的状态下按一下就开了
 * -----------------
 * 采用匿名内部类实现自己的类有自己对应的点击动作，无需判断
 * @author Hong
 *
 */
abstract class Controller03{
    private Controller03(){}

    public static Controller03 ON = new Controller03() {

        @Override
        public Controller03 click() {
            return OFF;
        }

        public String toString() {
            return "on";
        };
    };
    public static Controller03 OFF = new Controller03() {

        @Override
        public Controller03 click() {
            // TODO Auto-generated method stub
            return ON;
        }

        public String toString() {
            return "off";
        };
    };

    /*
     * 通过抽象的方法和匿名内部类，在内部类中重写抽象方法，从而实现不同的类的点击动作不同
     */
    public abstract Controller03 click();

}


----------


/*
 * 输出结果
 * off
 * on
 * */

通过将该类声明成抽象类，其中定义抽象的按下按钮的方法，在类的内部就可以创建实现自己相应的按下动作的匿名内部类。很好的体现了匿名内部类的使用。

下面才是本文的主角，通过枚举，很方便的实现这样的集合。

package hong.study._enum;
/**
 * 枚举实现按钮
 * @author Hong
 *
 */
public class Study05 {
    public static void main(String[] args) {
        Controller05 off = Controller05.ON.click();
        System.out.println(off);
        Controller05 on = Controller05.OFF.click();
        System.out.println(on);
    }
}

enum Controller05{
    ON{@Override
    public Controller05 click() {
        // TODO Auto-generated method stub
        return OFF;
    }}, 
    OFF{@Override
    public Controller05 click() {
        // TODO Auto-generated method stub
        return ON;
    }};

    private Controller05(){}

    public abstract Controller05 click();
}

/**
 * 运行结果：
    OFF
    ON
 * */

下面给出另外一个枚举的小例子：

package hong.study._enum;
/**
 * 枚举中的常量都是枚举对象，枚举本身的构造器都必须是私有的
 * 枚举的构造器可以是带参数的，形式如Boy中所示
 * 调用枚举中的常量的过程，首先要初始化枚举，也就是加载枚举的过程
 *  调用枚举的构造器，枚举中有几个对象，就需要调用构造器几次
 *  可以根据具体情况调用无参还是有参构造器
 * @author Hong
 *
 */
public class Study04 {
    public static void main(String[] args) {
        Girl g1 = Girl.Gril1;
        System.out.println(g1.getName());
        Boy b1 = Boy.Boy1;
        System.out.println(b1.getName());
    }
}

enum Girl{
    Gril1, Girl2, Gril3, Gril4;

    private String name;
    private Girl(){
        System.out.println("无参构造器");
    }
    private Girl(String name){
        this.name = name;
        System.out.println("有参构造器");
    }

    public String getName(){
        return name;
    }
}
enum Boy{
    Boy1("b1"), Boy2("b2"), Boy3("b3"), Boy4("b4");

    private String name;
    private Boy(){
        System.out.println("无参构造器");
    }
    private Boy(String name){
        this.name = name;
        System.out.println("有参构造器");
    }

    public String getName(){
        return name;
    }
}

/*
 * 输出结果：
    无参构造器
    无参构造器
    无参构造器
    无参构造器
    null
    有参构造器
    有参构造器
    有参构造器
    有参构造器
    b1
 */