Java学习笔记——枚举Enum

本人学习枚举的小小总结吧。
关键词enum是JDK5新引入的一个特性。枚举对于开发提供了很多的便利。
首先看一下什么是枚举吧，在Java编程思想中定义，关键词enum可以将一组具名的值的有限集合创造为一种新的类型。
个人理解，枚举就是已经实例化了有限个的类，并且可以定义类的数据和行为。
与普通类的区别，枚举无法继承其他类，因为已经继承Enum类，同样也可以实现多个接口，在枚举类中可以声明抽象方法，也可以声明实例方法，类方法。
先看一个最简单的实例吧

public enum Number {
    ONE,
    TWO,
    THREE,
    FOUR,
    FIVE,
    SIX,
    SEVEN,
    EIGHT,
    NINE,
    TEN;
}

这个枚举类的定义什么意思，可以理解为有一个Number的类，并且实例化了ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN等是个实例对象。可以通过values()方法得到一个Number枚举类的数组。

        Number[] numbers = Number.values();
        for(Number number:numbers){
            System.out.println(number);
        }

运行结果是：

ONE
TWO
THREE
FOUR
FIVE
SIX
SEVEN
EIGHT
NINE
TEN

用关键词enum声明的类，默认是继承了Enum类的，父类Enum中有toString（）方法，所以打印出来的是实例的名字。

好了，我们尝试Number类增加一个构造器吧

public enum Number {
    ONE(1),
    TWO(2),
    THREE(3),
    FOUR(4),
    FIVE(5),
    SIX(6),
    SEVEN(7),
    EIGHT(8),
    NINE(9),
    TEN(10);

    final private int value;

    Number(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

这个例子中的话，在实际开发中是经常会用到的。以前我们通常是定义一个常量类来定义的。

public class NumberConstant {

    public static int ONE = 1;
    public static int TWO = 2;
    public static int THREE = 3;
    public static int FOUR = 4;
    public static int FIVE = 5;
    public static int SIX = 6;
    public static int SEVEN = 7;
    public static int EIGHT = 8;
    public static int NINE = 9;
    public static int TEN = 10;

}

在《Effective Java》一书中提到，上面类的int枚举是编译时常量，被编译到使用它们的客户端。如果与枚举常量关联的int发生了变化，客户端必须重新编译，而Java枚举类型则不需要。

好了，构造器有了，那为Java枚举类添加一个普通的实例方法吧，其实上面的getValue()就是一个普通的实例方法了。比较简单，可以这样子直接调用。

System.out.println(Number.ONE.getValue());

好了，接下来为Number类增加一个抽象方法吧

package com.example.myenum;

public enum Number {
    ONE(1){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    TWO(2){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    THREE(3){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    FOUR(4){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    FIVE(5){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    SIX(6){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    SEVEN(7){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    EIGHT(8){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    NINE(9){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    TEN(10){
        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    };

    final private int value;

    Number(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    abstract public void print();

当然，出来定义抽象方法之外，也可以去实现一个接口

package com.example.myenum;

public enum Number implements INumber{
    ONE(1){
        @Override
        public int plus() {
            return this.getValue()+this.getValue();
        }

        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    TWO(2){
        @Override
        public int plus() {
            return this.getValue()+this.getValue();
        }

        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    },
    THREE(3){
        @Override
        public int plus() {
            return this.getValue()+this.getValue();
        }

        @Override
        public void print() {
            System.out.println(this.getValue());
        }
    };
   ;

    final private int value;

    Number(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    abstract public void print();
}

Java枚举类型经常用于定义常量。
下面实现一个简单的加减乘除
最简单的实现方法

public class Calculator {
    public static void main(String[] args) {
        System.out.println(cal(1.5,3.5,'+'));
        //System.out.println(CalculatorEnum.PLUS.cal(1.5,3.5));
    }

    public static double cal(double x,double y,char c){
        switch (c){
            case '+':
                return x+y;

            case '-':
                return x-y;

            case '*':
                return x*y;

            case '/':
                return x/y;

            default:
                throw new ArithmeticException("异常");

        }
    }
}

再来看看用枚举来实现

package com.example.myenum;

public enum  CalculatorEnum {
    PLUS{
        @Override
        public double cal(double x,double y) {
            return x+y;
        }
    },
    MINUS{
        @Override
        public double cal(double x,double y) {
            return x-y;
        }
    },
    MULTI{
        @Override
        public double cal(double x,double y) {
            return x*y;
        }
    },
    DEVILE{
        @Override
        public double cal(double x,double y) {
            return x/y;
        }
    };
    abstract public double cal(double x,double y);
}

是不是感觉很优雅呀。
今天先这样子吧。