枚举

　　学了一段时间Java，总结一下到目前为止学到的枚举用法：

1）可以定义在包中、类中，但不能定义在方法中
2）枚举类型不能被继承
3）枚举类型默认继承java.lang.Enum
4）枚举类型的每个取值都是自己的一个实例对象
5）枚举类型可以有属性、方法、构造器
6）枚举类型可以实现接口
7）枚举类型有静态方法values()获取所有取值

package com.wsy.enumtest;
//enum在switch中的应用
//JDK1.5及之后的switch语句可以支持enum类型，使用枚举，能让我们的代码可读性更强。
enum Signal {
    GREEN, YELLOW, RED
}

public class TrafficLight {
    Signal color = Signal.GREEN;

    public void change() {
        switch (color) {
        case RED:
            color = Signal.GREEN;
            System.out.println(color);
            break;
        case YELLOW:
            color = Signal.RED;
            System.out.println(color);
            break;
        case GREEN:
            color = Signal.YELLOW;
            System.out.println(color);
            break;
        }
    }
    
    public static void main(String[] args) {
        TrafficLight trafficLight = new TrafficLight();
        trafficLight.change();
    }
}

package com.wsy.enumtest;
//enum实现接口
//所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。但可以实现接口。
//在JDK1.5 之前，我们定义常量都是： public static final…… .现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。
//例如：enum Color { RED， GREEN， BLANK， YELLOW }
interface Behaviour {
    void print();

    String getInfo();
}

public enum Color implements Behaviour {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;

    // 构造方法
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }

    // 接口方法
    @Override
    public String getInfo() {
        return this.name;
    }

    // 接口方法
    @Override
    public void print() {
        System.out.println(this.index + ":" + this.name);
    }

    // 覆盖方法
    @Override
    public String toString() {
        return this.index + "_" + this.name;
    }

    public static void main(String[] args) {
        RED.print();
        System.out.println(RED.getInfo());
        System.out.println(RED);
    }
}

　　以下是用枚举做的随机发牌的一个小程序（因为牌的花色固定，大小固定，适合用枚举， 注：没有大小王）：

package com.wsy.enumtest;

import java.util.ArrayList;
import java.util.List;

public class Card {
    public enum Rank{
        DEUCE,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,TEN,JACK,QUEEN,KING,ACE
    }
    public enum Suit{
        CLUBS,DIAMONDS,HEARTS,SPADES
    }
    
    private final Rank rank;
    private final Suit suit;
    private Card(Rank rank , Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }
    
    public Rank rank() {
        return rank;
    }
    
    public Suit suit() {
        return suit;
    }
    
    public String toString() {
        return rank + "of" + suit;
    }
    
    private static final List<Card> protoDeck = new ArrayList<Card>();
    
    static {
        for(Suit suit : Suit.values()) {
            for(Rank rank : Rank.values()) {
                protoDeck.add((new Card(rank , suit)));
                }
            }
    }
    
    public static ArrayList<Card> newDeck() {
        return new ArrayList<Card>(protoDeck);
    }
}


package com.wsy.enumtest;


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Deal {
    public static void main(String[] args) {
        if(args.length != 2) {
            System.out.println("Usage:java" + Deal.class.getName() + "numHands cardPerHand");
            System.exit(1);
        }
        
        int numHands = Integer.parseInt(args[0]);
        int cardsPerHand = Integer.parseInt(args[1]);
        List<Card> deck = Card.newDeck();
        Collections.shuffle(deck);
        for(int i = 0; i < numHands; i++) {
            System.out.println(deal(deck , cardsPerHand));
        }
    }
    public static ArrayList<Card> deal(List<Card> deck , int n){
        int deckSize = deck.size();
        List<Card> handView = deck.subList(deckSize-n , deckSize);
        ArrayList<Card> hand = new ArrayList<Card> (handView);
        handView.clear();
        return hand;
    }
}

 EnumSet集合辅助使用enum类型：allOf()/range()/of()...

public enum Grade {
    A , B , C , D
}

import java.util.EnumSet;

public class EnumSetTest {
    public static void outEnumSet(EnumSet es) {
        for (Object o : es) {
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        //打印枚举中所有取值
        EnumSet es = EnumSet.allOf(Grade.class);
        outEnumSet(es);
        System.out.println("************");
        //打印枚举中的A到C
        es = EnumSet.range(Grade.A, Grade.C);
        outEnumSet(es);
        System.out.println("************");
        //打印枚举中的B和D
        es = EnumSet.of(Grade.B,Grade.D);
        outEnumSet(es);
        System.out.println("************");
        //输出枚举中的所有取值
        Grade[] grades = Grade.values();
        for(Object o : grades){
            System.out.println(o);
        }
    }
}

结果：
A
B
C
D
************
A
B
C
************
B
D
************
A
B
C
D

EnumMap集合辅助使用enum类型：

public enum Grade {
    A , B , C , D
}

import java.util.EnumMap;
import java.util.Map;

public class EnumMapTest {
    public static void main(String[] args) {
        EnumMap<Grade, String> em = new EnumMap<Grade, String>(Grade.class);
        em.put(Grade.A, "Excellent");
        em.put(Grade.B, "Good");
        em.put(Grade.C, "Passed");
        em.put(Grade.D, "Fail");

        for (Object o : em.entrySet()) {
            Map.Entry entry = (Map.Entry) o;
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }
}

结果：
A:Excellent
B:Good
C:Passed
D:Fail