0
点赞
收藏
分享

微信扫一扫

枚举Enum

快乐小码农 2022-04-24 阅读 92
java
加载失败

目录

1、声明

2、代码

声明(性别)

switch(红绿灯)

3、常用方法

values() 方法

compareTo() ,valueOf()方法

ordinal（）方法

4、枚举的构造方法

5、枚举实现接口

无参

 1个参 

 2个参

String 

6、自定义枚举类

7、覆盖基类方法

1、声明

是一个特定类型的类。所有枚举都是Java中的新类java.lang.Enum的隐式子类

不能手工进行子类定义

声明：

  • 在枚举中需写全该枚举类型变量的每一个值，这些值称为枚举元素。
  • 命名规范：枚举名称，首字母大写，驼峰标识；其枚举值，全大写，下划线分割；
  • 任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。

使用：

  1. 枚举名 变量名=枚举名.枚举值         [使用枚举名.枚举值取得每一个枚举值]  
  2. 枚举名 变量名;
  3.  变量名=枚举名.枚举值

2、代码

  • 声明(性别)

public enum Gender {
    MALE,
    FEMALE
}


public class GenderTest {
    public static void main(String[] args) {
        Gender g = null; //定义枚举变量
        g = Gender.MALE;//给枚举赋//只能获取从已经定义好的枚举列表中枚举值
        System.out.println(g);
    }
}

  • switch(红绿灯)

public enum Signal {
    RED, YELLOW, GREEN
}

public class TrafficLight {
    Signal color = Signal.GREEN;
    public void change() {
        switch (color) {
            case RED: {
                color = Signal.GREEN;
                break;
            }
            case GREEN: {
                color = Signal.YELLOW;
                break;
            }
            case YELLOW: {
                color = Signal.RED;
                break;
            }
        }
    }
    public static void main(String[] args) {
        TrafficLight light = new TrafficLight();
        //初始化信号灯颜色
        light.color = Signal.GREEN;
        //改变红绿灯
        light.change();
        System.out.println(light.color);
    }
}

3、常用方法

  • values() 方法

    通过调用枚举类型的 values() 方法可以将枚举的所有成员以数组形式返回，也可以通过该方法获取枚举类型的成员。

public class SignalValuesTest {
    public static void main(String[] args) {
        //value()  获取定义枚举值列表，以数组的形式返回
        Signal[] values=Signal.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }
    }
}

  • compareTo() ,valueOf()方法

    调用 valueOf() 方法获取枚举的一个成员，再调用 compareTo() 方法进行比较，并输出结果

    Enum默认实现了java.lang.Comparable接口。

    枚举类型 变量=枚举类型.valueOf("枚举值")

    • 如果指定的数与参数相等返回0。
    • 如果指定的数小于参数返回 -1。
    • 如果指定的数大于参数返回 1。
public enum Gender {
    AAA,
    MALE,
    FEMALE
}

public class GenderTestForString {
    public static void main(String[] args) {
        //把字符串转成枚举类型
        //把字符串转成对象？可以
        //Gender g=Gender.valueOf("MALE1");//非法参数异常java.lang.IllegalArgumentException
        Gender g = Gender.valueOf("MALE");
        System.out.println(g);
        for (Gender gender : Gender.values()) {
            int result = g.compareTo(gender);
            System.out.println("g=" + g + ",gender=" + gender + ",result=" + result);
        }
    }
}
/*
MALE
g=MALE,gender=AAA,result=1
g=MALE,gender=MALE,result=0
g=MALE,gender=FEMALE,result=-1
*/

  • ordinal（）方法

    可以获取一个成员在枚举中的索引位置。下 面的示例创建一个包含 3 个成员的枚举类型 Signal，然后调用 ordinal() 方法输出 成员及对应索引位置

Signal[] values=Signal.values();
for(Signal s:values){
  System.out.println("索引："+s.ordinal()+"\t值："+s);
}
/*
索引：0  值：RED
索引：1  值：YELLOW
索引：2  值：GREEN
*/

