Java的枚举类

标签：Java String 枚举 seasonName seasonDesc println public

枚举类型本质上也是一种类，只不过是这个类的对象是有限的、固定的几个，不能让用户随意创建
若枚举只有一个对象，则可以作为一种单例模式的实现方式
在开发中的使用场景
- 如果针对于某个类，其实例是确定的个数，则推荐此类声明为枚举类

枚举类的实现：

在JDK5.0 之前，需要程序员自定义枚举类型。
在JDK5.0 之后，Java支持enum关键字来快速定义枚举类型。

一、`jdk5.0`之前定义枚举类的方式

私有化类的构造器，保证不能在类的外部创建其对象
在类的内部创建枚举类的实例。声明为：public static final ，对外暴露这些常量对象

public class SeasonTest {
    public static void main(String[] args) {
        System.out.println(Season.spring.toString());
    }
}

class Season {
    // 声明当前类的对象的实例变量
    private final String seasonName;
    private final String seasonDesc;

    // 私有化类的构造器
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    // 提供实例变量的get方法

    public String getSeasonDesc() {
        return seasonDesc;
    }
    public String getSeasonName() {
        return seasonName;
    }

    // 创建当前类的实例
    public static final Season spring = new Season("春天", "春暖花开");
    public static final Season summer = new Season("夏天", "夏日炎炎");
    public static final Season autumn = new Season("秋天", "秋高气爽");
    public static final Season winter = new Season("冬天", "白雪皑皑");

    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

二、`jdk5.0`之后的定义方法

使用enum关键字来定义枚举类

public class SeasonTest02 {
    public static void main(String[] args) {
        System.out.println(Season1.spring.getClass());  // 输出： class com.atguigu02.Season1
        System.out.println(Season1.spring.getClass().getSuperclass());  // 输出： class java.lang.Enum
    }
}

interface Info {
    void show();
}

// jdk5.0中使用enum关键字定义枚举类
enum Season1 implements Info{
    // 1.必须在枚举类的开头声明多个对象，对象之间使用,隔开
    // public static final 都省略了
    spring("春天", "春暖花开"),
    summer("夏天", "夏日炎炎"),
    autumn("秋天", "秋高气爽"),
    winter("冬天", "白雪皑皑");

    private final String seasonName;
    private final String seasonDesc;

    private Season1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }

    @Override
    public void show() {
        System.out.println("这是一个季节");
    }
}

1、enum定义枚举类的注意事项：

使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类。同时，说明枚举本质上还是类。
枚举类的常量对象列表必须在枚举类的首行，因为是常量，所以建议大写。
列出的实例系统会自动添加 public static final 修饰。
如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。（多个对象之间使用,隔开）
编译器给枚举类默认提供的是private的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数
如果枚举类需要的是有参构造，需要手动定义，有参构造的private可以省略，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。
枚举类默认继承的是java.lang.Enum类，因此不能再继承其他的类型。（再次继承就会报错）
JDK5.0 之后switch，提供支持枚举类型，case后面可以写枚举常量名，无需添加枚举类作为限定。

示例：

package com.atguigu02;

public class SeasonTest04 {
    public static void main(String[] args) {
        Week week = Week.MONDAY;
        System.out.println(week);   // 输出： MONDAY

        switch (week) {
            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;
        }
    }
}

// 定义一个枚举类
enum Week {
    MONDAY("星期一"),
    TUESDAY("星期二"),
    WEDNESDAY("星期三"),
    THURSDAY("星期四"),
    FRIDAY("星期五"),
    SATURDAY("星期六"),
    SUNDAY("星期日");
    private final String desc;

