224 - 枚举

已于 2022-10-11 17:59:55 修改
阅读量61 收藏
点赞数
分类专栏： JavaSE 文章标签： java
于 2022-10-11 16:13:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoulizhengZ/article/details/127262680
版权

1、引入

【1】数学：枚举法：

1<x<4

2<y<5

求x+y=6

枚举法：一枚一枚的列举出来。前提：有限，确定

【2】在java中，类的对象是有限个，确定的。这个类我们可以定义为枚举类。

举例：

星期：一二三四五六日  

性别：男女

季节：春夏秋冬

【3】自定义枚举类：（JDK1.5之前自定义枚举类） 

代码示例：
Season类：

package test5_Enum;

/**
 * @Auther: zhoulz
 * @Description: 定义枚举类：季节
 * @version: 1.0
 */
public class Season {
    //属性
    //private final String seasonName = "春天";//季节名字
    //private final String seasonDesc = "出暖花开";//季节描述
    //季节都是确定的，可以说是常量，因此要赋值
    //但是赋值后，就无法更改了，即不能向上面那么写，
    // 怎么办：利用构造器

    private final String seasonName;//季节名字
    private final String seasonDesc;//季节描述
    //利用构造器对属性进行赋值操作：
    //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
    Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //提供枚举类的有限的、确定的对象：
    //Season spring = new Season("春天","春暖花开");
    //改为：
    //public static - 为了外界能调用，且Season. 直接调用；final - 外界不能该；SPRING - 常量的话，就大写。
    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("冬天","冰天雪地");

    //上面基本创建好了枚举类
    //额外因素：
    //因为都是常量，且值都设置好了，所以不用set()方法了
    //但可以有get()方法
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    //还可以有toString()方法
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

测试类：Test1

package test5_Enum;

/**
 * @Auther: zhoulz
 * @Description: test5_Enum
 * @version: 1.0
 */
public class Test1 {
    public static void main(String[] args) {
        Season summer = Season.SUMMER;
        System.out.println(summer/*.toString()*/);
        //相当于：
        System.out.println(summer.toString());

        System.out.println(summer.getSeasonName());
    }
}

2、JDK1.5之后使用enum关键字来创建枚举类

较之前自定义的枚举类：

 变为下面的枚举类：

代码示例：

package test6_Enum_2;

/**
 * @Auther: zhoulz
 * @Description: 定义枚举类：季节
 * @version: 1.0
 */
public enum Season {

    //提供枚举类的有限的、确定的对象：—— enum枚举类要求对象（常量）必须放在最开始位置
    //然后，改成：
    //多个对象之间用，进行连接，最后一个对象后面用;结束

    SPRING ("春天","春暖花开"),
    SUMMER ("夏天","烈日炎炎"),
    AUTUMN ("秋天","硕果累累"),
    WINTER ("冬天","冰天雪地");

    //属性
    private final String seasonName;//季节名字
    private final String seasonDesc;//季节描述
    //利用构造器对属性进行赋值操作：
    //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
    Season(String seasonName, String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //上面基本创建好了枚举类
    //额外因素：
    //因为都是常量，且值都设置好了，所以不用set()方法了
    //但可以有get()方法
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    //还可以有toString()方法
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

同样，定义好了枚举类，我们就可以使用了。

使用枚举类：

代码示例：

package test6_Enum_2;

/**
 * @Auther: zhoulz
 * @Description: test6_Enum_2
 * @version: 1.0
 */
public class TestSeason {
    public static void main(String[] args) {
        Season winter = Season.WINTER;
        System.out.println(winter);
        //将重写后的toString()方法注释后，得到输出后的 winter为  WINTER
        //而在之前自定义的枚举中，如果将重写后的toString()方法注释，
        //得到的结果为：test5_Enum.Season@14ae5a5

        //而结果WINTER 说明打印的不是一个地址，从而说明enum定义的Season不是继承自Object
        //获取其父类：
        System.out.println(Season.class.getSuperclass().getName());//结果：java.lang.Enum

        //enum关键字对应的枚举类的上层父类是 ：java.lang.Enum
        //但是我们自定义的枚举类的上层父类：Object
    }
}

在源码中经常看到别人定义的枚举类形态：

public enum Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;
}

