枚举类型

最新推荐文章于 2021-11-30 10:24:11 发布
最新推荐文章于 2021-11-30 10:24:11 发布
阅读量239 收藏
点赞数
分类专栏： think in java

传送门：http://blog.csdn.net/qq_27093465/article/details/52181860


JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给我的开发带来了“大”方便。

大师兄我又加上自己的理解，来帮助各位理解一下。

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 

Java代码 
  1. public enum Color {  
  2.   RED, GREEN, BLANK, YELLOW  
  3. }  

 

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。 

Java代码 
  1. enum Signal {  
  2.     GREEN, YELLOW, RED  
  3. }  
  4. public class TrafficLight {  
  5.     Signal color = Signal.RED;  
  6.     public void change() {  
  7.         switch (color) {  
  8.         case RED:  
  9.             color = Signal.GREEN;  
  10.             break;  
  11.         case YELLOW:  
  12.             color = Signal.RED;  
  13.             break;  
  14.         case GREEN:  
  15.             color = Signal.YELLOW;  
  16.             break;  
  17.         }  
  18.     }  
  19. }  

 

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 

Java代码 
  1. public enum Color {  
  2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.     // 成员变量  
  4.     private String name;  
  5.     private int index;  
  6.     // 构造方法  
  7.     private Color(String name, int index) {  
  8.         this.name = name;  
  9.         this.index = index;  
  10.     }  
  11.     // 普通方法  
  12.     public static String getName(int index) {  
  13.         for (Color c : Color.values()) {  
  14.             if (c.getIndex() == index) {  
  15.                 return c.name;  
  16.             }  
  17.         }  
  18.         return null;  
  19.     }  
  20.     // get set 方法  
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.     public void setName(String name) {  
  25.         this.name = name;  
  26.     }  
  27.     public int getIndex() {  
  28.         return index;  
  29.     }  
  30.     public void setIndex(int index) {  
  31.         this.index = index;  
  32.     }  
  33. }  

 

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。 

Java代码 
  1. public enum Color {  
  2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.     // 成员变量  
  4.     private String name;  
  5.     private int index;  
  6.     // 构造方法  
  7.     private Color(String name, int index) {  
  8.         this.name = name;  
  9.         this.index = index;  
  10.     }  
  11.     //覆盖方法  
  12.     @Override  
  13.     public String toString() {  
  14.         return this.index+"_"+this.name;  
  15.     }  
  16. }  

 

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。 

Java代码 
  1. public interface Behaviour {  
  2.     void print();  
  3.     String getInfo();  
  4. }  
  5. public enum Color implements Behaviour{  
  6.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  7.     // 成员变量  
  8.     private String name;  
  9.     private int index;  
  10.     // 构造方法  
  11.     private Color(String name, int index) {  
  12.         this.name = name;  
  13.         this.index = index;  
  14.     }  
  15. //接口方法  
  16.     @Override  
  17.     public String getInfo() {  
  18.         return this.name;  
  19.     }  
  20.     //接口方法  
  21.     @Override  
  22.     public void print() {  
  23.         System.out.println(this.index+":"+this.name);  
  24.     }  
  25. }  

 

用法六：使用接口组织枚举

 Java代码 

  1. public interface Food {  
  2.     enum Coffee implements Food{  
  3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
  4.     }  
  5.     enum Dessert implements Food{  
  6.         FRUIT, CAKE, GELATO  
  7.     }  
  8. }  

 

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

关于枚举的实现细节和原理请参考：

参考资料：《ThinkingInJava》第四版

http://softbeta.iteye.com/blog/1185573


我的这篇文章，因为是转载的，可能基本就没有变动，导致被某人踩了一脚。觉得不符合我大师兄的性格。下面我把自己的使用理解给整理一下。

也是因为因为当时刚刚开始学习吧。把平时自以为了解的东西都只是大概了解了一下，说到底，还是自以为了解了，其实转眼就不知道什么是什么了。
出来学习，不习惯看代码怎么能行呢？
下面是我自己的测试代码。


