《onjava进阶卷》01枚举类型10常量特定方法

10、常量特定方法

Java枚举机制可以通过为每个枚举实例编写不同的方法，来赋予它们不同的行为。通过关联的枚举实例来查找和调用方法，通常叫作表驱动模式。

public enum ConstantSpecificMethod {  
    DATE_TIME {  
        @Override  
        String getInfo() {  
            return DateFormat.getDateInstance().format(new Date());  
        }  
    },  
    CLASSPATH {  
        @Override  
        String getInfo() {  
            return System.getenv("CLASSPATH");  
        }  
    },  
    VERSION {  
        @Override  
        String getInfo() {  
            return System.getProperty("java.version");  
        }  
    };  
  
    abstract String getInfo();  
  
    public static void main(String[] args) {  
        for (ConstantSpecificMethod csm : values()) {  
            System.out.println(csm.getInfo());  
        }  
    }  
}

10.1 用枚举实现职责链模型

职责链设计模式先创建了一批用于解决目标问题的不同方法，然后将它们连成一条链。

class Mail {  
    enum GeneralDelivery {YES, NO1, NO2, NO3, NO4, NO5}  
  
    enum Scannability {UNSCANNABLE, YES1, YES2, YES3, YES4}  
  
    enum Readability {ILLEGIBLE, YES1, YES2, YES3, YES4}  
  
    enum Address {INCORRECT, OK1, OK2, OK3, OK4, OK5, OK6}  
  
    enum ReturnAddress {MISSING, OK1, OK2, OK3, OK4, OK5}  
  
    GeneralDelivery generalDelivery;  
    Scannability scannability;  
    Readability readability;  
    Address address;  
    ReturnAddress returnAddress;  
    static long counter = 0;  
    long id = counter++;  
  
    @Override  
    public String toString() {  
        return "Mail " + id;  
    }  
  
    public String details() {  
        return toString() + ", General Delivery: " + generalDelivery +  
                ", Address Scannability: " + scannability +  
                ", Address Readability: " + readability +  
                ", Address Address: " + address +  
                ", Return address: " + returnAddress;  
    }  
  
    public static Mail randomMail() {  
        Mail m = new Mail();  
        m.generalDelivery = Enums.random(GeneralDelivery.class);  
        m.scannability = Enums.random(Scannability.class);  
        m.readability = Enums.random(Readability.class);  
        m.address = Enums.random(Address.class);  
        m.returnAddress = Enums.random(ReturnAddress.class);  
        return m;  
    }  
  
    public static Iterable<Mail> generator(final int count) {  
        return new Iterable<Mail>() {  
            int n = count;  
  
            @Override  
            public Iterator<Mail> iterator() {  
                return new Iterator<Mail>() {  
  
                    @Override  
                    public boolean hasNext() {  
                        return n-- > 0;  
                    }  
  
                    @Override  
                    public Mail next() {  
                        return randomMail();  
                    }  
  
                    @Override  
                    public void remove() {  
                        throw new UnsupportedOperationException();  
                    }  
                };  
            }  
        };  
    }  
}  
  
public class PostOffice {  
    enum MailHandler {  
        GENERAL_DELIVERY {  
            @Override  
            boolean handle(Mail m) {  
                switch (m.generalDelivery) {  
                    case YES:  
                        System.out.println("Using general delivery for " + m);  
                        return true;  
                    default:  
                        return false;  
                }  
            }  
        },  
        MACHINE_SCAN {  
            @Override  
            boolean handle(Mail m) {  
                switch (m.scannability) {  
                    case UNSCANNABLE:  
                        return false;  
                    default:  
                        switch (m.address) {  
                            case INCORRECT:  
                                return false;  
                            default:  
                                System.out.println("Delivering " + m + " automatically");  
                                return true;  
                        }  
                }  
            }  
        },  
        VISUAL_INSPECTION {  
            @Override  
            boolean handle(Mail m) {  
                switch (m.readability) {  
                    case ILLEGIBLE:  
                        return false;  
                    default:  
                        switch (m.address) {  
                            case INCORRECT:  
                                return false;  
                            default:  
                                System.out.println("Delivering " + m + " normally");  
                                return true;  
                        }  
                }  
            }  
        },  
        RETURN_TO_SENDER {  
            @Override  
            boolean handle(Mail m) {  
                switch (m.returnAddress) {  
                    case MISSING:  
                        return false;  
                    default:  
                        System.out.println("Returning " + m + " to sender");  
                        return true;  
                }  
            }  
        };  
  
        abstract boolean handle(Mail m);  
    }  
  
    static void handle(Mail m) {  
        for (MailHandler handler : MailHandler.values()) {  
            if (handler.handle(m)) {  
                return;  
            }  
            System.out.println(m + " is a dead letter");  
        }  
    }  
  
    public static void main(String[] args) {  
        for (Mail mail : Mail.generator(10)) {  
            System.out.println(mail.details());  
            handle(mail);  
            System.out.println("******");  
        }  
    }  
}