精华内容
下载资源
问答
  • 最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示:public enumColorSelect {RED_BAGE= 0,GREEN_BAGE,BLUE_BAGE;}编译不过。我将赋值语句修改了以后,如下所示:public ...

    最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示:

    public enumColorSelect {

    RED_BAGE= 0,

    GREEN_BAGE,

    BLUE_BAGE;

    }

    编译不过。

    我将赋值语句修改了以后,如下所示:

    public enumColorSelect {

    RED_BAGE ,

    GREEN_BAGE,

    BLUE_BAGE;

    }

    编译通过。说明C++那样的赋值方法不适用java。所以,我需要弄清楚的是:

    1. 在java平台上,如何初始化枚举值。

    2.像上述那样的枚举类型ColorSelect,没有赋值,为什么switch(ColorSelect) 可以运行?它是通过字符串还是整数值来匹配枚举类型。

    为了弄清楚上述问题,我自己就写了个示范程序,将该程序编译后,看看结果,是否可以找到答案。

    一. 如何初始化枚举值

    下面是我的示范程序:

    自己定义的枚举类:

    public enum ColorSelect { //定义枚举类ColorSelect

    RED_BAGE , //定义三个枚举对象

    GREEN_BAGE,

    BLUE_BAGE;

    }

    通过反编译,这段代码反编译后的程序是:

    public final class ColorSelect extendsEnum

    {public static ColorSelect valueOf(String s) //公有函数,该方法通过字符串获取对应的ColorSelect 对象

    {return (ColorSelect)Enum.valueOf(test/Enum/TestEnum$ColorSelect, s);

    }public static ColorSelect[] values() //公有函数该方法获取所有的ColorSelect对象

    {

    ColorSelect acolorselect[]= ENUM$VALUES; //ENUM$VALUES是ColorSelect数组,下面的代码会将其进行初始化

    int i =acolorselect.length;

    ColorSelect acolorselect1[]= newColorSelect[i];

    System.arraycopy(acolorselect,0, acolorselect1, 0, i);returnacolorselect1;

    }public static final ColorSelect BLUE_BAGE; //定义公共成员BLUE_BAGE,属于ColorSelect对象

    private static final ColorSelect ENUM$VALUES[]; //定义私有成员ENUM$VALUES[],属于ColorSelect数组

    public static final ColorSelect GREEN_BAGE; //定义公共成员GREEN_BAGE,属于ColorSelect对象

    public static final ColorSelect RED_BAGE; //定义公共成员RED_BAGE,属于ColorSelect对象

    static{//static里面这段代码,将上面定义的是三个公共成员ColorSelect对象进行初始化,然后将他们全部赋值给ENUM$VALUES

    RED_BAGE = new ColorSelect("RED_BAGE", 0); //初始化BLUE_BAGE

    GREEN_BAGE = new ColorSelect("GREEN_BAGE", 1); //初始化GREEN_BAGE

    BLUE_BAGE = new ColorSelect("BLUE_BAGE", 2); //初始化BLUE_BAGE

    ColorSelect acolorselect[] = new ColorSelect[3];

    ColorSelect colorselect=RED_BAGE;

    acolorselect[0] =colorselect;

    ColorSelect colorselect1=GREEN_BAGE;

    acolorselect[1] =colorselect1;

    ColorSelect colorselect2=BLUE_BAGE;

    acolorselect[2] =colorselect2;

    ENUM$VALUES=acolorselect;

    }private ColorSelect(String s, int i) //私有函数,调用父类进行初始化ColorSelect对象

    {super(s, i);

    }

    }

    从该反编译的代码看,有两个公有成员函数:

    public static ColorSelect valueOf(String s);  该方法通过字符串获取对应的ColorSelect 对象

    public static ColorSelect[] values();  该方法获取所有的ColorSelect 对象

    这两种方法,在java里面可以直接调用。

    下面的是ColorSelect的数据成员。

    public static finalColorSelect BLUE_BAGE;private static finalColorSelect ENUM$VALUES[];public static finalColorSelect GREEN_BAGE;public static final ColorSelect RED_BAGE;

    公有数据就是BLUE_BAGE,GREEN_BAGE,RED_BAGE,它们本身属性就是ColorSelect类。所以,从这里可以看到枚举类定义的成员变量也是类。后续的代码:

    RED_BAGE = new ColorSelect("RED_BAGE", 0);

    GREEN_BAGE= new ColorSelect("GREEN_BAGE", 1);

    BLUE_BAGE= new ColorSelect("BLUE_BAGE", 2);

    这三行相当于初始化这三个类,并且每个类分配唯一的序号,按定义时的顺序从0递增。我们在java代码,可以调用ColorSelect.BLUE_BAGE.ordinal()来得到对应的序号值。

    通过以上分析,java枚举是一个类,不是语言本身实现的,而是编译器实现的,我们可以直接调用里面的方法。Enum 本身就是个普通的 class, 可以有很多自定义方法用来实现不同的功能。如果我们不自定义里面的方法,编译器就能初始化,默认顺序从0递增。我们也可以自定义方法,这样就能随便赋值。

    下面是我们自定义的java枚举类型,可以赋值。

    public enumTemp {/*通过括号赋值,而且必须有带参构造器和一属性跟方法,否则编译出错

    * 赋值必须是都赋值或都不赋值,不能一部分赋值一部分不赋值

    * 如果不赋值则不能写构造器,赋值编译也出错*/absoluteZero(-459), freezing(32),boiling(212), paperBurns(451);private final intvalue;public intgetValue() {returnvalue;

    }//构造器默认也只能是private, 从而保证构造函数只能在内部使用

    Temp(intvalue) {this.value =value;

    }

    }

    这就是一个枚举类,自定义方法来赋值。java不像C++那样简便,初始第一个值,后续值递增。赋值必须是都赋值或都不赋值,不能一部分赋值一部分不赋值。如果不赋值则不能写构造器,赋值编译也出错。

    Temp temp = null;

    Log.i("Temp##",temp.freezing.getValue()+"");

    在主函数中,我们调用temp.freezing.getValue(),得到对应的值32。

    如果大家感觉自定义枚举类麻烦,其实也可以用别的方法来代替自定义枚举类。如下所示:

    public classColorSelect {private static final int RED_BAGE = 1;private static final int GREEN_BAGE = 3;private static final int BLUE_BAGE = 5;

    }

    这种方法也比较方便。

    二. 第一个疑问搞清楚了,我们现在要解决第二个问题。Switch到底通过字符串,还是整型来分辨枚举变量。

    下面是java代码段:

    ColorSelect test =ColorSelect.BLUE_BAGE;switch(test){caseRED_BAGE:

    Log.i("TEST####1","a");break;caseGREEN_BAGE:

    Log.i("TEST####2","b");break;caseBLUE_BAGE:

    Log.i("TEST####3","c");break;default:

    Log.i("TEST####4","d");

    }

    Log.i("TEST####ret", "e");

    反编译后的代码:

    { //主函数

    ColorSelect colorselect =ColorSelect.BLUE_BAGE;

    ai= $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect(); //调用子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect(),返回数组赋值给ai

    i = colorselect.ordinal(); //得到该枚举类型BLUE_BAGE的序号

    ai[i]; //switch根据ai[i]值来进行判断

    JVM INSTR tableswitch 1 3: default 56 //1 3是ai[i]的取值范围//1 73//2 84//3 95;

    goto_L1 _L2 _L3 _L4

    _L1:

    Log.i("TEST####4", "d");

    _L6:

    Log.i("TEST####ret", "e");return;

    _L2:

    Log.i("TEST####1", "a");continue; /*Loop/switch isn't completed*/_L3:

    Log.i("TEST####2", "b");continue; /*Loop/switch isn't completed*/_L4:

    Log.i("TEST####3", "c");if(true) goto _L6; else goto_L5

    _L5:

    }private static int$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect[];

    }//子函数

    static int[] $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect() //{int ai[] =$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect;if(ai == null)

    {

    ai= new int[ColorSelect.values().length];try //下面的代码,将每一个枚举类型的序号值作为数组ai的下标,然后赋一个整数值

    {int i =ColorSelect.BLUE_BAGE.ordinal();

    ai[i]= 3;

    }catch(NoSuchFieldError nosuchfielderror2) { }try{int j =ColorSelect.GREEN_BAGE.ordinal();

    ai[j]= 2;

    }catch(NoSuchFieldError nosuchfielderror1) { }try{int k =ColorSelect.RED_BAGE.ordinal();

    ai[k]= 1;

    }catch(NoSuchFieldError nosuchfielderror) { }

    $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect=ai;

    }returnai;

    }

    子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect()的功能:

    通过int i = ColorSelect.BLUE_BAGE.ordinal()得到该类的唯一序号,作为数组下标,并且赋值给ai[i]。这样,每一个枚举类对应都有唯一的整数对应。然后返回数组ai[]。这个功能是编译器实现的。我感觉,子函数的功能有些多余,其实可以直接用之前初始化枚举类的时候的下标号,直接作为标识符也行,就不用再给每个枚举类重新赋整数值。

    主函数里面,调用子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect(),switch()里面的参数是ai[i],根据这个整数值来判断分支。Java里面枚举值通过编译器给每个枚举类型赋整型数值,然后Switch通过识别这些整数来进行判断分支,这就解决了第二个疑问。

    同时我们通过对比switch的java代码和反编译的代码,可以得到大概下面的结论。

    1.每个标志位的"continue"说明该分支break。

    2.最后一个分支的标志是if (true) goto _Lx,else goto _x。

    同时我们通过对比switch的java代码和反编译的代码,可以得到大概下面的结论。

    1.每个标志位的"continue"说明该分支break。

    2.最后一个分支的标志是if (true) goto _Lx,else goto _x。

    同时,还有些疑问,没弄明白?

    我写了好几个switch的例子,反编译出来的代码有一个共同规律。

    反编译代码1:

    JVM INSTR tableswitch 1 3: default 56

    //1 73//2 84//3 95;

    goto _L1 _L2 _L3 _L4

    反编译代码2:

    JVM INSTR tableswitch 0 2: default 60

    //0 77//1 88//2 99;

    goto _L1 _L2 _L3 _L4

    这两个,标明 1, 2,3相互之间数值都相差11。第二个也是。这个搞不懂?同时,这些数值代表什么?

    如果以上哪些不对的地方,请大家指正。

    (转自:http://blog.csdn.net/bage1988320/article/details/6690845)

    展开全文
  • 今天遇到一个问题,就是设计了两个枚举,一个是状态枚举(EnumA)一个是动作枚举(EnumB),状态枚举定义了当前状态的可以进行的操作,操作枚举定义了执行了此操作后的下一个状态。具体代码如下:public enum EnumA {...

    今天遇到一个问题,就是设计了两个枚举,一个是状态枚举(EnumA)一个是动作枚举(EnumB),状态枚举定义了当前状态的可以进行的操作,操作枚举定义了执行了此操作后的下一个状态。

    具体代码如下:

    public enum EnumA {

    STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),

    STATUS_B("STATUS_B", "状态B", null);

    private String code;

    private String desc;

    private List operation;

    }

    EnumA(String code, String desc, List operation) {

    this.operation = operation;

    this.code = code;

    this.desc = desc;

    }

    public enum EnumB {

    OPERATION_A("OPERATION_A", "操作1", EnumA.STATUS_B);

    private String code;

    private String desc;

    private EnumA next;

    }

    EnumB(String code, String desc, EnumA next) {

    this.next = next;

    this.code = code;

    this.desc = desc;

    }

    当我按照这种定义去声明枚举值常量时,编译器并没有错误提示。

    但是执行的时候结果如下:

    public static void main(String[] args) {

    System.out.println(EnumB.OPERATION_A.getNext());

    System.out.println(EnumA.STATUS_A.getOperation());

    }

    624d7746418d

    image.png

    public static void main(String[] args) {

    System.out.println(EnumA.STATUS_A.getOperation());

    System.out.println(EnumB.OPERATION_A.getNext());

    }

    624d7746418d

    image.png

    可以看出来,首先被使用到的枚举值中的内容是完整的。原因简单分析一下便容易明白,当第一个枚举值(例如是EnumA)被使用的时候,虚拟机查到这个EnumA的实例还没有加载,便调用构造函数去实例化。构造函数中需要EnumB的某个实例,所以虚拟机会调用EnumB的构造函数去实例化EnumB,但是此时EnumA还没有实例化完成,拿到的指针为NULL,所以EnumB中的类型为EnumA的属性便为NULL。

    解决方法

    对症下药的想法就是将两个枚举的关系在初始化层面解除耦合,但是带来的问题是两个枚举又需要使用对方的实例,什么时候将对方的实例填充进去呢?初步想法是当首先被调用的枚举实例化完成后将此枚举的实例填入另外一个枚举属性中。

    那第二个问题便是如何让首先使用的枚举实例化后自动的开始填充动作呢?映入脑海的应该是代码块了,它是类加载的时候会自动执行的代码逻辑。所以是否可以采用在构造函数下方添加一个代码块来让枚举实例化(调用构造函数)后执行相应的代码呢?

    具体代码如下:

    public enum EnumA {

    STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),

    STATUS_B("STATUS_B", "状态A", null);

    private String code;

    private String desc;

    private EnumB operation;

    EnumA(String code, String desc, EnumB next) {

    this.code = code;

    this.desc = desc;

    this.operation = next;

    }

    {

    EnumB.OPERATION_A.setNext(STATUS_B);

    }

    }

    但是添加了代码后,编译器明显的提示像是对我说:“小伙子想的太简单了”。

    624d7746418d

    image.png

    这段代码有一个警告和一个编译错误,他们的内容分别如下:

    624d7746418d

    image.png

    624d7746418d

    image.png

    这里说明了,枚举实例是静态的,就是和静态成员变量(用static修饰的变量)是同一个级别的。但是他们的初始化又是利用构造函数才可以完成的,执行了构造函数则必然会执行代码块。因为实例化要一个一个执行,所以代码块执行的时候其他的某些枚举实例还没有创建,所以需要使用静态代码块来完成填充的动作。

    所以正确的方式如下:但是并不是完美解决了,需要看文章最后一部分的说明

    public enum EnumA {

    STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),

    STATUS_B("STATUS_B", "状态A", null);

    private String code;

    private String desc;

    private EnumB operation;

    static {

    EnumB.OPERATION_A.setNext(STATUS_B);

    }

    EnumA(String code, String desc, EnumB next) {

    this.code = code;

    this.desc = desc;

    this.operation = next;

    }

    }

    枚举实例加载顺序

    这里做了一个实验,可以观察到枚举实例在实例化时的执行顺序:

    public enum EnumA {

    STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),

    STATUS_B("STATUS_B", "状态A", null);

    private String code;

    private String desc;

    private EnumB operation;

    static {

    System.out.println("static:");

    }

    EnumA(String code, String desc, EnumB next) {

    this.code = code;

    this.desc = desc;

    this.operation = next;

    System.out.println("constructor:" + this);

    }

    {

    System.out.println("init:" + this);

    }

    }

    624d7746418d

    image.png

    可见在实例化的时候,构造函数和代码块依次执行。当全部枚举实例都实例化完成后静态代码块才会执行,逻辑比较简单,毕竟枚举实例属于静态变量,当前的状态还是处于类级别初始化阶段,只不过初始化要用到具体对象的实例化逻辑,才会调用到构造函数和代码块,当全部枚举实例实例化完成后,类初始化完毕后便会执行静态代码块中的逻辑。

    写在最后

    这一点是在完成总结的时候想到的,因为上述方案只是在EnumA中进行了属性值的填充,但是它的前提是EnumA要优先在EnumB之前被调用,不然在EnumB实例化的时候会需要EnumA先实例化完成,但是填充逻辑是在EnumA中的,填充时又需要EnumB的实例,执行的话会报空指针。所以要保证枚举的加载顺序才行

    解决方法

    第一步:将没有填充逻辑的枚举中构造函数中的入参中去掉类型为另外一个枚举的变量,这样做才可以保证正常的初始化。

    第二步:在没有填充逻辑的枚举中的静态代码块中调用一下有填充逻辑的枚举,这样就会触发实例化另外一个枚举的动作,并且执行填充逻辑。这样即使没有填充逻辑的枚举优先被调用,也可以获取到正常的值。

    具体代码如下:

    public enum EnumB {

    OPERATION_A("OPERATION_A", "操作1");

    private String code;

    private String desc;

    @Setter

    private EnumA next;

    static {

    EnumA init = EnumA.STATUS_A;

    }

    EnumB(String code, String desc) {

    this.code = code;

    this.desc = desc;

    }

    }

    展开全文
  • // 这时数组还没有初始化,不能使用* 2. 在定义时,初始一个数组 int iArr = new int[5]; //初始化为5个元素数组,为[0,0,0,0,0]* 3. 在定义时初始化一个数组 int iArr2 = {1,2,3,4,5};* 上面这种方式只能在定义时可以...

    import java.util.Arrays;

    /**

    * 1. 定义一个数组 int[] iArr; // 这时数组还没有初始化,不能使用

    * 2. 在定义时,初始一个数组 int iArr = new int[5]; //初始化为5个元素数组,为[0,0,0,0,0]

    * 3. 在定义时初始化一个数组 int iArr2 = {1,2,3,4,5};

    * 上面这种方式只能在定义时可以,假如int[] iArr; iArr = {1,2,3,4,5}; // 这样分两步不行

    *

    */

    public class TestArray

    {

    /**

    * 可变参数的函数

    * int ... args 这样的参数方式,表示可以传递任意多的参数给variableAgrs,

    * 在variableAgrs函数中args当成数组对待

    */

    public static void variableAgrs(int ... args)

    {

    System.out.println(args.length); //参数个数

    int iLen = args.length;

    for (int i=0;i

    {

    System.out.print(args[i]);

    }

    System.out.println("");

    }

    /**

    * 创建一个简单的枚举

    * 创建Spiciness后,指定的类似NOT这样的都是Spiciness的实例

    * Spiciness实例自动具有一些方法,比如toString(),ordinal()

    * Spiciness具有动态方法values();这个方法按照Spiciness中常量实例定义的顺序生成数组

    */

    enum Spiciness

    {

    NOT,MILD,MEDIUM,HOT,FLAMING

    }

    public static void main(String[] args)

    {

    //数组初始化

    int[] iArr = new int[5]; //5五个元素被初始化为[0,0,0,0,0]

    System.out.println(Arrays.toString(iArr));

    int[] iArr2 ;

    //System.out.println(Arrays.toString(iArr2)); //编译不通过,数组需要初始化

    //iArr2 = {1,2,3,4,5};编译不通过

    iArr2 = new int[3];

    System.out.println(Arrays.toString(iArr2));

    //{1,2,3,4,5} 这种方式初始化数组,只能在定义时,比如

    int[] iArr3 = {1,2,3,4,5};

    System.out.println(Arrays.toString(iArr3));

    //可变参数调用,可以传递0~任意多的参数

    variableAgrs();//输出 0

    variableAgrs(1); //输出 1 1

    variableAgrs(1,2);//输出 2 12

    variableAgrs(iArr3); //甚至,可以传递数组引用, 输出 5 12345

    //枚举

    Spiciness spiciness = Spiciness.HOT;

    System.out.println(spiciness.toString()); //输出 HOT

    System.out.println(spiciness.ordinal()); //输出 3

    System.out.println(Arrays.toString(Spiciness.values())); //输出 [NOT, MILD, MEDIUM, HOT, FLAMING]

    //枚举可在switch中使用

    switch(spiciness)

    {

    case NOT:

    {

    System.out.println("Not");

    break;

    }

    case MILD:

    {

    System.out.println("MILD");

    break;

    }

    case MEDIUM:

    {

    System.out.println("MEDIUM");

    break;

    }

    case HOT:

    {

    System.out.println("HOT");

    break;

    }

    case FLAMING:

    {

    System.out.println("FLAMING");

    break;

    }

    default:

    {

    System.out.println("default");

    break;

    }

    }

    }

    }

    赞 赏

    展开全文
  • JAVA初始化及使用enum枚举类型

    万次阅读 2018-04-02 21:20:41
    在使用enum之前,需要先创建一个整型常量集,但枚举值并不会取值限定在这个常量集的范围内,因此,具有一定的风险,且较难使用。枚举类型的创建,public enum Spiciness{ NOT,MILD,MEDIUM,HOT,FLAMING }创建枚举类型...

    在使用enum之前,需要先创建一个整型常量集,但枚举值并不会取值限定在这个常量集的范围内,因此,具有一定的风险,且较难使用。


    枚举类型的创建,

    public enum Spiciness{
        NOT,MILD,MEDIUM,HOT,FLAMING
    }

    创建枚举类型时编译器会自动添加一些特性,如会自动创建toString()方法,以便你可以很方便的显示某个enum实例的名字,除此之外,还会创建ordinal()方法,用于表示某个特定enum常量的声明顺序;还有static values()方法,按照enum常量的声明,产生由这些常量构成的数组:


    实例如下:

    public class SimpleEnumUse {
    public enum Spiciness{
    	NOT,MILD,MEDIUM,HOT,FLAMING
    }
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Spiciness hotHot= Spiciness.MEDIUM;
    		System.out.println(hotHot);
    		for(Spiciness s:Spiciness.values())          //value()方法用来产生顺序数组
    			System.out.println(s+",ordinal "+s.ordinal());//ordinal()方法用来声明顺序
    	}
    }
    /* Output:
    NOT,ordinal 0
    MILD,ordinal 1
    MEDIUM,ordinal 2
    HOT,ordinal 3
    */

    由此可见,可以把enum当作其他类来处理。事实上enum确实是类,而且可以用有限的可能值集合配合switch使用。

    如下,

    import thinkinginjava5_.SimpleEnumUse.Spiciness;
    class Burrito{
    	Spiciness degree;
    	public Burrito(Spiciness degree) {
    		// TODO Auto-generated constructor stub
    		this.degree=degree;
    	}
    	public void describe(){
    		System.out.print("This burrito is ");
    		switch(degree){
    		case NOT:System.out.println("not spicy at all.");
    			break;
    		case MILD:
    		case MEDIUM:System.out.println("a little hot");
    		break;
    		case HOT:
    		case FLAMING:System.out.println("maybe too hot");
    		break;
    		}
    	}
    }
    public class SimpleEnumUse {
    public enum Spiciness{
    	NOT,MILD,MEDIUM,HOT,FLAMING
    }
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub		
    		Burrito plain=new Burrito(Spiciness.NOT),
    		greenChile=new Burrito(Spiciness.MEDIUM),
    		jalapeno=new Burrito(Spiciness.HOT);
    		plain.describe();
    		greenChile.describe();
    		jalapeno.describe();
    		
    	}
    }
    /*Output 
    This burrito is not spicy at all.
    This burrito is a little hot
    This burrito is maybe too hot
     */



    展开全文
  • 今天写枚举类的时候发现了一个有趣的现象,在这里分享一下: 首先我们定义一个简单的枚举类: /** * @author jinghuaixin * @date 2020/04/30 */ public enum Week { Monday, Tuesday; // 静态代码块 static ...
  • 1. 如何自定义枚举类提供类的属性,声明为 private final声明为 final 的属性,在构造器中初始化通过公共方法(get)方法来调用属性创建枚举类的对象:将类的对象声明 public static final举例如下:class Season {//1...
  • public enum AAA { S111,SBBB,SCCC; private AAA() { System.out.println("123"); } } public class TestMain { public static void main(String [] args) { ...three 123
  • 在看http_errno展开的时候,发现由HTTP_ERRNO_GEN通过HTTP_ERRNO_MAP的生成的枚举"XX_UNKNOWN,"多一个逗号,而编译器并不报错,而是接受它了。这明明是一个语法错误么!...发现不仅仅是C如此,java...
  • 您可以将枚举用作单身人士enum Singleton {INSTANCE;}假设您的单身人士在单元测试中做了不受欢迎的事情,你可以;// in the unit test before using the Singleton, or any other global flag.System.setProperty(...
  • 类中可以拥有的成分1. Field (有static类来调用,没有实例调用)2. 方法3....5. 内部类/枚举/接口执行性语句(包括循环、分支、创建对象、赋值、调用方法),只能放在方法、构造器、初始化块。初始化块的...
  • java 枚举_Java枚举

    2021-03-05 14:26:27
    2. 每一个枚举元素初始化时都会执行一次构造函数;3. ordinal()方法获取的是枚举元素所在的索引位置,位置以0开始,枚举元素位置移动,该返回值也会移动。 因此ordinal()方法是时常变化的,使用需谨慎;4. compareTo...
  • public enum ResultEnum {   SUCCESS ("200","成功"),   FAILURE ("500","发生异常");...关联数据用于对枚举实例进行初始化 转载于:https://www.cnblogs.com/feng9exe/p/11316333.html
  • Java-初始化与清理

    2020-12-06 21:18:18
    1、构造器初始化。 2、方法重载 3、this关键字 4、static关键字 5、清理 6、成员初始化 7、数据初始化 8、枚举类型 一、构造器初始化 Java对象有默认构造器,是以类名命名的无参构造器。 显示指定构造器后,Java...
  • java 枚举

    2019-10-03 16:45:37
    声明为 final 的属性,在构造器中初始化 通过公共方法(get)方法来调用属性 创建枚举类的对象:将类的对象声明 public static final 举例如下: class Season { //1. 提供类的属性,声明为 private fi...
  • java 枚举

    2018-07-26 08:55:27
    Java 枚举型就是一个常量的集合 枚举型中的构造器 只是用来初始化的 用户并不会主动调用  
  • 我发现它有枚举的凝灰岩.这是Kathy Siera书中的一个例子:public class WeatherTest {static Weather w;public static void main(String[] args) {System.out.print(w.RAINY.count + " " + w.Sunny.count + " ");}}...
  • Android Java 枚举

    2019-05-25 16:15:29
    Android Java 枚举 知识点:枚举 枚举在C / C++ / c# 中...如果枚举没有初始化, 则从第一个标识符开始,顺次赋给标识符0, 1, 2, …。但当枚举中的某个成员赋值后,其后的成员按依次加1的规则确定其值 enum Num { ...
  • 静态数据初始化 无论创建了多少个对象,静态数据都只占用一份存储区域。static关键字不能应用于局部变量,因此他只作用于域。如果一个域时基本的静态类型域,且也没有对他进行初始化,那么它就会获得基本类型的标准...
  • JAVA 枚举类型详解

    2020-09-02 18:05:40
    二、自定义枚举三、JAVA枚举类型总结 前言 JDK1.5之前,只能使用自定义实现枚举,JDK1.5后,引入了枚举类型,本文将从自定义枚举类型的创建开始,详解JAVA的枚举类型。 一、枚举是什么? 可以理解为,一个JAVA类...
  • java枚举

    2021-02-10 19:42:35
    3. 对象如果有实例变量,应该声明为private final,并在构造器中初始化 class Season{ private final String SEASONNAME;//季节的名称 private final String SEASONDESC;//季节的描述 private Season(String ...
  • java 枚举 参数传递

    千次阅读 2020-01-21 17:10:22
    具体问题是这样的,JAVA定义一个枚举(如 RED、BLUE、GREEN)对象,初始值为RED,作为一个方法的参数传入,在方法中对该枚举对象进行修改(修改为BLUE),在调用该方法后,该对象还是为RED,如何使方法对对象的修改...
  • 如何处理编译器错误:空白最终字段standardAttributesList可能尚未初始化? +0 只是想知道:在你的枚举中有一个成员函数是否有意义为你做到这一点?如果拥有这个枚举的唯一原因是收集一个可能的枚举值列表并为其...
  • java 枚举Demo

    2019-12-14 17:46:35
    //元素 指的是 枚举类 里面的所有常亮 enum Weekday { //周一到周五 常量 SUN(0), MON(1), TUS(2), WED(3), THU(4), FRI(5), ... //我们定义了一个int变量,然后通过构造函数初始化这个变量。 private int val...
  • Java枚举的本质原理是通过普通类来实现的,只是编译器为我们做了加工处理,每个枚举类型编译后的字节码实质都是继承自java.lang.Enum的枚举类型同名普通类,每个枚举变量实质是一个与枚举类型同名普通类的静态常量...

空空如也

空空如也

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

java枚举初始化

java 订阅