4、枚举的构造方法

  • 枚举相当于一个类，它也是有构造方法的。如果显式地写出了枚举的构造方法，那么就必须在创造枚举对象时相应地显式引用，否则就会出错。这也是 Java的运行机制一。

  • 枚举中的每一个元素，都相当于一个对象的引用，这个元素可以有方法和字段

  • 枚举类被初始化时调用构造方法，每个构造方法将以成员声明顺序被调用:有几个枚举值就按顺序依次调用构造方法创建几个对象

  • 不能有public的构造方法，保证客户代码没有办法新建一个enum的实例。

  • 和在普通类里面定义变量一样定义其它任何类型的非枚举变量，这些变量可以用任何你想用的修饰符。

public enum Color {
//定义枚举列表（枚举的实例对象引用），如果定义了构造方法，显示调用构造方法
//定义枚举列表必须要放在最前面，每个枚举值之间用逗号隔开，最后一个用分号
    RED(), GREEN("绿色"){
        public String getColorName(){
            return this.getName();
        }
    }, YELLOW("黄色"){
        public String getColorName(){
            return this.getName();
        }
    }, BLUE("蓝色"){
        public String getColorName(){
            return this.getName();
        }
    };
    private String name;

    public String getName() {
        return name;
    }

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

    //private构造方法 只能在类的内部被使用
    Color() {
        System.out.println("无参构造方法被调用");
    }

    //从语法上不可以定义public构造方法，不希望枚举由其他人创建对象，只有自己内部来创建对象，可以很好地控制枚举列表
    private Color(String name) {
        this.name = name;
        System.out.println("有参被调用name=" + name);
    }

    public static void main(String[] args) {
        Color blue = Color.BLUE;
        System.out.println(blue);
        System.out.println(blue.name);
        System.out.println("---------------------");
        for (Color c : Color.values()) System.out.println(c);
        System.out.println("=====================");
        //String str="GREEN"和Color.GREEN是两种类型
        String str = "GREEN";
        //转换成枚举
        Color c = Color.valueOf(str);
        System.out.println(c.getName());
        System.out.println("=====================");
        String a = "123";
        String b = "456";
        //a+b进行算术运算
        System.out.println(a + b);//字符串拼接
        System.out.println(Integer.valueOf(a) + Integer.valueOf(b));
        System.out.println("=====================");
        System.out.println(Color.GREEN.getName());
        System.out.println(Color.YELLOW.getName());
    }
}
/*
无参构造方法被调用
有参被调用name=绿色
有参被调用name=黄色
有参被调用name=蓝色
BLUE
蓝色
---------------------
RED
GREEN
YELLOW
BLUE
=====================
绿色
=====================
123456
579
=====================
绿色
黄色
*/

5、枚举实现接口

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

  • 枚举可以实现接口,当一个枚举实现了一个接口之后，枚举中的每一个对象都要分别实现接口中的所有抽象方法

  • 除了实现抽象接口，枚举自己内部也可以定义抽象方法。一旦枚举自己也定义了 抽象方法，那么枚举中的每个对象都要分别的实现这些方法，不然会报错。

  • 代码构造 构造方法前的private可以省略不写，默认private

无参

public interface A {
    int ma();
}

static void test01(){
        //创建实现A接口的匿名类对象
        A a=new A() {
            @Override
            public int ma() {
                return 5;
            }
        };
        //方法体只有一行代码可省略大括号，返回值不用return
        A b=()->5;
        A c=()->{
            return 5;
        };
        //标准写法
        A d=()->{
        //System.out.println("ni");
            return 0;
        };
        System.out.println(a.ma());
        System.out.println(b.ma());
        System.out.println(c.ma());
        System.out.println(d.ma());
        System.out.println("=================");
    }
/*
5
5
5
ni
0
*/

 1个参 

public interface B {
    int ma(int x);
}

static void test02(){
//创建实现B接口的匿名类对象
//        B b=new B() {
//            @Override
//            public int ma(int x) {
//                return 2*x;
//            }
//        };
//        //标准写法
//        B b=x->2*x;
        B b=(int x)->{return 2*x;};
        System.out.println(b.ma(10));
    }

 2个参