[java]  view plain  copy
  1. package com.lxk.enumTest;  
  2.   
  3. /** 
  4.  * Java枚举用法测试 
  5.  * <p> 
  6.  * Created by lxk on 2016/12/15 
  7.  */  
  8. public class EnumTest {  
  9.     public static void main(String[] args) {  
  10.         forEnum();  
  11.         useEnumInJava();  
  12.     }  
  13.   
  14.     /** 
  15.      * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
  16.      */  
  17.     private static void forEnum() {  
  18.         for (SimpleEnum simpleEnum : SimpleEnum.values()) {  
  19.             System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());  
  20.         }  
  21.         System.out.println("------------------");  
  22.         for (TYPE type : TYPE.values()) {  
  23.             System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());  
  24.         }  
  25.     }  
  26.   
  27.     /** 
  28.      * 在Java代码使用枚举 
  29.      */  
  30.     private static void useEnumInJava() {  
  31.         String typeName = "f5";  
  32.         TYPE type = TYPE.fromTypeName(typeName);  
  33.         if (TYPE.BALANCE.equals(type)) {  
  34.             System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");  
  35.         } else {  
  36.             System.out.println("大师兄代码错误");  
  37.         }  
  38.   
  39.     }  
  40.   
  41.     /** 
  42.      * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
  43.      * Ordinal 属性，对应的就是排列顺序，从0开始。 
  44.      */  
  45.     private enum SimpleEnum {  
  46.         SPRING,  
  47.         SUMMER,  
  48.         AUTUMN,  
  49.         WINTER  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
  55.      */  
  56.     private enum TYPE {  
  57.         FIREWALL("firewall"),  
  58.         SECRET("secretMac"),  
  59.         BALANCE("f5");  
  60.   
  61.         private String typeName;  
  62.   
  63.         TYPE(String typeName) {  
  64.             this.typeName = typeName;  
  65.         }  
  66.   
  67.         /** 
  68.          * 根据类型的名称，返回类型的枚举实例。 
  69.          * 
  70.          * @param typeName 类型名称 
  71.          */  
  72.         public static TYPE fromTypeName(String typeName) {  
  73.             for (TYPE type : TYPE.values()) {  
  74.                 if (type.getTypeName().equals(typeName)) {  
  75.                     return type;  
  76.                 }  
  77.             }  
  78.             return null;  
  79.         }  
  80.   
  81.         public String getTypeName() {  
  82.             return this.typeName;  
  83.         }  
  84.     }  
  85. }  



然后是测试的结果图：



简单的例子，大家基本都用过，看不懂的基本都是第二个例子。可以看到，在第二个例子里面，后面带有参数，其实可以这么理解。

enum这个关键字，可以理解为跟class差不多，这也个单独的类。可以看到，上面的例子里面有属性，有构造方法，有getter，也可以有setter，但是一般都是构造传参数。还有其他自定义方法。那么在这些东西前面的，以逗号隔开的，最后以分号结尾的，这部分叫做，这个枚举的实例。也可以理解为，class  new 出来的实例对象。这下就好理解了。只是，class，new对象，可以自己随便new，想几个就几个，而这个enum关键字，他就不行，他的实例对象，只能在这个enum里面体现。也就是说，他对应的实例是有限的。这也就是枚举的好处了，限制了某些东西的范围，举个栗子：一年四季，只能有春夏秋冬，你要是字符串表示的话，那就海了去了，但是，要用枚举类型的话，你在enum的大括号里面把所有的选项，全列出来，那么这个季节的属性，对应的值，只能在里面挑。不能有其他的。

我上面的例子，就是根据typeName，你可以从那些例子里面挑选到唯一的一个TYPE类型的枚举实例--TYPE.BALANCE。注意方法

