Effective Java 第二版 Enum

/** * Effective Java 第二版 *   第30条:用enum代替int常量  */

import java.util.HashMap;import java.util.Map;

public class EnumTest {

    /*媒体操作*/    public final static int START = 1;    public final static int PAUSE = 2;    public final static int RESUME = 3;    public final static int STOP = 4;

    /*返回结果*/    public final static int RET_OK = 1;

    private static int playWithInt(int fun)    {        switch (fun)        {            case START:            case PAUSE:            case RESUME:            case STOP:                System.out.println("playWithInt do " + fun);                break;            default:        }        return RET_OK;    }

    public enum PlayEm    {        START,PAUSE,RESUME,STOP //命名空间使得他可以重名    }

    private static void playWithEnum(PlayEm fun)    {        switch (fun)        {            case START:            case PAUSE:            case RESUME:            case STOP:                System.out.println("playWithEnum do " + fun);                break;            default:

        }    }

    public enum SuperPlayEm    {        START(1,"START"),PAUSE(2,"PAUSE"),RESUME(3,"RESUME"),STOP(4,"STOP");

        private final int code;        private final String name;

        SuperPlayEm(int code, String name) {            this.code = code;            this.name = name;        }

        @Override        public String toString() {            return "SuperPlayEm{" +                    "code=" + code +                    ", name=‘" + name + ‘\‘‘ +                    ‘}‘;        }

        public void doPlay(String player)        {            switch (this)            {                case START:                case PAUSE:                case RESUME:                case STOP:                    System.out.println("player : "+ player + " exec " + this.name());                    break;                default:            }

        }    }

    private static void playWithSuperEnum(SuperPlayEm fun)    {        switch (fun)        {            case START:            case PAUSE:            case RESUME:            case STOP:            default:                System.out.println("playWithSuperEnum do " + fun);        }    }

    public enum SuperPlayApplyEm    {        START(1,"START"){void doPlay(String player){System.out.println("player : "+ player + " exec START" );}},        PAUSE(2,"PAUSE"){void doPlay(String player){System.out.println("player : "+ player + " exec PAUSE" );}},        RESUME(3,"RESUME"){void doPlay(String player){System.out.println("player : "+ player + " exec RESUME" );}},        STOP(4,"STOP"){void doPlay(String player){System.out.println("player : "+ player + " exec STOP" );}};

        private final int code;        private final String name;

        SuperPlayApplyEm(int code, String name) {            this.code = code;            this.name = name;        }

        @Override        public String toString() {            return "SuperPlayEm{" +                    "code=" + code +                    ", name=‘" + name + ‘\‘‘ +                    ‘}‘;        }

        abstract void doPlay(String player);    }

    public enum MixEnum    {        START("400100","1001"),        PAUSE("400100","1002"),        RESUME("400100","1003"),        STOP("400100","1004")        ;        private final String baseCode;        private final String followCode;

        private static final Map<String,MixEnum> map = new HashMap<String,MixEnum>();

        static {            for (MixEnum mixEnum : MixEnum.values()) {                map.put(mixEnum.baseCode+mixEnum.followCode,mixEnum);            }        }

        MixEnum(String baseCode, String followCode) {            this.baseCode = baseCode;            this.followCode = followCode;

        }

        public static MixEnum fromCode(String code)        {            return map.get(code);        }    }

    public static void main(String[] args) {    /*P128-P134*/
        //传统C做法        playWithInt(START);  //打印无法识别        playWithInt(RET_OK); //编译器不能报错

        //普通java枚举        playWithEnum(PlayEm.START);//        playWithEnum(RET_OK);

        /**         * 自定义java枚举         */        SuperPlayEm aaa = SuperPlayEm.START;        playWithSuperEnum(aaa);

        /**         * 打印所有枚举信息         * 如果有人要一份接口文档时,是不是会很好用         */        for (SuperPlayEm superPlayEm : SuperPlayEm.values()) {            System.out.println(superPlayEm);        }

        /**         * 这个枚举可以做的很强大,给他设置很多参数,也可以定义函数         * 但这样做可能在加一个枚举的时候,忘记加case分支         */        aaa.doPlay("camera");        /**         * 防止忘记加case         * 但这样导致代码变多,各有利弊吧。         */        SuperPlayApplyEm superPlayApplyEm = SuperPlayApplyEm.PAUSE;        superPlayApplyEm.doPlay("camera");

        /**         * 生成枚举的方法 1  valueOf         */        SuperPlayEm superPlayEm = SuperPlayEm.valueOf("START");        System.out.println(superPlayEm);

        /**         * 生成枚举的方法 2   自定义         *         */        MixEnum mixEnum = MixEnum.fromCode("4001001002");        System.out.println(mixEnum);    }

}

原文地址:https://www.cnblogs.com/aoyihuashao/p/9053959.html

时间: 2024-08-06 18:13:15

Effective Java 第二版 Enum的相关文章

《Effective Java 第二版》学习笔记 第13条 使类和成员的可访问性最小化