        为什么这么简单：因为这个枚举类底层没有属性，属性，构造器，toString，get方法都删掉不写了，然后案例来说应该写为：SPRING() ，  现在连（）都可以省略了， 就变成  SPRING。

看到的形态就剩：常量名（对象名）

举例：

Thread中的枚举类：State

代码示例：

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

3、Enum类的常用方法

代码示例：

Season枚举：

public enum Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;
}

测试类： 

package test7_Enum_3;

/**
 * @Auther: zhoulz
 * @Description: test7_Enum_3
 * @version: 1.0
 */
public class TestSeason {
    public static void main(String[] args) {
        //用enum关键字创建的Season枚举类上面的父类是：java.lang.Enum,
        //其下的常用方法，子类Season可以直接拿过来使用：

        //1、toString() —— 获取对象的名字
        Season autumn = Season.AUTUMN;
        System.out.println(autumn/*.toString()*/); //AUTUMN

        System.out.println("----------");
        //2、values() —— 返回枚举类对象的数组
        //values()是静态的，所以直接Season. 去调
        Season[] values = Season.values();
        //使用增强for循环，对values进行遍历
        //对values进行遍历，然后用Season s 去接收
        for (Season s:values){
            System.out.println(s.toString());
        }

        System.out.println("----------");
        //3、valueOf() —— 通过对象名字获取这个枚举对象
        //注意：对象的名字必须传正确，否则抛出异常

        //注意：valueOf()方法 要求传入的是一个String name (字符串对象) ，
        // 然后返回的是一个Season对象
        Season autumn1 = Season.valueOf("AUTUMN");
        System.out.println(autumn1);
    }
}

4、枚举类实现接口

（1）首先，定义一个接口：

代码示例：

package test8_Enum_4_implement_interface;

/**
 * @Auther: zhoulz
 * @Description: test8_Enum_4_implement_interface
 * @version: 1.0
 */
public interface TestInterface {
    void show();
    // 接口体中只进行方法的声明，不允许提供方法的实现,
    // 方法的定义没有方法体，且用分号结尾
}

（2）然后，创建一个枚举类实现接口，并且重写show方法：

代码示例：

package test8_Enum_4_implement_interface;

/**
 * @Auther: zhoulz
 * @Description: test8_Enum_4_implement_interface
 * @version: 1.0
 */
public enum Season implements TestInterface{
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;

    //实现接口，必须要对里面的抽象方法进行重写：
    @Override
    public void show(){
        System.out.println("这是Season！！！");
    }
}

（3）最后，创建测试类：

代码示例：

package test8_Enum_4_implement_interface;

/**
 * @Auther: zhoulz
 * @Description: test8_Enum_4_implement_interface
 * @version: 1.0
 */
public class Test1 {
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        autumn.show();

        //同理
        Season summer = Season.SUMMER;
        summer.show();
    }
}

结果发现：
        所有创建的枚举对象，调用这个show方法的时候，走的都是同一个方法，结果都一样：

但是现在要求：

                不同的对象  调用的show方法也不同。

代码示例：

测试类：同上

枚举类：

package test8_Enum_4_implement_interface;

/**
 * @Auther: zhoulz
 * @Description: test8_Enum_4_implement_interface
 * @version: 1.0
 */
public enum Season implements TestInterface{
    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("这是冬天！");
        }
    };

    //实现接口，必须要对里面的抽象方法进行重写：
    /*@Override
    public void show(){
        System.out.println("这是Season！！！");
    }*/
}

结果：

5、实际应用

代码示例：

Person类：

package test9_Enum_5_practical_application;

/**
 * @Auther: zhoulz
 * @Description: test9_Enum_5_practical_application
 * @version: 1.0
 */
public class Person {
    //属性
    private int age;
    private String name;
    //private String sex;
    //不用属性sex：
    private Gender sex;

    //set、get方法：
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    /*public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        if (sex == "男" || sex == "女"){ //更好？：if (sex.equals("男") || sex.equals("女"))
            this.sex = sex;
        }
        else{
            this.sex = "性别设置无效！";
            System.out.println("请您重新设置性别！！！");
        }
    }*/
    //
    //提供对应的枚举类的对象的set、get方法
    public Gender getSex() {
        return sex;
    }

    public void setSex(Gender sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}'; //记住把sex注释掉,创建了Gender sex后就会报错了
    }
}

枚举类：

package test9_Enum_5_practical_application;

/**
 * @Auther: zhoulz
 * @Description: test9_Enum_5_practical_application
 * @version: 1.0
 */
public enum Gender {
    男,
    女;
}

测试类：

package test9_Enum_5_practical_application;

/**
 * @Auther: zhoulz
 * @Description: test9_Enum_5_practical_application
 * @version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(20);
        p.setName("小丽");
        //p.setSex("女");

        //p.setSex("qwewdwdfasf"); //不是自己想要的，但也不会报错
        //以前的做法是在setSex()方法中进行判断，
        //现在通过枚举来解决 : 创建一个枚举类，把属性sex及其方法去掉，
        //当创建了枚举类对象Gender sex后，设置的不是“男、女”就会报错了。
        //而且，不能直接传入“男、女”
        //应该是：
        p.setSex(Gender.男);//会提示传入：Gender sex 对象
                            //输入Gender. 后，自动获取
        //即：传入枚举类Gender的对象：-->在入口处对参数进行了限制

        System.out.println(p);
    }
}

还可以通过枚举结合switch处理：

代码示例：

package test9_Enum_5_practical_application;

/**
 * @Auther: zhoulz
 * @Description: test9_Enum_5_practical_application
 * @version: 1.0
 */