TYPE type = TYPE.fromTypeName(typeName);
这个方法的返回类型就是这个TYPE枚举类型的。
这下就好理解，这个枚举是怎么在工作了吧

再补充一下：

上面那个带参数的枚举类型的实例里面实际上是三个属性，除了我自定义的typeName以外，还有2个是系统自带的。看下面源码的图：



看到这里之后，不知道你能不能理解下面图片内说明的话：下面图片主要说明在使用枚举时，的规范和标准。希望可以在实际开发时候用到



最后补充一点：

也许你知道呢，但是也许你不知道呢？我是真的不知道，测了之后才知道！！！

枚举类型对象之间的值比较，是可以使用==，直接来比较值，是否相等的，不是必须使用equals方法的哟。

具体，请参考下面的链接：

java 枚举类比较是用==还是equals？



转自：http://blog.csdn.net/yehui928186846/article/details/51426415

基本特性：

1，enum关键字 
枚举enum是同class，interface同一级别的特性。 
我们可以把enum看作一个抽象类，但是它又有它的不同之处，enum不能被继承。

这一点其实在Android源码中就得到了证实：

Public abstract class Enum<E extends Enum<E>> implements Serializable,Comparable <E>    
{   
   ...  
} 
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

从源码中可以看出Enum相当于一个抽象类。所以，enum可以看成一个抽象类并且和class、interface同级。

2，枚举的定义 
如何在Enum中定义枚举常量呢？ 
1，枚举常量没有任何修饰符 
2，每个常量以“，”分隔，以“；”结束枚举常量的描述。 
3，枚举常量必须定义在所有方法或者构造器之前。

规矩我们已经知道了，接下来就看看如何在代码里定义枚举常量了：

//枚举常量的定义可以在最后一个元素加，再加；结束。常量区分大小写
public enum OrdinaryEnums {
        red,
        RED,
        green,
        yellow,
        blue,;
    }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

3，使用枚举的目的 
当我们需要限制一系列变量的时候，通常想到数组或者集合；其实很多时候我们需要限定变量需要做的事情很多，或者说如果被限制的变量可以做其他事情的话就更好了，而不是单纯的一个变量（String，int，double）。

那么，枚举的作用不仅仅可以让你使用限制在一个enum中的变量，并且这些变量的灵活性和拓展性很好。 
举例说明： 
如果我们需要使用一些状态，比如一个星期的状态。 
我们可以用数组：

 String[] week=new String[7];
        week[0]="星期天";
        week[1]="星期一";
        week[2]="星期二";
        week[3]="星期三";
        week[4]="星期四";
        week[5]="星期五";
        week[6]="星期六";
        String weekday=week[0];
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

或者集合，这些表示大家都很熟悉。 
那么看看用枚举如何来写：

 public enum WeekEnums {
        //注：枚举写在最前面，否则编译出错
        Sunday,
        Monday,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday,;

        private static String getWeek(WeekEnums weekEnums) {
            String week = null;
            switch (weekEnums) {
                case Sunday://星期天
                    week = "星期天";
                    break;
                case Monday://星期一
                    week = "星期一";
                    break;
                case Tuesday:// 星期二
                    week = "星期二";
                    break;
                case Wednesday://星期三
                    week = "星期三";
                    break;
                case Thursday:// 星期四
                    week = "星期四";
                    break;
                case Friday://星期五
                    week = "星期五";
                    break;
                case Saturday://  星期六
                    week = "星期六";
                    break;
            }
            return week;
        }
    }
//获取方式：
String weekday = WeekEnums.getWeek(WeekEnums.Friday);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

可能，有人会说，这样写可是很麻烦。的确比数组或者集合麻烦了，但是它的拓展性是非常好的，因为往往我们需要的不仅仅是一个字符串，不仅仅是调用数字得到一个以供显示的星期，而是更多的逻辑处理。

我们来重写一下枚举中getWeek方法：

