精华内容
下载资源
问答
  • /***Bestpay.com.cnInc.*Copyright(c)2011-2015AllRightsReserved.*/packagecom.bestpay.bpbp.common.enums;/***销账业务类型枚举**@authorWeiliang*@version$Id:BizTypeEnum.java,v0.12015年12月14日下午2:20...

    /**

    * Bestpay.com.cn Inc.

    * Copyright (c) 2011-2015 All Rights Reserved.

    */

    package com.bestpay.bpbp.common.enums;

    /**

    * 销账业务类型枚举

    *

    * @author Weiliang

    * @version $Id: BizTypeEnum.java, v 0.1 2015年12月14日 下午2:20:53 Weiliang Exp $

    */

    public enum BizTypeEnum {

    TRAIN_TICKET("TRAIN_TICKET", "火车票"),

    TRANSPORT_DEPOSIT("TRANSPORT_DEPOSIT", "交通卡充值");

    /** 枚举编码  */

    private String code;

    /** 描述说明 */

    private String description;

    /**

    * 默认构造器

    *

    * @param code 枚举编码

    * @param description 描述说明

    * @param isFinish

    */

    private BizTypeEnum(String code, String description) {

    this.code = code;

    this.description = description;

    }

    /**

    * 通过枚举code获得枚举

    *

    * @param code 枚举编码

    * @return 支付单状态枚举

    */

    public static BizTypeEnum getByCode(String code) {

    for (BizTypeEnum bizTypeEnum : values()) {

    if (bizTypeEnum.getCode().equals(code)) {

    return bizTypeEnum;

    }

    }

    return null;

    }

    /**

    * Getter method for property code.

    *

    * @return property value of code

    */

    public String getCode() {

    return code;

    }

    /**

    * Getter method for property description.

    *

    * @return property value of description

    */

    public String getDescription() {

    return description;

    }

    public static void main(String[] args) {

    BizTypeEnum [] customErrorCodeEnums=BizTypeEnum.values();

    for(int i=0;i

    System.out.println(customErrorCodeEnums[i].getCode());

    System.out.println(customErrorCodeEnums[i].getDescription());

    }

    }

    }

    展开全文
  • java 枚举类循环

    2016-04-05 13:37:23
    //枚举类 public enum DeptNoEnum { DEPT_WEALTH_MANAGE_SOCIAL_FINANCE(1,"财富管理部社交金融组"), DEPT_PUBLIC_RELATION(2,"公关部"), DEPT_WEALTH_MANAGE_CONTENT(3,"财富管理...
    //枚举类
    public enum DeptNoEnum {
    DEPT_WEALTH_MANAGE_SOCIAL_FINANCE(1,"财富管理部社交金融组"),
    DEPT_PUBLIC_RELATION(2,"公关部"),
    DEPT_WEALTH_MANAGE_CONTENT(3,"财富管理内容部");

    private Integer code;
    private String name;


    private DeptNoEnum(Integer code, String name) {
    this.code = code;
    this.name = name;
    }

    public Integer getCode() {
    return code;
    }

    public void setCode(Integer code) {
    this.code = code;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    public static String getNameByCode(Integer code){
    for (DeptNoEnum deptNoEnum : DeptNoEnum.values()) {
    if(deptNoEnum.getCode().equals(code)){
    return deptNoEnum.getName();
    }
    }
    return null;
    }

    }

    main方法中循环code,value
    public static void main(String[] args){
    //循环展示枚举类型
    for (DeptNoEnum deptNoEnum : DeptNoEnum.values()){
    String a1 = deptNoEnum.toString();
    System.out.println(DeptNoEnum.valueOf(a1).getCode());
    System.out.println(DeptNoEnum.valueOf(a1).getName());
    }
    }
    展开全文
  • 本文转载自:http://blog.csdn.net/qq_27093465/article/details/51706076 作者:李学凯什么时候想用枚举类型:有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之的东西,这个东西又没必要跟...

    本文转载自:http://blog.csdn.net/qq_27093465/article/details/51706076 作者:李学凯

    什么时候想用枚举类型:

    有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之类的东西,这个东西又没必要跟整个项目的全局常量放在一起,就放在model的java文件里面是最合适的,那么,你可以有两种选择:

    1,在java model文件里面,定义public final static XXXX = "" ;

    这种就是全局静态变量,通过类名就可以直接访问。

    2,还是在java model 文件里面,定义个枚举类型 public enum XXXX{a,b,c,d,e,f};

    什么时候,如何使用:

    当在和前台传过来的数据或者在逻辑操作的代码里面需要去用到这个常量值去做比较的时候,就是使用枚举类型的时候。

    一般形式是: 类名.枚举类型名.单个枚举类型

    用上面的例子(假设在一个叫A的model java文件里面),

    则为A.XXXX.a.toString();

    就可以这么使用了。

    为什么要这么设计常量:

    这里有个代码的书写原则,这东西一般是没人,而且书里面也是没人跟你说的,都是代码看多了,或者,在你犯错误的时候才知道的问题。

    就是在自己的代码里面,要是想使代码很规范,不被吊打,

    那么写出来的逻辑代码里面是不应该出现常量字符串和常量数字之类的东西。

    例如代码里面出现数字:100,8,

    或者其他的数字,

    字符串如:只要是在逻辑代码里面带引号的。

    这些代码,你写出来虽然在功能上是没有问题的,但是,这些都是隐藏的炸弹。

    好的代码,是不会出现这个问题的。这些东西都应该被定义成一个常量,然后再在其他地方使用。

    类似c语言里面的宏定义的感觉。

    不然在很久之后,忽然有些地方的值换了,只需要修改一处地方,整个项目都不用担心会出问题,

    但是,如果你没有这么干,那么,没人知道你在逻辑代码里面还有这样的常量存在。

    那么代码就会出现美妙的后果。

    然后就炸了。

    怎么循环一个枚举类型。

    枚举有一个方法,values(),

    使用形式如: int length = XXXX.values().length

    返回的是一个类型与枚举类型一致的数组。

    然后就可以循环这个数组。

    就是循环枚举类型了。

    public enum EnumTest {

    MON, TUE, WED, THU, FRI, SAT, SUN;

    }

    //循环输出 值

    for (EnumTest e : EnumTest.values()) {

    System.out.println(e.toString());

    }

    4650d1ea9e55bd0edfe7fd26060a5963.png

    .ordinal()方法。

    这个方法就是从枚举类型的第一个枚举开始,依次从零开始往上递增。

    上面的例子中a,b,c,d,e,f,依次对应 为数字 ,0,1,2,3,4,5

    形式:A.XXXX.a.ordinal();

    这么个方式调用。

    创建枚举类型要使用 enum 关键字,

    隐含了所创建的类型都是

    java.lang.Enum

    类的子类(java.lang.Enum 是一个抽象类)

    其中的方法和属性如下图:

    c9cfee719ff6d14669501723f8f61379.png

    enum 对象的常用方法介绍

    int compareTo(E o)

    比较此枚举与指定对象的顺序。

    Class getDeclaringClass()

    返回与此枚举常量的枚举类型相对应的 Class 对象。

    String name()

    返回此枚举常量的名称,在其枚举声明中对其进行声明。

    int ordinal()

    返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。

    String toString()

    返回枚举常量的名称,它包含在声明中。

    static > T valueOf(Class enumType, String name)

    返回带指定名称的指定枚举类型的枚举常量。

    JAVA中循环遍历list有三种方式

    转自:https://blog.csdn.net/changjizhi1212/article/details/81036509JAVA中循环遍历list有三种方式for循环.增强for循环(也就是常 ...

    Java 枚举(enum) 详解7种常见的用法

    Java 枚举(enum) 详解7种常见的用法 来源 https://blog.csdn.net/qq_27093465/article/details/52180865 JDK1.5引入了新的类型— ...

    java中循环遍历实体类的属性和数据类型以及属性值

    package com.walkerjava.test; import java.lang.reflect.Field; import java.lang.reflect.InvocationTarg ...

    java 各种循环遍历

    遍历方式选择: 实现了 RandomAccess 接口的 list,优先选择普通 for 循环 ,其次 foreach: 未实现 RandomAccess 接口的 list, 优先选择 iterato ...

    Java 枚举(enum) 详解4种常见的用法

    JDK1.5引入了新的类型——枚举.在 Java 中它虽然算个“小”功能,却给我的开发带来了“大”方便. 大师兄我又加上自己的理解,来帮助各位理解一下. 用法一:常量 在JDK1.5 之前,我们定义常 ...

    Java中循环删除list中元素的方法总结

    印象中循环删除list中的元素使用for循环的方式是有问题的,但是可以使用增强的for循环,然后在今天使用的时候发现报错了,然后去科普了一下,发现这是一个误区.下面我们来一起看一下. Java中循环遍 ...

    JAVA中循环删除list中元素的方法总结【转】

    印象中循环删除list中的元素使用for循环的方式是有问题的,但是可以使用增强的for循环,然后今天在使用时发现报错了,然后去科普了一下,再然后发现这是一个误区.下面就来讲一讲..伸手党可直接跳至文末 ...

    JAVA中循环删除list中元素

    文章来源: https://www.cnblogs.com/pcheng/p/5336903.html JAVA中循环遍历list有三种方式for循环.增强for循环(也就是常说的foreach循环) ...

    随机推荐

    string length() 方法注意点

    突然意识到string length() 是跟文件的字符编码相关的 测试了下, 果然如此: 对于常见字, 结果是一样的, System.out.println("T中国123".l ...

    [Java解惑]应用

    声明:原创作品,转载时请注明文章来自SAP师太技术博客( 博/客/园www.cnblogs.com):www.cnblogs.com/jiangzhengjun,并以超链接形式标明文章原始出处,否则将 ...

    linux 的开机启动脚本顺序

    linux 开机启动脚本顺序 linux 开机启动脚本顺序. 第一步:启动内核 第二步:执行init (配置文件/etc/inittab) 第三步:启动相应的脚本,并且打开终端/etc/init.d  ...

    【SQL】导出表数据到Excel中

    打开数据库之后点击新建表查询: ------------------------------------------------------------------------------------ ...

    Packetbeat协议扩展开发教程 一

    原文链接:http://elasticsearch.cn/article/48 Packetbeat(https://www.elastic.co/products/beats/packetbeat) ...

    laravel中的多对多关系详解

    数据表之间是纵横交叉.相互关联的,laravel的一对一,一对多比较好理解,官网介绍滴很详细了,在此我就不赘述啦,重点我记下多对多的关系 一种常见的关联关系是多对多,即表A的某条记录通过中间表C与表B ...

    Python3.6学习笔记(四)

    错误.调试和测试 程序运行中,可能会遇到BUG.用户输入异常数据以及其它环境的异常,这些都需要程序猿进行处理.Python提供了一套内置的异常处理机制,供程序猿使用,同时PDB提供了调试代码的功能,除 ...

    C++调用Java的Jar包

    一个简单需求:用C++调用Jar包. 实现基本思路:调用CreateProcess API来启动cmd.exe执行jar包. 调用类CJarAppCall. JarAppCall.h #pragma ...

    wpf简单的绘图板

    xaml:

    展开全文
  • java-枚举类

    2016-12-21 16:42:48
    所以枚举类中的非枚举成员(其他的成员变量),只会被初始化一次,这是用枚举类实现单例模式的基础,(2)枚举类中的静态成员变量,不能在枚举类的初始化方法中赋值使用,这是为了防止出现赋值的死循环结构1.枚举类

    转载自Todo_的博客http://blog.csdn.net/todo_/article/details/50588933

    重要补充:(1)因为枚举类的枚举成员都是public static final修饰的,所以枚举类中的非枚举成员(其他的成员变量),只会在初始化枚举成员的时候被初始化一次(每个枚举成员都会去初始化一次),这是用枚举类实现单例模式的基础(单个枚举成员),(2)枚举类中的静态成员变量,不能在枚举类的初始化方法中赋值使用,这是为了防止出现赋值的死循环结构,会先初始化枚举成员,在初始化静态成员,(3)枚举类成员的初始化,虽然是public static final 修饰的,但是不是在类加载的时候初始化的,而是在第一次被调用的时候,初始化的。枚举成员实际上是枚举类的实例对象,当枚举类被调用的时候,枚举类会一次性初始化所有的枚举成员(4)枚举类中的非枚举成员(其他的成员变量)最好用private final 修饰,避免产生歧义。

    1.枚举类入门

    Java 5 新增了一个enum关键字(它与class、interface关键字的地方相同),用以定义枚举类。正如前面看到的,枚举类是一种特殊的类,他一样可以有自己的成员变量、方法,可以实现一个或多个接口,也可以定义自己的构造器。一个Java源文件中最多只能定义一个public访问权限的枚举类,且java源文件也必须和该枚举类的类名相同。

    但枚举类终究不是普通类,它与普通类有如下简单区别。
    (1)枚举类可以实现一个或多个接口,使用enum定义的枚举类默认继承了java.lang.Enum类,而不是默认继承Object类,因此枚举类不能显示继承其他父类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口。
    (2)使用enum定义、非抽象的枚举类默认会使用final修饰,因此枚举类不能派生子类。
    (3)枚举类的构造器只能使用private访问控制符,如果省略了构造器的访问控制符,则默认使用private修饰;如果强制指定访问控制符,则只能指定private修饰符。
    (4)枚举类的所有实例必须在枚举类的第一行显式列车,否则这个枚举类永远都不能产生实例。列出这些实例时,系统会自动添加public static final修饰,无须程序员显式添加。

    枚举类默认提供了一个values()方法,该方法可以很方便地遍历所有的枚举值。

    public enum SeasonEnum {
        // 在第一行列出4个枚举实例
        SPRING,SUMMER,FALL,WINTER;
    }

    编译上面Java程序,将生成一个SeasonEnu.class文件,这表明枚举类型是一个特殊的Java类。由此可见,enum关键字和class、interface关键字的作用大致相似。
    定义枚举类时,需要显示列出所有的枚举值,如上面的SPRING,SUMMER,FALL,WINTER;所示,所有的枚举值之间以英文逗号(,)隔开,枚举值列举结束后以英文分号作为结束。这些枚举值代表了该枚举类的所有可能的实例。
    如果需要使用该枚举类的某个实例,则可使用EnumClass.variable的形式,如SeasonEnum.SPRING.下面我们通过一个例子来了解一下枚举的简单用法。

    public class Test3 {
    
        public enum SeasonEnum {
            // 在第一行列出4个枚举实例
            SPRING, SUMMER, FALL, WINTER;
        }
    
        public void judge(SeasonEnum seasonEnum) {
            // switch 语句里的表达式可以是枚举值
            switch (seasonEnum) {
                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) {
            Test3 test3 = new Test3();
            // 枚举类默认有一个values()方法,返回该枚举类的所有实例
            for (SeasonEnum s : SeasonEnum.values()) {
                System.out.println(s);
            }
            // 使用枚举实例时,可通过EnumClass.variable形式来访问
            test3.judge(SeasonEnum.SPRING);
        }
    }

    java.lang.Enum类

    因为所有的枚举类都继承了java.lang.Enum类,所以枚举类可以直接使用java.lang.Enum类中所有包含的方法。java.lang.Enum类中提供了如下几个方法:
    (1)int compareTo(E o):该方法用于与指定枚举对象比较顺序,同一个枚举实例只能与相同类型的枚举实例进行比较。如果该枚举对象位于指定枚举对象之后,则返回正数;如果该枚举对象位于指定枚举对象之前,则返回负数,否则返回零。
    (2)String name():返回此枚举实例的名称,这个名称就是定义枚举类时列出的所有枚举值之一。与此方法相比,大多数程序员应先考虑使用toString()方法,因此toString()方法返回更加用户友好的名称。
    (3)int ordinal():返回枚举值在枚举类中的索引值(就是枚举值在枚举声明中的位置,第一个枚举值的索引值为零)。
    (4):String toString():返回枚举常量的名称,与name方法相似,但toString()方法更常用。
    (5):public static < T extends Enum < T> > T valueOf(Class< T > enumType,String name):这是一个静态方法,用于返回指定枚举类中指定名称的枚举值。名称必须与在该枚举类中声明枚举值时所用的标识符完全匹配,不允许使用额外的空白字符。

    枚举类的成员变量、方法和构造器

    我们来看一个例子:

    public class Test4 {
    
        public enum Gender {
            MALE,FEMALE;
            // 定义一个public修士的实例变量
            public String name;
        }
    
        public static void main(String[] args) {
            // 通过Enum的valueOf()方法来获取指定枚举类的枚举值
            Gender g = Enum.valueOf(Gender.class, "FEMALE");
            // 直接为枚举值的name实例变量赋值
            g.name = "女";
            // 直接访问枚举值的name实例变量
            System.out.println(g + "代表:" + g.name);
        }
    }

    上面程序使用Gender枚举类时与使用一个普通类没有太大的差别,差别只是产生Gender对象的方式不同,枚举类的实例只能是枚举值,而不是随意地通过new来创建枚举类对象。
    正如前面提到的,Java应该吧所有类设计成良好封装的类,所以不应该允许直接访问Gender类的name成员,而是应该通过方法来控制对name的访问。否则可能出现混乱的情形,例如上面程序恰好设置了g.name = “女”,要是采用g.name = “男”,那程序就会非常混乱了,可能出现FEMALE代表男的局面。可以按照如下代码来改进Gender类的设计。

    public class Test4 {
    
        public enum Gender {
            MALE, FEMALE;
            // 定义一个public修士的实例变量
            public String name;
    
            public void setName(String name) {
                switch (this) {
                    case MALE :
                        if (name.equals("男")) {
                            this.name = name;
                        } else {
                            System.out.println("参数错误");
                            return;
                        }
                        break;
                    case FEMALE :
                        if (name.equals("女")) {
                            this.name = name;
                        } else {
                            System.out.println("参数错误");
                            return;
                        }
                        break;
                }
            }
    
            public String getName() {
                return name;
            }
        }
    
        public static void main(String[] args) {
            // 通过Enum的valueOf()方法来获取指定枚举类的枚举值
            Gender g = Enum.valueOf(Gender.class, "FEMALE");
            // 直接为枚举值的name实例变量赋值
            g.setName("女");
            // 直接访问枚举值的name实例变量
            System.out.println(g + "代表:" + g.name);
            // 此时设置name值时将会提示参数错误
            g.setName("男");
            // 直接访问枚举值的name实例变量
            System.out.println(g + "代表:" + g.name);
        }
    }

    上面的做法可以提高安全性,但是还是不够好。枚举类通常应该设计成不可变类,就是说,它的成员变量值不应该允许改变,这样会更安全,而且代码更加简洁。因此建议将枚举类的成员变量使用private final 修饰。
    如果所有的成员变量都是用了final修饰符来修饰,所以必须在构造器里为这些成员变量指定初始值(或者在定义成员变量是指定默认值,或者在初始化块中指定初始值,但这两种情况并不多见),因此应该为枚举类显示定义带参数的构造器。
    一旦为枚举类显示定义了带参数的构造器,列出枚举值时就必须对应地传入参数:

    我们更改上面的例子如下:

    public enum Gender {
        // 此处的枚举值必须调用对应的构造器来创建
        MALE("男"), FEMALE("女");
        // 定义一个public修士的实例变量
        private final String name;
        private Gender(String name) {
            this.name = name();
        }
    
        public String getName() {
            return this.name;
        }
    }

    实现接口的枚举类

    枚举类也可以实现一个或多个接口。与普通类实现一个或多个接口完全一样,枚举类实现一个或多个接口时,也需要实现该接口所包含的方法。如下面代码所示:

    public interface GenderDesc {
         void info();
     }
    public enum Gender implements GenderDesc{
           // 此处的枚举值必须调用对应的构造器来创建
           MALE("男"), FEMALE("女");
           // 定义一个public修士的实例变量
           private final String name;
           private Gender(String name) {
               this.name = name;
           }
    
           public String getName() {
               return this.name;
           }
    
           @Override
           public void info() {
               System.out.println("这是一个用于定义性别的枚举类");
           }
       }

    与普通类实现接口完全一样,如果由枚举类来实现接口里的方法,则每个枚举值在调用这个方法时都有相同的行为方式(因为方法体完全一样)。如果需要每个枚举值在调用该方法时呈现出不同行为方式,则可以让每个枚举值分别来实现该方法,每个枚举值提供不同的实现方式,从而不同的枚举值调用该方法是具有不同的行为方式。代码如下:

    public interface GenderDesc {
            void info();
    }
    public enum Gender implements GenderDesc{
         // 此处的枚举值必须调用对应的构造器来创建
         MALE("男")
         {
             @Override
             public void info() {
                 System.out.println("这个枚举值代表男");
             }
         }, 
         FEMALE("女")
         {
             @Override
             public void info() {
                 System.out.println("这个枚举值代表女");
             }
         };
         // 定义一个public修士的实例变量
         private final String name;
         private Gender(String name) {
             this.name = name();
         }
    
         public String getName() {
             return this.name;
         }
     }

    这里分别实现接口方法的语法与匿名内部类语法大致相似,只是它依然是枚举类的匿名内部子类。

    注:并不是所有的枚举类都是用了final修饰!非抽象的枚举类才默认使用final修饰。对于一个抽象的枚举类而言——只要包含了抽象方法,他就是抽象枚举类,系统默认使用abstract修饰,而不是使用final修饰。

    包含抽象方法的枚举类

    假设有一个Operation枚举类,它的4个枚举值PLUS,MINUS,TIMES,DIVIDE分别代表加、减、乘、除四中运算,该枚举类需要定义一个eval()方法来完成计算。
    从上面描述可以看出,Operation需要让PLUS,MINUS,TIMES,DIVIDE四个值对eval()方法各有不同的实现,此时可以考虑为Operation枚举类定义一个eval()抽象方法,然后让4哥枚举值分别为eval()提供不同的实现,代码如下:

    package com.lyong.test;  
    
    public enum Operation {
    
        PLUS {
    
            @Override
            public double eval(double x, double y) {
                return x + y;
            }
    
        },
    
        MINUS {
    
            @Override
            public double eval(double x, double y) {
                return x - y;
            }
    
        },
    
        TIMES {
    
            @Override
            public double eval(double x, double y) {
                return x * y;
            }
    
        },
    
        DIVIDE {
    
            @Override
            public double eval(double x, double y) {
                return x / y;
            }
    
        };
    
        // 为枚举类定义一个抽象方法
        // 这个抽象方法由不同的枚举值提供不同的实现
        public abstract double eval(double x, double y);
    
        public static void main(String[] args) {
            System.out.println(Operation.PLUS.eval(3, 4));
            System.out.println(Operation.MINUS.eval(3, 4));
            System.out.println(Operation.TIMES.eval(3, 4));
            System.out.println(Operation.DIVIDE.eval(3, 4));
        }
    }

    编译上面程序会生成5个class文件,其实Operation对应一个class文件,它的4个匿名内部子类分别对应一个class文件。
    枚举类里定义抽象方法时不能使用abstract关键字将枚举类定义成抽象类(因为系统自动会为它添加abstract关键字),但因为枚举类需要显示创建枚举值,而不是作为父类,所以定义每个枚举值时必须为抽象方法提供实现,否则将出现编译错误。

    展开全文
  • 需要填写第二个节点的三个办理人员数据,三个办理人员的角色是固定的枚举类中的枚举值,这样第一个节点审批提交时,我们就需要创建三个不同角色的办理对象,创建对象时只需要获取枚举中的所有枚举,然后循环创建多个...
  • 如何在Java循环枚举

    2020-06-04 05:45:37
    调用enum的.values()方法以返回一个数组,并使用for循环对其进行循环: for (EnumClass obj : EnumClass.values()) { System.out.println(obj); } 对于Java 8,将enum转换为流并将其循环: Stream.of...
  • 讲真,java枚举类提供的方法太少了,Enum只有两个valueOf可以搞,如果碰上需要传入枚举类型的值,获取枚举类对象或者枚举类型名称的时候,只能干瞪眼,或者循环比对。最近项目就遇到这种,而且感觉以后以及别人都...
  • 讲真,java枚举类提供的方法太少了,Enum只有两个valueOf可以搞,如果碰上需要传入枚举类型的值,获取枚举类对象或者枚举类型名称的时候,只能干瞪眼,或者循环比对。最近项目就遇到这种,而且感觉以后以及别人都...
  • 本文转载自:http://blog.csdn.net/qq_27093465/article/details/51706076 作者:李学凯什么时候想用枚举类型:有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之的东西,这个东西又没必要跟...
  • 讲真,java枚举类提供的方法太少了,Enum只有两个valueOf可以搞,如果碰上需要传入枚举类型的值,获取枚举类对象或者枚举类型名称的时候,只能干瞪眼,或者循环比对。最近项目就遇到这种,而且感觉以后以及别人都...
  • 1.用法一:常量 在JDK1.5 之前,我们常见的定义常量都是: public static fianl…。现在有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。... //循环Enum自带的values(),可以获取该
  • Java枚举存入List集合

    万次阅读 2017-09-26 09:50:39
    基本思路就是新建一个字段跟枚举一致的类A...枚举类: // 套餐枚举 public enum BalanceType { balance_type0(0, "套餐1"), balance_type1(1, "套餐2"), balance_type2( 2, "套餐3"), balance_type3(3, "套餐4"), bala
  • 一、枚举简介1、什么是枚举?需要在一定范围内取值,这... }*枚举的构造方法也是私有化的*特殊枚举的操作**在枚举类里面有构造方法**在构造方法里面有参数,需要在每个实例上都写参数**在枚举类里面有抽象方法**在枚...
  • java 枚举 循环遍历以及一些简单常见的使用

    万次阅读 多人点赞 2016-06-18 16:04:11
    有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之的东西,这个东西又没必要跟整个项目的全局常量放在一起,就放在model的java文件里面是最合适的,那么,你可以有两种选择: 1,在java ...
  • 枚举类

    2018-08-11 11:44:48
    枚举类实现的不是java.lang.objec接口,而是实现了java.lang.serializable 和java.lang.comparable 两个接口。 所有的枚举类都继承了java.lang.enum 另外默认的非抽象的枚举类会使用final修饰。不能被继承。也就不...
  • java枚举

    2013-10-31 11:16:58
    下面将通过2个枚举类AnimalOne,AnimalTwo来详细说明其用法: 下面代码主要是3个类,其实AnimalOne和AnimalTwo为枚举类,AnimalEnumTest为测试类,演示了日常工作所出现的情况。 [code="java"] /* * ...
  • 后来想了一下实在太麻烦了,加入枚举类改变的话业务代码的判断也需要改变比较麻烦,工具类也没找到相关的,于是自己通过反射写了一个循环遍历判断枚举类枚举类: public enum AuditState { TO_BE_AUDIT(0, ...
  • Java 中使用 enum 关键字来定义枚举类,其地位与 class、interface 相同,注意到编译后会单独形成一个.class文件。 假设我们声明了如下的一个枚举类型: public enum PenColor { BLACK, GRAY, RED, PINK, ...
  • 后来想了一下实在太麻烦了,加入枚举类改变的话业务代码的判断也需要改变比较麻烦,工具类也没找到相关的,于是自己通过反射写了一个循环遍历判断枚举类。 首先,是一个枚举类: public enum AuditState { TO...
  • 本文转载自:http://blog.csdn.net/qq_27093465/article/details/51706076 作者:李学凯什么时候想用枚举类型:有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之的东西,这个东西又没必要跟...
  • import static 中的具体方法(可以用*) 可变参数 add(int x,int ... args) overload和override的区别 增强for循环 for(type 变量名:集合变量名){} public static int add(int x,int.....
  • 枚举简介枚举类型可以使用关键字enum来指定,可以将一组值得有限...枚举基本特性枚举使用enum关键字声明,其values方法可以遍历枚举内部的所有元素,并且严格保持enum中声明时的顺序,因此可以在循环中使用values(...
  • 展开全部1、i的值是从1开始出现的,但32313133353236313431303231363533e78988e69d8331333337613763是你这个程序总共输出13的3次方次结果,也就是2197次结果,...你可以在第二层循环加个暂停语句,这样可以每过一...
  • 有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之的东西,这个东西又没必要跟整个项目的全局常量放在一起,就放在model的java文件里面是最合适的,那么,你可以有两种选择: 1,在java mod...
  • java 枚举

    2015-05-09 23:55:44
    1:当遍历集合或数组时,如果需要访问集合或数组的下标,那么最好使用旧式的方式来实现循环或遍历,而不要使用增强的for循环,因为它丢失了下标信息。 2. Integer有一个缓存,它会缓存介于-128~127之间的整数。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 671
精华内容 268
关键字:

java循环枚举类

java 订阅