众所周知，系统里有很多比如订单状态、审核状态；性别、结算方式、交易类型等属性，这些属性只有几个值，一般用0、1、2、3等的数字标识存入数据库，每次对这些属性所属对象的增删改操作，都会在代码里给状态设置值，由于项目是多人开发的，如果每次设置值的时候都直接set 0、1、2，容易出错，而且状态假设不用0、1、2表示了，用1、2、3表示，这时候所有set状态的地方都得改变，维护麻烦。所以用常量表示状态值，甚好。
据我目前所知，系统里实现常量的方式有三种：
1，& 接口常量
2，& 类常量
一：接口常量
Java程序里实现常量,jdk1.5之前,没有枚举类,有的用的接口来实现系统中的常量:
如java的swing里有一个SwingConstant:
public interface SwingConstants {
* The central position in an area. Used for
* both compass-direction constants (NORTH, etc.)
* and box-orientation constants (TOP, etc.).
public static final int CENTER
// Box-orientation constant used to specify locations in a box.
* Box-orientation constant used to specify the top of a box.
public static final int TOP
* Box-orientation constant used to specify the left side of a box.
public static final int LEFT
//。。。省略其他代码
接口常量，写起来方便，看着简洁，但是为了让其他人知道每个常量的含义，必须写注释，如果需要在用到常量对应的信息时候，需要看着注释来写。
如：在其他地方需要用到 SwingConstants.CENTER 的含义，必须看类里的注释，知道他表示中心。如果常量很多的话，把所有的常量都放在这一个接口里边，这种方式感觉也不是很友好。
（申哥，瑞友的架构师，我的老乡、偶像）看了申哥以前的项目，发现一个常量类，也是接口常量类，在接口里定义静态内部类，但是比上边这种要好，他可以把不同的功能的常量类进一步分类，看代码：
public interface UtilConstants {
* 公共常量
public static class Public {
public static final String ID = "TESTID";
public static class JspFilePath {
public static final String TESTCONTROLLER = "jsp/basic/";
public static final String TEMPLATE_PAGEPATH = "basic/template/"; // 模板（测试）
* vo 对象的一些公共的属性名称
public static class VoFields {
public static final String ACTIONTIME = "operateTime";//操作时间
public static final String ACTIONUSERNAME = "operatorName";//操作人姓名
public static final String CHECKTIME = "auditTime";//审核时间
public static final String CHECKUSERID = "checkUserId";//审核人ID
public static final String CHECKUSERNAME = "auditPerson";//审核人姓名
public static final String CREATETIME = "createTime";
// 创建时间
public static final String CREATEUSERID = "createUserId";// 创建人code
public static final String INSERTUSERNAME = "createUserName";// 创建人姓名
public static final String UPDATETIME = "updateTime";
// 修改时间
public static final String UPDATEUSERID = "updateUserId";// 修改人CODE
public static final String UPDATEUSERNAME = "updateUserName";// 修改人姓名
public static final String DELFLAG = "delFlag";
// 删除标记
public static final String DBID = "dbid";
使用，把不同功能的常量放在了接口的内部类里，通过不同的内部类，调用的时候可以更明确好找吧。
UtilConstants.JspFilePath.TEMPLATE_PAGEPATH
UtilConstants.VoFields.CHECKTIME
二：类常量
目前中彩网的项目是这样做的，还有过完年去待过4天的蛋疼学院的代码，也是这么做的，虽然有了枚举，可能是由于设计者习惯问题，还有很多人用的类常量，
定义了类常量，用一个Map&Integer, String&来封装常量对应的信息，在static代码块里，类初始化的时候执行一次put。用的时候
ResponseCode.RESP_INFO.get("DATABASE_EXCEPTION");就能取出响应信息
由于项目是前后端分离，在接口文档里需要写上状态码，还得写上状态码对应的提示信息，而且我们的响应类 RespInfo 有message属性，就是保存常量类里状态码对应的信息的。
public class ResponseCode {
/** 系统处理正常 */
public static final int SUCCESS_HEAD = 0;
/** 系统处理未知异常 */
public static final int EXCEPTION_HEAD = 1;
/** JSON解析错误 */
public static final int JSON_RESOLVE = 2;
/** 类型不匹配 */
public static final int TRANSTYPE_NO = 3;
/** Head - messageID未赋值 */
public static final int HEAD_messageID = 4;
/** Head - timeStamp未赋值 */
public static final int HEAD_timeStamp = 5;
/** Head - messengerID未赋值 */
public static final int HEAD_messengerID = 6;
/** Head - transactionType 未赋值 */
public static final int HEAD_transactionType = 7;
/** digest校验不通过 */
public static final int HEAD_DIGEST = 8;
/** src校验不通过 */
public static final int HEAD_SRC_NULL = 10;
/** 协议包含非法字符 */
public static final int ILLEGAL_MESSAGE = 11;
/** 数据库异常 */
public static final int DATABASE_EXCEPTION = 9;
public static final Map&Integer, String& RESP_INFO = new HashMap&Integer, String&();
// Head 相关
RESP_INFO.put(SUCCESS_HEAD, "系统处理正常");
RESP_INFO.put(EXCEPTION_HEAD, "系统处理未知异常");
RESP_INFO.put(JSON_RESOLVE, "JSON解析错误");
RESP_INFO.put(TRANSTYPE_NO, "类型不匹配");
RESP_INFO.put(HEAD_messageID, "messageID未赋值");
RESP_INFO.put(HEAD_timeStamp, "timeStamp未赋值");
RESP_INFO.put(HEAD_messengerID, "messengerID未赋值");
RESP_INFO.put(HEAD_transactionType, "transactionType未赋值");
RESP_INFO.put(HEAD_DIGEST, "digest校验不通过");
RESP_INFO.put(DATABASE_EXCEPTION, "数据库异常");
RESP_INFO.put(HEAD_SRC_NULL, "src未赋值");
RESP_INFO.put(ILLEGAL_MESSAGE, "协议包含非法字符");
这种类常量比接口常量好，因为可以定义状态码对应的提示信息。
所有的枚举类都是Enum类的子类,就行Object类一样，只是没有写出来，所以可以枚举类可调用Enum的方法。注意是逗号分隔属性，只有属性后边没有方法的话，最后加不加分号都行
public enum Season {
SPRING,SUMMER,AUTUMN ,WINTER
使用:可以直接使用属性，也可以调用Enum的方法如values方法
System.out.println(Season.AUTUMN);
System.out.println(Season.values());
Season[] values = Season.values();
System.out.println(values[0]);
可以在枚举类中添加一些构造器、方法和域：
私有化构造器，构造器只是在构造枚举常量的时候被调用如SMALL(&S&)
* 衣服尺寸
public enum Size {
SMALL("S"),
MEDIUM("M"),
LARGE("L"),
EXTRA_LARGE("XL");
private Size(String suoxie){
this.suoxie =
public String getSuoxie(){
public static void main(String[] args) {
//1:toString()方法返回常量的名
System.out.println(Size.SMALL.toString());//SMALL
//2:valueOf()
System.out.println(Size.valueOf("LARGE"));
//3:values:返回每个常量名
//SMALL MEDIUM LARGE EXTRA_LARGE
Size[] sizes = Size.values();
/*for (Size size : sizes) {
System.out.println(size);
//4:ordinal 返回常量的位置，从0开始
System.out.println(Size.LARGE.ordinal());
int i = Size.pareTo(Size.EXTRA_LARGE);
System.out.println(i);
System.out.println(Size.LARGE.getSuoxie());
申哥的枚举：
实际项目中不会每个类型都弄一个枚举类，假设那样，系统中会有很多枚举类，每个类里边只有几个属性，那样类太多，感觉没必要，所以申哥设计了一个常量类Constants，在常量类里定义了多个静态枚举类，这个和上边说的申哥在接口常量里定义静态内部类有点类似，不过现在换成了枚举。
接口里定义静态内部类好处：对不同功能的常量进行分类，用起来比较明确，但是由于是interface，里边不能定义static静态代码块，所以没办法像类常量那样即定义常量状态码，又在map里放对应的说明信息，只能通过注释给开发人员用的时候看。
&申哥的这种做法算是两全其美，在一个常量类里，定义多个静态的枚举，枚举类定义两个参数的构造器，一个相当于key，一个是value，属性也是final类型的，每个枚举对应实体对象的一种状态，甚好。
public class Constants {
public static enum Dict{
PROSTA("PROSTA","产品状态"),
COUNTRY("COUNTRY","国家"),
YWLX("YWLX","业务类型"),
INDUSTRYCOMPANYTYPE("IndustryCompanyType","公司类型"),
JSFS("JSFS","结算方式"),
COMMISSIONTYPE("COMMISSIONTYPE","返佣类型"),
BALUNITTYPE("BALUNITTYPE","结算单位类型"),
ORDERSTATS("OrderStats","订单状态"),
BACKORDERSTATUS("BackOrderStatus","退单审核状态"),
BUSINESSPAYMENT("BusinessPayment","业务款项"),
ENABLESTATE("enableState","启用禁用"),
APPROVESTATE("approveState","审批状态"),
分销系统所需是商品系统的xml
PRODUCTCONTENTTYPE("productContentType","商品内容分类"),
IDENTITY("identity","适应人群"),
AREA("area","领区"),
VISATYPE("visatype","签证类型"),
SERVICETYPE("serviceType","公证认证商品内容分类"),
PRODUCTTYPEQUALITY("productTypeQuality","公证认证商品性质"),
EXPRESSTYPE("expresstype","公证认证加急种类"),
IDETIFICATIONTYPE("identificationType","认证类别"),
QYKHLX("QYKHLX","客户类型"),
ZILIAONAME("ziliaoName","资料名称"),
YESORNO("yesOrNo","是否");
private Dict(String value,String name){
this.value=
this.name=
private final S
private final S
public String getValue() {
public String getName() {
* 订单状态
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum OrderStats{
DELETE(0,"删除"),RESERVE(1,"订单预定"),CONFIRM(2,"订单确认"),COMPLETE(3,"订单完成"),CLOSE(4,"订单关闭");
private OrderStats(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum sex{
MAN("1","男"),FEMAN("2","女");
private sex(String value,String name){
this.value =
this.name =
private final S
private final S
public String getValue() {
public String getName() {
* 退单审核状态
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum BackOrderStatus{
WAIT(1,"待审核"),AUDIT(2,"审核中"),PASS(3,"审核通过"),NOTPASS(4,"审核不通过");
private BackOrderStatus(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
* 结算方式
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum jiesuan{
XIANJIE("1","现结"),YUEJIE("2","月结");
private jiesuan(String value,String name){
this.value =
this.name =
private final S
private final S
public String getValue() {
public String getName() {
* 业务款项
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum BusinessPayment{
VISA("FUND18","签证费"),PREMIUMS("FUND07","保险"),DEPOSIT("FUND10","押金"),CANCELLING("FUND12","取消金"),FUND20("FUND20","单项服务"),FUND14("FUND14","认证费"),FUND09("FUND09","团款");
private BusinessPayment(String value,String name){
this.value =
this.name =
private final S
private final S
public String getValue() {
public String getName() {
* 通用的启用禁用状态
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum EnableState{
DISABLE(0,"禁用"),ENABLE(1,"启用");
private EnableState(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
* 通用的审批状态
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum ApproveState{
REJECT(0,"不通过"),PASS(1,"通过");
private ApproveState(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
* 通用的是否
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum YesOrNo{
NO(0,"否"),YES(1,"是");
private YesOrNo(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
* 业务状态
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum ServiceStatus{
NORMAL(1,"正常办理"),CHANGEING(2,"应收变更中"),BACKING(3,"退单中"),BACK(4,"退单");
private ServiceStatus(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum PayStatus{
NOTPAY("01","未支付"),PARTPAY("02","部分支付"),FINISHPAY("03","支付完成");
private PayStatus(String value,String name){
this.value =
this.name =
private final S
private final S
public String getValue() {
public String getName() {
public static enum DeleteStatus{
NORMAL(1,"正常"),DELETE(0,"删除");
private DeleteStatus(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
订单类型,主要是判断订单是从哪个系统推送过来的，
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum OrderType{
SALE("DDLY010301","ERP"),DISTRIBUTION("DDLY0104","分销平台");
private OrderType(String value,String name){
this.value =
this.name =
private final S
private final S
public String getValue() {
public String getName() {
public static enum CommonFieldEnum {
DBID("dbid",UUID.randomUUID().toString().replace("-", "")), //主键
CREATEPERSONNAME("createpersonname","username"),//创建人姓名
CREATEPERSONCODE("createpersoncode","usercode"),//创建人姓名
CREATEUSTIME("createtime",new Date()),//创建时间
UPDATEPERSONNAME("updatepersonname","username"),//更新人姓名
UPDATEPERSONCODE("updatepersoncode","usercode"),//更新人姓名
UPDATETIME("updatetime",new Date()),//更新时间
ACTIONPERSONNAME("actionpersonname","username"),//操作人姓名
ACTIONPERSONCODE("actionpersoncode","usercode"),//操作人code
ACTIONTIME("actiontime",new Date()),//操作时间
private CommonFieldEnum(String value, Object type) {
this.value =
this.type =
private final S
private final O
public String getValue() {
public Object getType() {
* &p&Company:rayootech&/p&
* @author xudf
public static enum BusinessType{
NOTARY("YWLX09","签证-公证认证"),VISA("YWLX10","签证-单办签证"),NOTVISA("YWLX16","签证其他"),INSURANCE("YWLX11","保险-单办保险");
private BusinessType(String value,String name){
this.value =
this.name =
private final S
private final S
public String getValue() {
public String getName() {
* 锁单状态
* &p&Company:rayootech&/p&
* @author zhangxueshen
public static enum LockStatus{
NORMAL(0,"正常"),RECEIVCHANGE(1,"应收变更锁单中"),SEALED(2,"客人封存更锁单中"),BACK(3,"退单更锁单中");
private LockStatus(Integer value,String name){
this.value =
this.name =
private final I
private final S
public Integer getValue() {
public String getName() {
public static void main(String[] args) {
String key = Constants.ServiceStatus.NORMAL.getName();
int value = Constants.ServiceStatus.NORMAL.getValue();
System.out.println(key+":"+ value);
阅读(...) 评论()用户名：hsj69106
文章数：35
访问量：285430
注册日期：
阅读量：1297
阅读量：3317
阅读量：580710
阅读量：463543
[匿名]mmwander：
51CTO推荐博文
转载：/blog/458439
把常量定义在接口里与类里都能通过编译，那2者到底有什么区别呢？那个更合理？
1. 常量接口
Java代码 &
public&interface&ConstInterfaceA&{&&
&&public&static&final&String&CONST_A&=&&aa&;&&
&&public&static&final&String&CONST_C&=&&ac&;&&
1) 无法限制开发员继承/实现接口.
2) 开发员能够在子接口里继续添加常量.而这些常量可能得不到祖先层的支持.
3) 常量作为参数时,是String,int等弱类型,开发员可以传入没有在常量接口里定义的值,这个问题无法通过编译器发现.
4) 由于开发员可以直接写常量值, 所以不能用==对比,只能用equals对比,不能优化性能
5) 开发员在没有参考资料时,不可能知道某个int型的参数到底应该赋什么内容.
6) 编译时,是直接把常量的值编译到类的二进制代码里,常量的值在升级中变化后,需要重新编译所有引用常量的类,因为里面存的是旧值.
Java代码 &
public&class&ConstClassA&{&&
&&public&static&final&String&CONST_A&=&&aa&;&&
&&public&static&final&String&CONST_C&=&&ac&;&&
&&private&ConstClassA()&{&&
常量类可以设置构造函数为private,从而限制继承,也就没有继续添加常量的问题了.
但是其他问题与常量接口一样无法解决
3. 枚举常量类
Java代码 &
public&class&EnumClassA&{&&
&&private&String&&&
&&private&EnumClassA(String&name)&{&&
&&&&this.name&=&&&
&&public&static&final&EnumClassA&CONST_A&=&new&EnumClassA(&aa&);&&
&&public&static&final&EnumClassA&CONST_C&=&new&EnumClassA(&ac&);&&
解决了以上所有问题,主要体现在:
1) 私有构造函数,避免被继承和扩展.
2) 定义方法的参数时,必须用枚举常量类类型,如上面的EnumClassA类型,这样就转变成了强类型,不会出现弱类型引起的问题.
3) 常量值地址唯一,可以用==直接对比,性能会有提高.
4) 开发员可以根据该参数类型打开对应的类,从而找到定义的常量.
5) 编译时,没有把常量值编译到代码里,即使常量的值发生变化也不会影响引用常量的类.
4. enum类型
Java代码 &
public&static&enum&Grade&{&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&A(4),&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&B(3),&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&C(2),&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&D(1),&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&F(0);&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&private&int&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&Grade(int&points)&{&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&this.points&=&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&}&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&getPoints()&{&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&return&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&}&&
&&&&&&&&&&&&&&&&&&&&&&&&&};&&
这是JDK1.5引入的,其实就是枚举常量类的代码封装简化而已.
查看enum反编译后的代码与枚举常量类的结构非常相似.
这可能是因为java的设计者一开始觉得enum与OO思想不符,所以没有提供支持,但是随着常量接口的滥用和枚举常量类方案的出现,才在JDK1.5里增加了enum.
了这篇文章
类别：未分类┆阅读(0)┆评论(0) 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
枚举Enum的定义和使用以及与常量Const的使用区别？
下载积分：1600
内容提示：枚举Enum的定义和使用以及与常量Const的使用区别？
文档格式：TXT|
浏览次数：134|
上传日期： 21:40:37|
文档星级：
全文阅读已结束，如果下载本文需要使用
 1600 积分
下载此文档
该用户还上传了这些文档
枚举Enum的定义和使用以及与常量Const的使用区别？
官方公共微信11953人阅读
假如有一笔业务需要审核，审核状态分：未审核，审核中，审核通过，审核不通过。我们在程序里是否可以直接这么写：
if(state==1){//1代表未操作
&&&&& //操作
&&&& //......
将状态标识直接写在代码里面（硬编码），只图一时方便，却是后患无穷，如果有一天你需要修改状态标识，用0代表未审核而不是1，你不得不将所有与该标识相关的代码都找出来一个个改，另外，在编码过程中，标识输入错误的概率是比较高的，一不小心把0输入成了10，虽然不会提示任何编译错误，但运行结果将是出乎人的意料的。
于是我们很快想到可以用常量代替：
public static final int UNAUDIT = 0;
相关判断代码则是:
if(state==CONSTANT.UNAUDIT){
&&&&& //操作
&&&&& //......
这段代码比硬编码更加健壮容易维护，但是仍然有不足之处。
1、UNAUDIT是编译期常量，如果其值被改变，那么使用方需要重新编译。
2、没有简便的方法获取标识代表的字符串描述。
于是我们用枚举类来代替常量。
public enum AuditState {
&&&& UNAUDIT(1),
&&&& AUDITING(2),
&&&& AUDIT_SUCCESS(3),
&&&& AUDIT_FAIL(4);
&&& AuditState(int statenum){
&& this.statenum =
public int getStatenum() {
调用如下：
if (state == AuditState.UNAUDIT.getStatenum()) {
&&& //AuditState.UNAUDIT.toString()获取字符串描述
System.out.println(
&&&& AuditState.UNAUDIT.toString() + &标识是 &
&&& + AuditState.UNAUDIT.getStatenum());
&& //......
枚举类还有更加强大的功能，如添加字段，方法，还可以对他进行遍历访问
常量的声明是每一个项目中不可或缺的，在Java1.5之前，我们只有两种方式的声明：类常量和接口常量。不过，在1.5版之后有了改进，即新增了一种常量声明方式，枚举常量。如下：&
enum Season{
Spring,Summer,Autumn,W
那么枚举常量与我们的经常使用的类常量和静态常量比有什么优势呢？&
1.枚举常量更简单&
先把Season枚举翻译成接口，代码如下：&
interface Season{
int Sprint = 0;
int Summer = 1;
int Autumn = 2;
int Winter = 3;
枚举只需要定义每个枚举项，不需要定义枚举值，而接口常量（或类常量）则必须定义值，否则编译通不过；两个引用的方式相同（都是“类名.属性”，如Season.Sprint），但是枚举表示的是一个枚举项，字面含义是春天，而接口常量却是一个Int类型。&
2.枚举常量属于稳态型&
使用常量接口，我们得对输入值进行检查，确定是否越界，如果常量非常庞大，校验输入就是一件非常麻烦的事情，但这是一个不可逃避的过程。&
public void describe(int s){
//s变量不能超越边界，校验条件
if(s &= 0 && s &4){
switch(s){
case Season.Summer:
System.out.println(&Summer is very hot!&);
case Season.Winter:
System.out.println(&Winter is very cold!&);
我们再来看看枚举常量是否能够避免校验问题，代码如下：&
public void describe(Season s){
switch(s){
case Season.Summer:
System.out.println(&Summer is very hot!&);
case Season.Winter:
System.out.println(&Winter is very cold!&);
不用校验，已经限定了是Season枚举，所以只能是Season类的四个实例。这也是我们看重枚举的地方：在编译期间限定类型，不允许发生越界的情况。&
3.枚举具有内置方法&
每个枚举都是java.lang.Enum的子类，该基类提供了诸如获得排序值的ordinal方法、compareTo比较方法等，大大简化了常量的访问。比如，列出所有枚举值：&
public static void main(String[] args){
for(Season s:Season.values()){
System.out.println(s);
4.枚举可以自定义方法&
这一点似乎不是枚举的优点，类常量也可以有自己的方法，但关键是枚举常量不仅仅可以定义静态方法，还可以定义非静态方法，而且还能够从根本上杜绝常量类被实例化。比如我们在定义获取最舒服的季节，使用枚举的代码如下：&
enum Season{
Spring,Summer,Autumn,W
//最舒服的季节
public static Season getComfortableSeason(){
那如果是使用类常量如何实现呢？如下：&
class Season{
public final static int Spring = 0;
public final static int Summer = 1;
public final static int Autumn = 2;
public final static int Winter = 3;
//最舒服的季节
public static int getComfortableSeason(){
虽然枚举在很多方面都比接口常量和类常量好用，但是它有一点比不上接口常量和类常量的，就是继承，枚举类型是不能有继承的，也就是说一个枚举常量定义完毕后，除非修改重构，否则无法做扩展。&
在项目开发中，推荐使用枚举常量代替接口常量或类常量。&
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：41939次
排名：千里之外
原创：36篇
转载：11篇
(1)(3)(14)(16)(13)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'