private static String getWeek(WeekEnums weekEnums) {
            String week = null;
            String behavior = null;
            switch (weekEnums) {
                case Sunday://星期天
                    week = "星期天";
                    behavior = "星期天我要去打球";//模仿一个逻辑处理
                    break;
                case Monday://星期一
                    week = "星期一";
                    behavior = "我要去上课";//模仿一个逻辑处理
                    break;
                case Tuesday:// 星期二
                    week = "星期二";
                    behavior = "我要去奶奶家";//模仿一个逻辑处理
                    break;
                case Wednesday://星期三
                    week = "星期三";
                    behavior = "我要去做义工";//模仿一个逻辑处理
                    break;
                case Thursday:// 星期四
                    week = "星期四";
                    behavior = "我要去做义工";//模仿一个逻辑处理
                    break;
                case Friday://星期五
                    week = "星期五";
                    behavior = "我要去做义工";//模仿一个逻辑处理
                    break;
                case Saturday://  星期六
                    behavior = "我要去做义工";//模仿一个逻辑处理
                    week = "星期六";
                    break;
            }
            return week;
        }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

这时候，枚举的有点久体现出来了，不仅仅可以获得状态，还可以在枚举中处理逻辑。 
这是数组或者集合无法做到了，而且枚举完成的逻辑不仅仅这些，还能完成更多更复杂的逻辑处理。

4，使用枚举

/**
 * 普通的枚举
 * 普通枚举在作用在于控制变量的范围，作用和数组、集合一样
 */
public class OrdinaryEnum {
    public enum OrdinaryEnums {
        red,
        green,
        yellow,
        blue,;
    }