    private Week(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

2、枚举类中常见的方法

	String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法   
        
    static 枚举类型[] values():返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值，是一个静态方法    
        
    static 枚举类型 valueOf(String name)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常
        
    String name():得到当前枚举常量的名称。建议优先使用toString()    
        
    int ordinal():返回当前枚举常量的次序号，默认从0开始

public class SeasonTest02 {
    public static void main(String[] args) {
        System.out.println(Season1.spring.getClass());  // 输出： class com.atguigu02.Season1
        System.out.println(Season1.spring.getClass().getSuperclass());  // 输出： class java.lang.Enum

        // 测试方法
        // 1.toString()
        // 默认不重写的话，打印的就是变量名；也可以重写toString打印想要的值
        System.out.println(Season1.spring); // 输出：spring

        // 2.name()
        // 打印当前变量的名称
        System.out.println(Season1.spring.name());  // 输出： spring

        // 3.values()
        Season1[] values = Season1.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }

        // 4.valueOf(String objName):返回当前枚举类中名称为objName的枚举类对象
        // 如果枚举类中不存在objName名称的对象，则报错
        String objName = "autumn";
        Season1 season1 = Season1.valueOf(objName);
        System.out.println(season1);

        // 5.ordinal():返回当前枚举常量的次序号，默认从0开始
        System.out.println(Season1.spring.ordinal());   // 输出： 0
    }
}

// jdk5.0中使用enum关键字定义枚举类
enum Season1 implements Info{
    // 1.必须在枚举类的开头声明多个对象，对象之间使用,隔开
    // public static final 都省略了
    spring("春天", "春暖花开"),
    summer("夏天", "夏日炎炎"),
    autumn("秋天", "秋高气爽"),
    winter("冬天", "白雪皑皑");

    private final String seasonName;
    private final String seasonDesc;

    private Season1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

三、枚举类实现接口的操作

情况一：枚举实现接口，在枚举类中重写了接口当中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是同一个方法。

public class SeasonTest02 {
    public static void main(String[] args) {
        // 通过枚举类的对象调用重写接口中的方法
        Season1.spring.show();  // 输出： 这是一个季节
    }
}

interface Info {
    void show();
}

// jdk5.0中使用enum关键字定义枚举类
enum Season1 implements Info{
    spring("春天", "春暖花开"),
    summer("夏天", "夏日炎炎"),
    autumn("秋天", "秋高气爽"),
    winter("冬天", "白雪皑皑");

    private final String seasonName;
    private final String seasonDesc;

    private Season1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }

    @Override
    public void show() {
        System.out.println("这是一个季节");
    }
}

情况2：让枚举类的每一个对象重写接口中的抽象方法，当通过不同的枚举类对象调用此方法时，执行的是不同的实现的方法

public class SeasonTest03 {
    public static void main(String[] args) {
        Season2[] season2s = Season2.values();
        for (int i = 0; i < season2s.length; i++) {
            season2s[i].show();
        }
    }
}

interface Info1 {
    void show();
}

// jdk5.0中使用enum关键字定义枚举类
enum Season2 implements Info{
    // 1.必须在枚举类的开头声明多个对象，对象之间使用,隔开
    // public static final 都省略了
    spring("春天", "春暖花开") {
        @Override
        public void show() {
            System.out.println("春天来了");
        }
    },
    summer("夏天", "夏日炎炎") {
        @Override
        public void show() {
            System.out.println("夏天来了");
        }
    },
    autumn("秋天", "秋高气爽") {
        @Override
        public void show() {
            System.out.println("秋天来了");
        }
    },
    winter("冬天", "白雪皑皑") {
        @Override
        public void show() {
            System.out.println("冬天来了");
        }
    };

    private final String seasonName;
    private final String seasonDesc;

    private Season2(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season2{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

标签：Java,String,枚举,seasonName,seasonDesc,println,public
From： https://blog.csdn.net/2302_81034736/article/details/143994385

Java的枚举类

Java的枚举类

一、`jdk5.0`之前定义枚举类的方式

二、`jdk5.0`之后的定义方法

1、enum定义枚举类的注意事项：

2、枚举类中常见的方法

三、枚举类实现接口的操作

相关文章

赞助商

阅读排行

Java的枚举类

Java的枚举类

一、jdk5.0之前定义枚举类的方式

二、jdk5.0之后的定义方法

1、enum定义枚举类的注意事项：

2、枚举类中常见的方法

三、枚举类实现接口的操作

相关文章

赞助商

阅读排行

一、`jdk5.0`之前定义枚举类的方式

二、`jdk5.0`之后的定义方法