linkin大话面向对象--枚举

• 枚举类(enum)

其实我们使用到枚举的地方还是很多的，其实我们可以完全人工的来实现枚举的功能。比如说我现在手里的项目我就是自己实现的枚举，说白了，枚举就是一个类的多例模式。

1，使用enum声明,默认直接继承了java.lang.Enum类，而不是Object类；

2，枚举类的对象是固定的,实例个数有限,枚举对象后可以跟()；跟着（）的意思就是在调用相关的构造器，要是不写的话就是在调用默认的构造器。

3，枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔；

4，枚举类的构造方法的权限修饰符默认是private；自己在定义枚举类的时候也要限定修饰符为private的。

5，一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象；一般在传入这个匿名内部类的时候都要实现里面的抽象方法。

6，下面这2个ipa比较重要：所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组)，便于遍历所有枚举对象；
所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。

/**
 *
 * @version 1L
 * @author  LinkinPark
 * @since   2014-11-2
 * @motto   梦似烟花心似水，同学少年不言情
 * @desc    ^使用enum定义，非抽象的枚举类默认会使用final修饰，因此枚举类不能派生子类
 */
public enum SeasonEnum {

    //在这里要列出4个枚举实例
    //注意了：枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举永远不能产生实例
    SPRING,SUMMER,FALL,WINTER;//默认添加 public static final

    //枚举类的构造器还能使用private访问控制符，默认也是使用private修饰的构造器
    private SeasonEnum(){

    }

    public static void test(SeasonEnum s){
        switch(s){
            case SPRING:
                System.out.println("春天。。。");
                break;
            case SUMMER:
                System.out.println("夏天。。。");
                break;
            case FALL:
                System.out.println("秋天。。。");
                break;
            case WINTER:
                System.out.println("冬天。。。");
                break;
        }
    }

    public static void main(String[] args) {
        for(SeasonEnum s:SeasonEnum.values()){
           System.out.println(s);
        }

        SeasonEnum.test(SeasonEnum.SPRING);
    }

}

• Java5开始出现枚举:

<1>.私有的构造方法

<2>.每个元素分别用一个公有的静态成员变量表示，枚举类的对象是固定的，实例个数有限。

<3>.枚举的直接父类java.lang.Enum；

<4>.枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

<5>.枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。

<6>.把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

<7>.枚举只有一个成员时，就可以作为一种单例的实现方式。

<8>.枚举元素有大括号对时，此时属性是枚举类的匿名内部类对象。(查看编译后的class文件)

<9>.所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组)，便于遍历所有枚举对象；

<10>.Enum常见方法：

String name();// 返回枚举实例名称;

int ordinal();// 返回枚举实例在枚举类中的索引,从0开始;

String toString();// 返回枚举对象的"自我描述";(看源代码)

<11>.在switch语句中使用枚举对象；

<12>.枚举类的构造方法；

<13>.枚举类覆写接口抽象方法的两种方式:

a.在枚举类中实现接口抽象方法；

b.在枚举匿名内部类对象中实现接口抽象方法；

public enum Gender {

    MALE("男","这里是男的"),FEMALE("女","这里是女的");

    //其实也可以不用枚举的 ，定义一个抽象类继承Enum,之后再继承这个抽象类，定义2个方法分别来获得下面的2个属性
    //public static final Gender MALE = new Gender("男","这里是男的");

    private final String name;

    private final String lable;

    private Gender(String name,String lable){
        this.name = name;
        this.lable = lable;
    }

    public String getName(){
        return this.name;
    }

    public String getLable(){
        return this.lable;
    }

    //可以到的上面构造器中传入的2个字符串的
    public static void main(String[] args) {
        System.out.println(Gender.MALE.getName());
        System.out.println(Gender.MALE.getLable());
    }

}

• 枚举类实现接口

枚举类覆写接口抽象方法的两种方式：

1，在枚举类中实现接口的抽象方法；

2，在枚举匿名内部类中实现接口的抽象方法；

//实现接口的枚举
public enum Linkin implements GenderDesc{

    MALE("男"),FEMALE("女");
    private String name;

    @Override
    public void show() {
        System.out.println("这里是一个用于定义性别属性的方法。。。");
    }

    private Linkin(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

}

interface GenderDesc{
    void show();
}

<pre name="code" class="java">//实现接口的枚举
//让每个枚举类在调用方法时呈现出不同的行为方式
public enum Linkin implements GenderDesc{

//MALE FEMALE 实际上是Linkin匿名子类的实例

    MALE("男"){
        public void show() {
            System.out.println("这里创建的是男的实例。。。");
        }
    },FEMALE("女"){
        public void show() {
            System.out.println("这里创建的是女的实例。。。");
        }
    };
    private String name;

    private Linkin(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

}

interface GenderDesc{
    void show();
}

• 包含抽象方法的枚举类

public enum Linkin{
    PLUS{
        public double eval(double x,double y){
            return x+y;
        }
    },
    MINUS{
        public double eval(double x,double y){
            return x-y;
        }
    },
    TIMES{
        public double eval(double x,double y){
            return x*y;
        }
    },
    DIVIDE{
        public double eval(double x,double y){
            return x/y;
        }
    };

    abstract public double eval(double x,double y);

    public static void main(String[] args) {
        System.out.println(Linkin.PLUS.eval(1, 1));
        System.out.println(Linkin.MINUS.eval(1, 1));
        System.out.println(Linkin.TIMES.eval(1, 1));
        System.out.println(Linkin.DIVIDE.eval(1, 1));
    }
}

• 枚举类的单例模式

使用枚举类来实现单例模式的好处是这样非常简洁，并且无偿地提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。

——来自《Effective Java》(作者：Josh Bloch)

enum Singleton {
	INSTANCE;//唯一实例

	public void print(){
		System.out.println("使用enum实现单例模式");
	}
	public static Singleton getInstance(){
		return INSTANCE;
	}
}