    private void test(OrdinaryEnums ordinaryEnums) {
        switch (ordinaryEnums) {
            case red://表示红色的枚举
                break;
            case green://表示绿色的枚举
                break;
            case yellow://表示黄色的枚举
                break;
            case blue://表示蓝色的枚举
                break;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
**
 * 带属性的枚举
 * 通过枚举可以获得一个相应的结果
 */
public class AattributeEnum {

    public enum AattributeEnums {
        //注：枚举写在最前面，否则编译出错
        red,
        RED,
        green,
        yellow,
        blue,;
        private static int color = Color.WHITE;

        private static int getColor(AattributeEnums aattributeEnums) {
            switch (aattributeEnums) {
                case red://表示红色的枚举
                    color = Color.RED;
                    break;
                case green://表示绿色的枚举
                    color = Color.GREEN;
                    break;
                case yellow://表示黄色的枚举
                    color = Color.YELLOW;
                    break;
                case blue://表示蓝色的枚举
                    color = Color.BLUE;
                    break;
                case RED://表示蓝色的枚举
                    color = Color.RED;
                    break;
            }
            return color;
        }
    }

    private void test() {
        int color = AattributeEnums.getColor(AattributeEnums.red);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
/**
 * 带构造器的枚举
 * 枚举的构造器类似于类的构造方法
 * 不同的是，枚举的构造器只提供给内部的枚举变量使用
 * 外界调用具体的枚举变量就相当于执行了构造器中的逻辑
 */
public class ConstructorEnum {

    public enum ConstructorEnums {
        red(Color.RED),
        green(Color.RED),
        yellow(Color.RED),
        blue(Color.BLUE),;
        private int color;

        ConstructorEnums(int color) {
            this.color = color;
        }

        private int getColor() {
            return color;
        }
    }

    private void test() {
        int color = ConstructorEnums.red.getColor();
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
/**
 * 带抽象方法的枚举
 * 在枚举中定义抽象方法，那么这个抽象方法所有的枚举变量都要去实现；不管有多少个抽象方法都一样
 * 外界调用相对应的枚举变量中的抽象方法就可以让枚举处理自己实现的这个抽象方法的具体实现逻辑
 */
public class AbstractEnum {

    public enum AbstractEnums {
        red {
            public int getColor() {
                return Color.RED;
            }

            public String getWeek() {
                return "星期一";
            }
        },
        green {
            public int getColor() {
                return Color.GREEN;
            }

            public String getWeek() {
                return "星期一";
            }
        },
        yellow {
            public int getColor() {
                return Color.YELLOW;
            }

            public String getWeek() {
                return "星期一";
            }
        },
        blue {
            public int getColor() {
                return Color.BLUE;
            }

            public String getWeek() {
                return "星期一";
            }
        },;

        public abstract int getColor();

        public abstract String getWeek();
    }

    private void test() {
        int color = AbstractEnums.red.getColor();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

我们可以通过这四种方式根据不同的情景来使用相应的枚举处理一些复杂的逻辑。

总结： 
当我们在需要控制一个方法传入的参数的时候，并且这些参数可以自己处理一些事情的时候我们就可以选择枚举来实现。

例如：时间选择格式，我们可以用枚举来规定格式，然后外界只能调用枚举中的格式，然后枚举再去将规定的格式传给时间用于格式化。 
所有的逻辑处理交给枚举来完成，我们只需要调用相应的枚举类型就能得到想要的时间格式的时间。 
还有很多地方都体现出枚举的好处，例如：网络请求的接口定义；一些辑返回参数的定义；

只要是需要控制变量的数量或者范围，并且拿到变量后还需要处理一些逻辑的场景都可以用枚举来完成



pddzming
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Delphi 枚举类型操作 Demo
02-25
演示如何操作Delphi 的枚举类型。 1. 包含源代码； 2. 包含执行程序 3. 演示如下函数如何使用：GetEnumName、GetEnumProp、GetEnumValue、SetEnumProp 4. 非常简单，一看就会。
Java中的枚举类型
u010804417的博客
09-13 999
Java中的枚举类型简介枚举类型的声明枚举类型的使用 简介 枚举是一个使用 enum 关键字的整型常数集合，用于声明一组带标识符的常数，可以定义枚举的名称、可访问性、基础类型和成员等。 枚举类型的声明 任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。 枚举类型的使用 特别注意，如果需要在自定义类型以外通过set/get方法传递该枚举类型，需要添加public访问修饰符，如下方代码所示。 //自定义类型 public class Delivery
Java 枚举（enum）剖析
蚩尤后裔-汪茂雄
07-12 6745
目录 Java 枚举（enum）概述 枚举常量 属性与方法 枚举参数 实现接口 抽象方法 Java 枚举（enum）概述 1、Java JDK 1.5 新增的 enum 关键词，可以定义枚举类，如 public enum WeekEnum { }. 2、使用 enum 定义后的枚举类在编译后默认继承 java.lang.Enum 类，而不是普通的继承 Object 类。由于 Ja...
强哥说Java--枚举类和注解
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
11-30 542
枚举类和注解一、枚举类的使用1.如何自定义枚举类2.如何使用关键字enum定义枚举类3.Enum类的主要方法4.实现接口的枚举类二、注解（Annotation）1.注解(Annotation)概述2.常见的Annotation示例3.自定义Annotation4.JDK中的元注解5.利用反射获取注解信息(在反射部分涉及)6.JDK8中注解的新特性5.复习题 一、枚举类的使用 1.如何自定义枚举类 类的对象只有有限个，确定的。 当需要定义一组常量时，强烈建议使用枚举类 枚举类的属性 枚举类对象的属性不应允许
C语言使用枚举类型作为函数参数
Bryan要加油
08-14 2万+
c语言枚举类型enum用法参数,C语言枚举类型（Enum）
weixin_35967330的博客
05-18 3545
在实际编程中，有些数据的取值往往是有限的，只能是非常少量的整数，并且最好为每个值都取一个名字，以方便在后续代码中使用，比如一个星期只有七天，一年只有十二个月，一个班每周有六门课程等。以每周七天为例，我们可以使用#define命令来给每天指定一个名字：#include #define Mon 1#define Tues 2#define Wed 3#define Thurs 4#define Fri...
枚举类型的定义和应用总结
09-04
枚举类型（enumerated type），在编程语言中是一种强大的数据类型，它允许程序员定义一组具有特定名字的常量。这些名字通常表示特定的值，它们是整数类型的，且值的范围由程序员在定义时指定。枚举类型有助于提高...
Java中枚举类型的一种使用方式
08-18
"Java中枚举类型的一种使用方式" Java中枚举类型是一种非常有用的技术，它可以帮助我们简化代码，提高代码的可读性和可维护性。在本文中，我们将通过一个实际例子来介绍Java中枚举类型的一种使用方式。 首先，让...
深入解析c#中枚举类型的定义与使用
09-05
在C#编程语言中，枚举（Enum）是一种特殊的类型，它允许我们定义一组相关的命名常量。这些常量具有特定的基础类型，通常是整型，如Int32、Int16或Byte等。枚举可以提高代码的可读性和可维护性，避免了使用硬编码的...
SpringBoot 实战：优雅的使用枚举参数
沉潜飞动
08-10 5843
该图片由Sinousxl在Pixabay上发布 你好，我是看山。 接口开发过程中不免有表示类型的参数，比如 0 表示未知，1 表示男，2 表示女。通常有两种做法，一种是用数字表示，另一种是使用枚举实现。 使用数字表示就是通过契约形式，约定每个数字表示的含义，接口接收到参数，就按照约定对类型进行判断，接口维护成本比较大。 在 Spring 体系中，使用枚举表示，是借助 Spring 的 Converter 机制，可以将数字或字符串对应到枚举的序号或者 name，然后将前端的输入转换为枚举类型。 在场景..
Spring Boot绑定枚举类型参数
热门推荐
求知若饥，虚心若愚
03-17 5万+
一、概述 在利用Spring进行Web后台开发时，经常会遇到枚举类型的绑定问题。一般情况下，如果Spring接收到的参数值为字符串类型，Spring会根据枚举的值与传入的字符串进行对应。假设有如下枚举 public enum Gender { MALE, FEMALE; } 那么，只要客户端在发送请求时，将参数的值设为MALE或FEMALE即可。请求类似如下形式： http://loca
spring注入枚举类型作为参数
yingkongshi99的专栏
04-05 2万+
//定义枚举类型 public enum ReportType { MONTH,WEEK,DAY } //使用枚举类型 public class ReportJob { private ReportType reportType; } //spring配置文件注入 注意： 枚举类型要想注入到类中，一定要
Spring Boot 使用枚举类型作为请求参数
weixin_41249041的博客
07-21 1万+
https://xkcoding.com/2019/01/30/spring-boot-request-use-enums-params.html 1. 场景 在我们实际开发中，枚举类型应用十分广泛，可以避免在项目中定义大量的『魔法值』变量。但是，在 web 开发中，如何将枚举对象作为请求参数传进 Controller，做到类型自动转换？直接使用@RequestParam和@Reques...
使用反射设置枚举类型的参数
noetic_wxb的专栏
12-07 2107
public enum TestEnum { Test1, Test2, Test4 } public static void Func(TestEnum t) { System.Console.WriteLine(t.ToString
枚举类型 和 可变参数
请叫我王老魔
02-26 2297
定义可变参数: 一定要放在所有参数的最后面， sum(不可变类型，可变类型int… nums)，同时可变参数最多只能有一个 可以一个个参数传进去，也可以以数组的方式传进去。 格式 type … name// 这样定义意思是sum可以接收多个整型的的变量 public static int sum(int... nums){ int summ = 0; // 这样来使用 for
枚举的参数带入
qq_39632912的博客
01-18 2245
枚举对象可以带入多个参数。。。。。虽然到目前为止，这样没有什么意思。。。。。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值