public interface C {
    int ma(int x,int y);
}

static void test03(){
//        C c=new C() {
//            @Override
//            public int ma(int x, int y) {
//                return x+y;
//            }
//        };
//        C c=(int x,int y)->{
//            return x+y;
//        };
        C c=(x,y)->x+y;
        System.out.println(c.ma(10,20));
    }

String 

@FunctionalInterface
public interface D {
    void String(String str);
}

static void test04(){
//        D d=new D() {
//            @Override
//            public void String(String str) {
//                System.out.println(str);
//            }
//        };
//        D d=(String str)->{
//            System.out.println(str);
//        };
        D d=str-> System.out.println(str);
        System.out.println("qwer");
    }
}

6、自定义枚举类

  • 所有枚举值都是public , static , final的
  • 步骤如下:

    • 声明枚举类型,在枚举值列表最后一列加分号,注意枚举值必须写在最前面.

    • 在枚举值列表后加括号,括号里边写实参值,是传给构造方法用的

    • 写枚举的私有的构造方法,形参类型要跟枚举值的实参列表类型一致

    • 在枚举值后面写私有的成员变量,一般情况下应该和构造方法的形参保持一致 ，写成员变量的getter和setter方法

enum WeekDay{  
    Mon("Monday"),
    Tue("Tuesday"),
    Wed("Wednesday"),
    Thu("Thursday"),
    Fri("Fr iday"),
    Sat("Saturday"),
    Sun("Sunday");//优先列举枚举值
    //以上是枚举的成员，必须先定义，而且使用分号结束
    private String day;//成员属性.定义其它任何类型的非枚举变量
    private WeekDay(String day){//构造方法，在列举枚举值时调用
        this.day=day;
    }
    //写成员变量的getter和setter方法
    public String getDay(){
        return day;
    }
    //普通方法
    public static void printDay(int i){//自定义方法 
        switch(i) {
            case 1:
                System.out.println(WeekDay.Mon);
                break;
            case 2:
                System.out.println(WeekDay.Tue);
                break;
            case 3:
                System.out.println(WeekDay.Wed);
                break;
            case 4:
                System.out.println(WeekDay.Thu);
                break;
                    case 5:
                System.out.println(WeekDay.Fri);
                break;
            case 6:
                System.out.println(WeekDay.Sat);
                break;
            case 7:
                System.out.println(WeekDay.Sun);
                break;
            default:
                System.out.println("wrong number!");
        }
    }
   
    public static void main(String[] args) {
        for(WeekDay day:WeekDay.values()){
            System.out.println(day+"====>"+day.getDay());
        }
        WeekDay.printDay(5);
    }
}
/*
Mon====>Monday 
Tue====>Tuesday 
Wed====>Wednesday 
Thu====>Thursday 
Fri====>Friday 
Sat====>Saturday 
Sun====>Sunday 
Fri
*/

7、覆盖基类方法

public class Test{
    public enum Color{
        RED("红色",1),
        GREEN("绿色",2),
        WHITE("白色",3),
        YELLOW("黄色",4);
        //成员变量
        private String name;
        private int index;
        //构造方法
        private Color(String name,int index){
            this.name=name;
            this.index=index;
        }
        //覆盖方法
        @Override
        public String toString(){
            return this.index+"-"+this.name;
        }
    }
    public static void main(String[] args){
        System.out.println(Color.RED.toString());    //输出：1-红色
    }
}
举报

相关推荐

enum枚举

c语言

枚举enum

java开发语言后端

java Enum 枚举

javaSystem枚举类OpenStack云计算

Java枚举(enum)

java开发语言SystemJavaListHtml/CSS前端开发

java枚举（enum）

java

TypeScript【enum 枚举】

typescriptjavascript前端

Enum枚举类

javamysql开发语言

枚举Enum使用

蓝桥杯算法数据结构排序算法eclipsejava

# TypeScript 枚举 enum

赋值枚举类型运算符Html/CSS前端开发

玩转枚举Enum

java服务器数据库Enum枚举JDK接口
0 条评论
加载失败