betway必威-betway必威官方网站
做最好的网站

Python的高级语法与用法,Enum使用分析

一,枚举

枚举,

Java 5新扩充了2个enum关键字(它与class、interface关键字的地点同样),用以定义枚举类。正如前方看到的,枚举类是1种万分的类,他同样能够有谈得来的积极分子变量、方法,可以落成1个或四个接口,也能够定义自身的构造器。贰个Java源文件中最四只可以定义一个public访问权限的枚举类,且java源文件也必须和该枚举类的类名一样。

但枚举类毕竟不是普通类,它与普通类有如下轻巧分歧。 
(一)枚举类可以实现一个或八个接口,使用enum定义的枚举类默许承接了java.lang.Enum类,而不是默许承袭Object类,因而枚举类不可能显得延续其余父类。在那之中java.lang.Enum类完结了java.lang.Serializable和java.lang.Comparable两个接口。 
(2)使用enum定义、非抽象的枚举类暗中认可会选用final修饰,由此枚举类不能够派生子类。 
(3)枚举类的构造器只好选择private访问调整符,假使不难了构造器的走访调整符,则暗中同意使用private修饰;假若强制钦赐访问调节符,则不得不内定private修饰符。 
(四)枚举类的享有实例必须在枚举类的率先行显式列车,不然这些枚举类永世都不能够发出实例。列出那么些实例时,系统会活动增加public static final修饰,无须程序猿显式增多。

下边正是八个特出枚举类型的概念:

Java代码:

  1. public enum Color{  
  2. RED,BLUE,BLACK,YELLOW,GREEN  

 

鲜明,enum很像非常的class,实际上enum评释定义的门类正是2个类。 而这么些类都是类库中Enum类的子类(java.lang.Enum)。它们继续了那一个Enum中的多数卓有功效的方法。大家对代码编写翻译之后开采,编写翻译器将enum类型单独编写翻译成了二个字节码文件:Color.class。

Color字节码代码

  1. final enum hr.test.Color {  
  2. // 全数的枚举值都以类静态常量  
  3. public static final enum hr.test.Color RED;  
  4. public static final enum hr.test.Color BLUE;  
  5. public static final enum hr.test.Color BLACK;  
  6. public static final enum hr.test.Color YELLOW;  
  7. public static final enum hr.test.Color GREEN;  
  8. private static final synthetic hr.test.Color[] ENUM$VALUES;  
  9. // 初始化进度,对枚举类的享有枚举值对象开始展览第2遍起首化  
  10. static {  
  11. 0 new hr.test.Color [1]  
  12. 3 dup  
  13. 四 ldc [1⑥] //把枚举值字符串“RED”压入操作数栈  
  14. 6 iconst_0 // 把整型值0压入操作数栈  
  15. 柒 invokespecial hr.test.Color(java.lang.String, int) [一柒] //调用Color类的个体构造器创造Color对象RED  
  16. 十 putstatic hr.test.Color.RED : hr.test.Color [二1] //将枚举对象赋给Color的静态常量RED。  
  17. 。..。..。.. 枚举对象BLUE等与上同  
  18. 102 return 
  19. };  
  20. // 私有构造器,外部不容许动态创造1个枚举类对象(也正是不恐怕动态创制八个枚举值)。  
  21. private Color(java.lang.String arg0, int arg1){  
  22. // 调用父类Enum的受保证构造器成立3个枚举对象  
  23. 3 invokespecial java.lang.Enum(java.lang.String, int) [38]  
  24. };  
  25. public static hr.test.Color[] values();  
  26. // 实现Enum类的用空想来欺骗别人方法  
  27. public static hr.test.Color valueOf(java.lang.String arg0);  

 

上面大家就详细介绍enum定义的枚举类的天性及其用法。(前边均用Color例如)

一、Color枚举类正是class,而且是一个不能被一连的final类。

其枚举值(RED,BLUE.。.)都以Color类型的类静态常量, 我们得以经过下边包车型大巴办法来博取Color枚举类的三个实例:

  1. Color c=Color.RED; 

 

瞩目:那个枚举值都以public static final的,也正是大家平时所定义的常量方式,因而枚举类中的枚举值最佳1切大写。

2、即然枚举类是class,当然在枚举类型中有构造器,方法和数据域。

不过,枚举类的构造器有一点都不小的不一样:

(一) 构造器只是在构造枚举值的时候被调用。

Java代码:

  1. enum Color{  
  2. RED(255,0,0),BLUE(0,0,255),BLACK(0,0,0),YELLOW(255,255,0),GREEN(0,255,0);  
  3. //构造枚举值,比方RED(25伍,0,0) //通过括号赋值,而且必须带有一个参构造器和一个属性跟方法,否则编译出错 ``//赋值必须都赋值或都不赋值,不能一部分赋值一部分不赋值;如果不赋值则不能写构造器  
  4. private Color(int rv,int gv,int bv){  
  5. this.redValue=rv;  
  6. this.greenValue=gv;  
  7. this.blueValue=bv;  
  8. }  
  9. public String toString(){ //覆盖了父类Enum的toString()  
  10. return super.toString() “(” redValue “,” greenValue “,” blueValue “)”;  
  11. }  
  12. private int redValue; //自定义数据域,private为了封装。  
  13. private int greenValue;  
  14. private int blueValue;  

(贰) 构造器只可以私有private,相对不容许有public构造器。 那样可以保障表面代码不能新布局枚举类的实例。那也是完全符合情理的,因为大家知道枚举值是public static final的常量而已。 但枚举类的法子和数据域可以允许外部访问。

Java代码:

  1. public static void main(String args[])  
  2. {  
  3. // Color colors=new Color(100,200,300); //wrong  
  4. Color color=Color.RED;  
  5. System.out.println(color); // 调用了toString()方法  

 

3、全体枚举类都持续了Enum的章程,下边大家详细介绍这几个方法。

(1) ordinal()方法: 重临枚举值在枚举类种的相继。这么些顺序依据枚举值申明的逐一而定。

  1. Color.RED.ordinal(); //再次回到结果:0  
  2. Color.BLUE.ordinal(); //重临结果:一 

 

(2) compareTo()方法: Enum达成了java.lang.Comparable接口,因而得以相比象与钦点对象的各类。Enum中的compareTo重回的是多少个枚举值的逐条之差。当然,前提是八个枚举值必须属于同一个枚举类,否则会抛出ClassCastException()格外。(具体可知源代码)

  1. Color.RED.compareTo(Color.BLUE); //再次回到结果 -一 

 

(3) values()方法: 静态方法,再次来到三个涵盖全体枚举值的数组。

  1. Color[] colors=Color.values();  
  2. for(Color c:colors){  
  3. System.out.print(c “,”);  
  4. }//再次回到结果:RED,BLUE,BLACK YELLOW,GREEN, 

 

(肆) toString()方法: 重返枚举常量的名号。

  1. Color c=Color.RED;  
  2. System.out.println(c);//重回结果: RED 

 

(5) valueOf()方法: 这一个主意和toString方法是相对应的,重回带钦点名称的钦命枚举类型的枚举常量。

  1. Color.valueOf(“BLUE”); //重回结果: Color.BLUE 

 

(六) equals()方法: 相比五个枚举类对象的引用。

Java代码:

  1. //JDK源代码:  
  2. public final boolean equals(Object other) {  
  3. return this==other;  

肆、枚举类能够在switch语句中动用。

Java代码:

  1. Color color=Color.RED;  
  2. switch(color){  
  3. case RED: System.out.println(“it‘s red”);break;  
  4. case BLUE: System.out.println(“it’s blue”);break;  
  5. case BLACK: System.out.println(“it‘s blue”);break;  

Java5新添了1个enum关键字(它与class、interface关键字的地点同样),用以定义枚举类。正如前方看到的,枚举类是1种奇特的类,他...

Enum的选用与分析,Enum使用剖析

示例:

package test;

public enum ColorEnum {
    RED,
    YELLOW,
    BLUE,
    GREEN,
    BLACK,;
}

明朗,enum很像特其他class,实际上enum证明定义的类别正是四个类。 而那个类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继续了这么些Enum中的诸多灵光的章程。我们对代码编写翻译之后开掘,编译器将enum类型单独编写翻译成了二个字节码文件:Color.class。

package test;


public final class ColorEnum extends Enum
{

    public static ColorEnum[] values()
    {
        return (ColorEnum[])$VALUES.clone();
    }

    public static ColorEnum valueOf(String s)
    {
        return (ColorEnum)Enum.valueOf(test/ColorEnum, s);
    }

    private ColorEnum(String s, int i)
    {
        super(s, i);
    }

    public static final ColorEnum RED;
    public static final ColorEnum YELLOW;
    public static final ColorEnum BLUE;
    public static final ColorEnum GREEN;
    public static final ColorEnum BLACK;
    private static final ColorEnum $VALUES[];

    static 
    {
        RED = new ColorEnum("RED", 0);
        YELLOW = new ColorEnum("YELLOW", 1);
        BLUE = new ColorEnum("BLUE", 2);
        GREEN = new ColorEnum("GREEN", 3);
        BLACK = new ColorEnum("BLACK", 4);
        $VALUES = (new ColorEnum[] {
            RED, YELLOW, BLUE, GREEN, BLACK
        });
    }
}

下面大家就详细介绍enum定义的枚举类的天性及其用法。(后边均用Color比方)

一、Color枚举类正是class,而且是1个不得以被一而再的final类。其枚举值(RED,BLUE...)都以Color类型的类静态常量, 大家能够由此下边的格局来赢得Color枚举类的3个实例:
                                                         Color c=Color.RED; 
小心:那个枚举值都是public static final的,也正是我们平日所定义的常量情势,由此枚举类中的枚举值最佳一切大写。 

二、即然枚举类是class,当然在枚举类型中有构造器,方法和数据域。可是,枚举类的构造器有相当的大的不及: 
      (一) 构造器只是在协会枚举值的时候被调用。

 1 package test;
 2 
 3 public enum ColorEnum {
 4     RED(255, 0, 0), BLUE(0, 0, 255), BLACK(0, 0, 0), YELLOW(255, 255, 0), GREEN(0, 255, 0);
 5 
 6     // 构造枚举值,比如RED(255,0,0)
 7     private ColorEnum(int rv, int gv, int bv) {
 8         this.redValue = rv;
 9         this.greenValue = gv;
10         this.blueValue = bv;
11     }
12 
13     public String toString() { // 覆盖了父类Enum的toString()
14         return super.toString()   "("   redValue   ","   greenValue   ","   blueValue   ")";
15     }
16 
17     private int redValue; // 自定义数据域,private为了封装。
18     private int greenValue;
19     private int blueValue;
20 }

      (贰) 构造器只可以私有private,相对不允许有public构造器。 那样能够确定保障表面代码不或者新协会枚举类的实例。那也是完全符合情理的,因为我们领略枚举值是public static final的常量而已。 但枚举类的法子和数据域能够允许外部访问。

public static void main(String args[])  
{  
        // Color colors=new Color(100,200,300);  //wrong  
           Color color=Color.RED;  
           System.out.println(color);  // 调用了toString()方法  
} 

3、全部枚举类都持续了Enum的章程,上边我们详细介绍这一个艺术。 
       (壹)  ordinal()方法: 重临枚举值在枚举类种的次第。那几个顺序依据枚举值注明的顺序而定。
                 ColorEnum.RED.ordinal();  //再次来到结果:0
                 ColorEnum.BLUE.ordinal();  //再次回到结果:一
       (二)  compareTo()方法: Enum已毕了java.lang.Comparable接口,由此能够比较象与钦定对象的逐条。Enum中的compareTo重回的是四个枚举值的依次之差。当然,前提是五个枚举值必须属于同多少个枚举类,不然会抛出ClassCastException()万分。(具体可知源代码)
                 ColorEnum.RED.compareTo(Color.BLUE);  //重返结果 -1
       (三)  values()方法: 静态方法,再次来到1个分包全部枚举值的数组。
                 ColorEnum[] colors=ColorEnum.values();
                 for(ColorEnumc:colors){
                        System.out.print(c ","); 
                 }//重临结果:RED,BLUE,BLACK YELLOW,GREEN,
       (肆)  toString()方法: 重临枚举常量的称号。
                 ColorEnum c=ColorEnum.RED;
                 System.out.println(c);//重回结果: RED
       (5)  valueOf()方法: 这几个方法和toString方法是相呼应的,重回带钦定名称的钦定枚举类型的枚举常量。
                 ColorEnum.valueOf("BLUE");   //重返结果: ColorEnum.BLUE
       (6)  equals()方法: 相比四个枚举类对象的引用。

//JDK源代码:      
public final boolean equals(Object other) {  
        return this==other;  
}               

肆、枚举类能够在switch语句中选择。

ColorEnum color = ColorEnum .RED;  
switch(color){  
        case RED: System.out.println("it's red");break;  
        case BLUE: System.out.println("it's blue");break;  
        case BLACK: System.out.println("it's blue");break;  
}  

 

示例: package test; public enum ColorEnum { RED, YELLOW, BLUE, GREEN, BLACK,;} 显著,enum很像极度的class,实际上enum证明定...

from enum import Enum     #引进枚举模块

class VIP(Enum):      #python中枚举既是类,而且要承接父类Enum

    YELLOW=1

    GREEN=2

    BLACK=3

    RED=4

print(VIP.YELLOW)     #获得的是枚举

print(VIP.YELLOW.value)

print(VIP.YELLOW.name)   #赢得的是str

结果:VIP.YELLOW #枚举类型    一 #枚举值    YELLOW#枚举的名字

 

贰,枚举的重命名

from enum import Enum     

class VIP(Enum):      

    YELLOW=1

    YELLOW_ALIAS=2   #在枚举中,要是七个数值是一样的话,能够叫做另一个的外号。

    BLACK=3

    RED=4

for v in VIP:

    print(v)        #此刻当打字与印刷的时候,是不会打字与印刷出外号来的。

假如想要打字与印刷出小名的话

for v in VIP.__member__.items():

    print(v)     #此时可打字与印刷出枚举的有着有关项

若果地点的出口太多,也能够

for v in VIP.__member__:

    print(v)

 

 

 

三,枚举类型转化

from enum import Enum     

class VIP(Enum):      

本文由betway必威发布于编程开发,转载请注明出处:Python的高级语法与用法,Enum使用分析

TAG标签: betway必威
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。