public class Test2 {
    public static void main(String[] args) {
        Gender sex = Gender.男;

        //switch后面的（）中可以传入枚举类型
        //switch后面的（）:int,short,byte,char,String ,枚举
        // long、float、double不行
        switch (sex){
            case 女:
                System.out.println("一个女孩。");
                break;
            case 男:
                System.out.println("一个男孩。");
                break;
    }
}
哆啦A梦的_梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java枚举类
yy310585的博客
12-23 53
Java枚举类 创建自定义枚举类 public class Season { // 属性 private final String seasonName; private final String seasonDesc; // 构造器私有化，外接不能调用这个构造器 private Season(String seasonName, Strin...
[Objective-c程序设计].杨正洪等.扫描版
04-01
16.2 KVC简介224 16.3 路径225 16.4 整体操作226 16.4.1 中途小憩227 16.4.2 流畅地运算231 16.5 批处理233 16.6 nil仍然可用234 16.7 处理未定义的键235 16.8 小结236 第17章 NSPredicate237 17.1 创建谓词237 17.2...
NET设计规范-.NET约定、惯用法与模式.part2
08-14
3.5.3　枚举类型的命名　51 3.6　类型成员的命名　53 3.6.1　方法的命名　53 3.6.2　属性的命名　54 3.6.3　事件的命名　55 3.6.4　字段的命名　57 3.7　参数的命名　57 3.8　资源的命名　58 3.9　小结　59 第4章　...
NET设计规范-.NET约定、惯用法与模式.part1
08-14
5.7.1　枚举和布尔参数之间的选择　140 5.7.2　参数的验证　142 5.7.3　参数的传递　145 5.7.4　参数数量可变的成员　147 5.7.5　指针参数　150 5.8　小结　152 第6章　为扩展性而设计　153 6.1　扩展机制　153 ...
D5开发人员指南-02卷
10-11
7.4.2 枚举 152 7.4.3 控件接口 152 7.4.4 TOleControl的派生类 152 7.4.5 方法 152 7.4.6 属性 153 7.5 在应用程序中使用ActiveX控件 153 7.6 发布带有ActiveX控件的应用程序 154 7.7 注册ActiveX控件 155 7.8 ...
Visual C++ 2005入门经典--源代码及课后练习答案
02-02
5.2.4　给函数传递引用实参 224 5.2.5　使用const修饰符 226 5.2.6　main()函数的实参 227 5.2.7　接受数量不定的函数实参 229 5.3　从函数返回值 231 5.3.1　返回指针 231 5.3.2　返回引用 234 5.3.3　函数...
（javaweb）请求响应postman
2301_79144798的博客
08-08 486
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 272
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 294
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Spring事务
c1tenj2的博客
08-07 453
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
Spring Boot 3.x Rest API最佳实践之API设计
felix_alone2012的博客
08-08 946
本系列教程将会以企业中API基础功能封装为目标，用最新的Spring Boot 3.x版本来逐步搭建和完善Rest API项目基础架构，并结合实际电商项目中API的实现需求来进行最佳实践。如果觉得对你有帮助，记得点赞收藏，关注小卷，后续更精彩！
反射和注解
supercool7的博客
08-08 270
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 411
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Java：继承，this，super
m0_75257168的博客
08-10 350
可以同名，但参数列表不能相同（有参无参构造）
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 271
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
log4j反序列化-流程分析
无
08-06 1199
JDK8u141依赖</</</</</</</</</
DSL domain specific language of Kola
AK15221736052的博客
08-08 741
Kola 从 SmartBear 的 PactFlow, Spring clout Contract, Spock, Karate 等前辈上得到很多参考和灵感；直接用 ApiHug 上下文的 api 可以有更丰富的上下文， 关于request, response 的定义， path, 参数， 校验规则。但是 BDD 的表达方式，真的是太好了，兼顾程序世界的结构化，和非程序世界的通俗易懂；更不用说， 测试界的基石: Junit5, TestNG, AssertJ 等基础框架；在 ApiHug 上下文，
dynamic-datasource+Mybatis多数据源使用
tiantiantbtb的博客
08-06 911
严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。#设置默认的数据源或者数据源组,默认值即为master。#去掉默认使用HikariCP。
javaImageIo实现图片内容动态修改
zhangzeshan
08-07 165
在指定坐标绘制水印文字
【L2-枚举-例】硬币
06-16
对不起，您的问题似乎没有完全明确，关于"L2-枚举-例"硬币，我不太确定您是指哪种特定的概念或者技术用语。枚举（Enumeration）通常是在编程中用来定义一组命名常量的一种方法，而"硬币"可能指的是实际的货币单位或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值