Java中的枚举(Enum)

基本概念

Java 枚举是一个特殊的类,一般表示一组常量,比如一年的 4 个季节,一个年的 12 个月份,一个星期的 7 天,方向有东南西北等。

Java 枚举类使用 enum 关键字来定义,各个常量使用逗号(,)来分割。枚举类和正常类一样,也可以有成员变量、实例方法、静态方法、抽象方法

比如列举一个颜色的枚举类,包含红、黄、蓝三个属性

public class test1 {

    enum Color{
        RED,
        YELLOW,
        BLUE
    }

    public static void main(String[] args) {
        System.out.println(Color.RED);
        System.out.println(RED);
    }
}

每个枚举都是通过 Class 在内部实现的,且所有的枚举值都是 public static final 的。

以上的枚举类 Color 转化在内部类实现:

class Color
{
     public static final Color RED = new Color();
     public static final Color YELLOW= new Color();
     public static final Color BLUE= new Color();
}

values(), ordinal() 和 valueOf() 方法

enum 定义的枚举类默认继承了 java.lang.Enum 类,并实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中:

  • values() 返回枚举类中所有的值。
  • ordinal()方法可以找到每个枚举常量的索引,就像数组索引一样。
  • valueOf()方法返回指定字符串值的枚举常量。
public class test1 {

    enum Color{
        RED,
        YELLOW,
        BLUE
    }

    public static void main(String[] args) {
//        System.out.println(Color.RED);
//        System.out.println(RED);

        System.out.println(Arrays.toString(Color.values()));
        System.out.println(YELLOW.ordinal());
        System.out.println(Color.valueOf("YELLOW"));
    }
}

输出:

1. 枚举类常量

//枚举类是一个特殊的class
//这个class相当于使用final static修饰,不能被继承
//他的构造方法强制被私有化,每一个枚举类有一个默认的构造方法private ColorEnum();
//所有的枚举都继承自java.lang.Enum类。由于 Java 不支持多继承,所以枚举对象不能再继承其他类
public enum Color {
    //每个枚举变量都是枚举类Color的实例,相当于RED=new Color(1),按序号来。
    //每个成员变量都是final static修饰
    RED,YELLOW,BLUE
}

测试:

    public static void main(String[] args) {
        for (Color color : Color.values()) {
            System.out.println(color+",ordinal:"+color.ordinal()+",name:"+color.name());
        }
    }

结果:

2. 带参数的枚举

public class test2 {
    /**
     * Monday (周一)
     * Tuesday (周二)
     * Wednesday (周三)
     * Thursday (周四)
     * Friday (周五)
     * Saturday (周六)
     * Sunday (周日)
     */
    enum Week{
        MONDAY(1),
        TUESDAY(2),
        WEDNESDAY(3),
        THURSDAY(4),
        FRIDAY(5),
        SATURDAY(6),
        SUNDAY(7);
        private Integer num;
        private Week(Integer num){
            this.num=num;
        }

        public static Integer getNum(Week week){
            return week.num;
        }
    }

    public static void main(String[] args) {
        System.out.println(Week.getNum(Week.FRIDAY));
    }
}

结果:

3. 覆盖枚举的方法

public class test2 {
    enum Week{
        MONDAY(1),
        TUESDAY(2),
        WEDNESDAY(3),
        THURSDAY(4),
        FRIDAY(5),
        SATURDAY(6),
        SUNDAY(7);
        private Integer num;
        private Week(Integer num){
            this.num=num;
        }
        public static Integer getNum(Week week){
            return week.num;
        }

        @Override
        public String toString() {
            return this.name()+"_"+this.num;
        }
    }

    public static void main(String[] args) {
        for (Week week : Week.values()) {
            System.out.println(week.toString());
        }
    }
}

结果:

4.在Switch中使用枚举

public class test2 {
    enum Week{
        MONDAY(1),
        TUESDAY(2),
        WEDNESDAY(3),
        THURSDAY(4),
        FRIDAY(5),
        SATURDAY(6),
        SUNDAY(7);
        private Integer num;
        private Week(Integer num){
            this.num=num;
        }
        public static Integer getNum(Week week){
            return week.num;
        }

        @Override
        public String toString() {
            return this.name()+"_"+this.num;
        }
    }

    public static void main(String[] args) {
        Week thursday = Week.THURSDAY;
        switch (thursday){
            case MONDAY:
                System.out.println("星期一");
                break;
            case TUESDAY:
                System.out.println("星期二");
                break;
            case WEDNESDAY:
                System.out.println("星期三");
                break;
            case THURSDAY:
                System.out.println("星期四");
                break;
            case FRIDAY:
                System.out.println("星期五");
                break;
            case SATURDAY:
                System.out.println("星期六");
                break;
            case SUNDAY:
                System.out.println("星期天");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

结果:

5.实现接口

我们创建的枚举类默认是被final修饰,并且默认继承了Enum类。因此不能再继承其他的类。但是可以去实现接口。

有这样一个判断场景。

if ("dog".equals(animalType)){
    System.out.println("吃骨头");
} else if ("cat".equals(animalType)) {
    System.out.println("吃鱼干");
} else if ("sheep") {
    System.out.println("吃草");
}

怎样用枚举来消除掉 if/else 呐,看下面的代码:

先定义一个接口,里面有一个通用方法 eat()

public interface Eat {
    //吃
    String eat();
}

然后创建枚举类实现这个接口

public enum AnimalEnum implements Eat {
 
    Dog(){
        @Override
        public void eat() {
            System.out.println("吃骨头");
        }
    },
 
    Cat() {
        @Override
        public void eat() {
            System.out.println("吃鱼干");
        }
    },
 
    Sheep() {
        @Override
        public void eat() {
            System.out.println("吃草");
        }
    }
 
}

调用的时候只需要一行代码:

public class Test {
    public static void main(String[] args) {
        AnimalEnum.valueOf("Cat").eat(); // 吃鱼干
    }
}

6.枚举类中定义抽象方法

枚举类除了可以实现接口外,还可以在枚举类中定义抽象方法,这样每个枚举的对象只要分别实现了此抽象方法即可。

enum Color{
    RED{
        public String getColor(){//枚举对象实现抽象方法
            return "红色";
        }
    },
    GREEN{
        public String getColor(){//枚举对象实现抽象方法
            return "绿色";
        }
    },
    BLUE{
        public String getColor(){//枚举对象实现抽象方法
            return "蓝色";
        }
    };
    public abstract String getColor();//定义抽象方法
}


public class Test{
    public static void main(String[] args) {
        for (Color c:Color.values()){
            System.out.print(c.getColor() + "、");
        }
    }
}

7.枚举实现懒汉式单例

/**
 * @Description: 枚举  线程安全
 */
public class SingletonExample {
 
    /**
     * 构造函数私有化,避免外部创建实例
     */
    private SingletonExample(){}
 
    private static SingletonExample getInstance() {
        return Singleton.INSTANCE.getInstance();
    }
 
    private enum Singleton {
        INSTANCE;
        private SingletonExample instance;
 
        // JVM 保证这个方法绝对只调用一次
        Singleton() {
            instance = new SingletonExample();
        }
 
        public SingletonExample getInstance() {
            return instance;
        }
    }
}

 

  • 4
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值