第四章 类和接口 第13条 使类和成员的可访问性最小化 1.设计良好的模块会隐藏所有的实现细节,把它的API与实现清晰的隔离开来,模块之间只通过它们的API进行通信,一个模块不需要知道其他模块的内部工作情况:即信息隐藏或封装,是软件设计的基本原则之一. 2.Java提供了许多机制来协助信息隐藏.访问控制(access control)机制决定了类.接口和成员的可访问性(accessibility). 3.第一规则:尽可能地使每个类或者成员不被外界访问.或者说在保证功能的情况下,使用最小的访问级别

[Effective Java]第二章 创建和销毁对象

第一章      前言 略... 第二章      创建和销毁对象 1.            考虑用静态工厂方法代替构造器 创建对象方法:一是最常用的公有构造器,二是静态工厂方法.下面是一个Boolean的简单示例: public static Boolean valueOf(boolean b) { return (b ? Boolean.TRUE : Boolean.FALSE); } l  静态工厂方法与构造器不同的第一大优势在于,它们有名称. 作用不同的公有构造器只能通过参数来区别(因

Effective java 第二章创建和销毁对象 读书笔记

建和销毁对象 一般有两种方式,一种是获得本身的实例,最常用的方法就是提供一个共有的构造器.第二个方法是,类可以提供一个共有的静态工厂方法. 静态工厂方法与构造器不同的三大优势: 有名字: 调用时不用创建新的对象: 返回原来类型的任何子类型对象. 第四大优势: 在创建参数化类型实例的时候,它们使代码变得更加简洁. 服务提供者框架 三个组件: 服务接口 提供者主持API 服务访问API 可选: 服务提供者接口 静态工厂方法的缺点: 类如果不含共有的或者受保护的构造器,就不能被子类化: 它们与其他的静

[读书笔记]Effective Java 第二章

考虑用静态工厂方法代替构造器 静态工厂方法第一大优势是可以用特有的名称.常见的类创建实例需要用构造函数,而当需要两个构造函数时,我们需要在参数列表做区分才能写出两个构造方法.使用静态工厂模式,可以规避方法名=类名的限制,使用更易读的方法呈现. 静态工厂方法第二大优势是不必在每次调用的时候创建一个新的实例.这点和单例设计模式有些类似,在使用不可变类的时候可以预先构建实例并缓存,之后可以重复利用,避免创建不必要的重复对象,也可以用静态工厂保证这是一个单例.可以确保不会存在两个相等的实例,即当且仅当a

effective java——30使用enum

1, 枚举太阳系八大行星 package com.enum30.www; public enum Planet {//枚举太阳系八大行星 MERCURY(3.302e+23,2.439e6), VENUS(4.8e+24,6.0e6), EARTH(5.9e+24,6.3e6); private final double mass; //kilogram private final double radius; //meters private final double surfaceGravi

Effective java 第二章 对象 (2)

不要创建不必要的对象 一.一些对象创建后不会在更改,可重复使用的对象不比在重新创建. 二.能使用基本类型计算而尽量使用基本类型,包装类型在效率上比基本类型要低  比如: public static void main(String[] args) { Long i=0L; //long i=0L; for(int j=0;j<1000000;j++){ i+=1; } 循环一百万次    Long 类型  时间差  32      long 类型  时间差  7     原因是 ,使用Long类

Effective java 第二章 对象 (1)

这章主要说了对象的 创建和销毁,怎样避免无谓,过多的对象,以及创建对象的几个方法  一.使用静态工厂方法代替构造器, 正常的创建类的方法    OneObject  oneObject=new OneObject();       这样写的话,每次都会创建一个新的对象 静态工厂方法             public class OneObject { private static OneObject oneObject=new OneObject(); private String name

《Effective Java 第三版》新条目介绍

前言 从去年的3月份起我就在开始读<Effective Java 第二版>,当然,我读的是中文版的:可能是我理解能力还不行,对于书中的内容总是感觉理解困难:就拿第一章的内容「创建和销毁对象」来说吧,这是我读的次数最多的一章,想必原因大家也是明白的,每次我读不下去的时候,我就从头开始读,所以,现在我对这本书的第一章是最为熟悉的了.后来,有一次我上网看到有网友说这本书确实和绝大部分的翻译书籍一样,对于有些原文中的内容翻译的不是很流畅,所以会导致阅读的人感觉难以理解:于是,我就斗胆下了本英文的原版来

Effective Java 学习笔记之第七条——避免使用终结(finalizer)方法

避免使用终结方法(finalizer) 终结方法(finalizer)通常是不可预测的,也是很危险的,一般情况下是不必要的. 不要把finalizer当成C++中析构函数的对应物.java中,当对象不可达时(即没有引用指向这个对象时),会由垃圾回收器来回收与该对象相关联的内存资源:而其他的内存资源,则一般由try-finally代码块来完成类似的工作. 一.finalizer的缺点: 1. 终结方法的缺点在于不能保证会被及时地执行. 及时执行finalizer方法是JVM垃圾回收方法的一个主要功