自定义枚举类（jdk5.0之前）

package com.atguigu.java;

/**
 * 一、枚举类的使用
 * 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
 * 2.当需要定义一组常量时，强烈建议使用枚举类
 * 3.如果枚举类中只有一个对象，则可以作为一种单例模式的实现方式。
 *
 * 二、如何定义枚举类
 * 方式一：jdk5.0之前，自定义枚举类
 * 方式二：jdk5.0，可以使用enum关键字定义枚举类
 *
 */

//自定义枚举类
class Season{
    //1.声明Season对象的属性:private final修饰
    private final String seasonName;//final修饰的，要么直接赋值，要么构造器赋值
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //3.提供当前枚举类的多个对象：public static final的
    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("冬天","冰天雪地");

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求1：提供toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}
//测试使用自定义枚举类
public class SeasonTest {

    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);//Season{seasonName='春天', seasonDesc='春暖花开'}
        
    }

}

使用enum关键字定义枚举类

package com.atguigu.java;

public class SeasonTest2 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());//SUMMER

        System.out.println(Season1.class.getSuperclass());//父类是 class java.lang.Enum
        //即定义的枚举类默认继承于java.lang.Enum类
}

//使用enum关键字枚举类（class在这改为enum）
enum Season1 {
        //public static final Season1 SPRING = new Season1("春天","春暖花开");
       // 把自定义枚举类中的public static final Season1 ，new Season1都去掉。
     //此处要求对象SPRING,SUMMER,AUTUMN, WINTER要写着最上边 不然报错
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"),//多个对象之间用逗号，
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //3.私有化类的构造器,并给对象属性赋值

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

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

}
}

Enum类中的常用方法和使用enum关键字定义的枚举类实现接口

package com.atguigu.java;

/**
 * 使用enum关键字定义枚举类
 * 说明：定义的枚举类默认继承于java.lang.Enum类
 *
 * * 三、Enum类中的常用方法：
 *  *    values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
 *  *    valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
 *  *    toString()：返回当前枚举类对象常量的名称
 *  *
 *  * 四、使用enum关键字定义的枚举类实现接口的情况
 *  *   情况一：实现接口，在enum类中实现抽象方法
 *  *   情况二：让枚举类的对象分别实现接口中的抽象方法
 *  *
 */
public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());//SUMMER

        System.out.println(Season1.class.getSuperclass());//父类是 class java.lang.Enum
        //即定义的枚举类默认继承于java.lang.Enum类

        System.out.println("****************");
        //values():返回所有的枚举类对象构成的数组
        Season1[] values = Season1.values();
        for(int i = 0;i < values.length;i++){
            System.out.println(values[i]);//
            values[i].show();
        }
        //SPRING
        //春天在哪里？
        //SUMMER
        //宁夏
        //AUTUMN
        //秋天不回来
        //WINTER
        //大约在冬季
        System.out.println("****************");

        //valueOf(String objName):返回枚举类中对象名是objName的对象。
        Season1 winter = Season1.valueOf("WINTER");
        //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
//        Season1 winter = Season1.valueOf("WINTER1");
        System.out.println(winter);//WINTER
        winter.show();//大约在冬季
    }
}

interface Info{//一个接口
    void show();
}

//使用enum关键字枚举类
enum Season1 implements Info{//实现接口和class类实现接口一样
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    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("大约在冬季");
        }
    };

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值

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

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
//    //4.其他诉求1：提供toString()
//    这里不必重写toString（），如果有诉求，可以重写。
//    @Override
//    public String toString() {
//        return "Season1{" +
//                "seasonName='" + seasonName + '\'' +
//                ", seasonDesc='" + seasonDesc + '\'' +
//                '}';
//    }


    @Override
    //情况一：实现接口，在enum类中实现抽象方法
    public void show() {
        System.out.println("这是一个季节");
    }
}

涉及知识点

• 前台Thymeleaf下拉列表使用枚举类
• 后台实体类使用枚举类接收前台传值
• 自定义Mybatis枚举类转换器,插入枚举类数据和查询数据封装为枚举类
• EnumMap,使用枚举类作为Key的Map

前台

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <select id="test">
        <!-- 前台将后台枚举类中的数据遍历显示 -->
        <option th:each="enmu:${enums}" th:value="${enmu.code}" th:text="${enmu.name}"></option>
    </select>
    <button onclick="submitData()">提交请求</button>
</div>
</body>
<script th:src="@{/js/jquery.min.js}"></script>
<script th:inline="javascript" type="text/javascript">
	// 获取项目根路径
    const ctxPath = [[${#httpServletRequest.getContextPath()}]];

    async function submitData() {
		
		// 属性名需要和后台用来接收的实体类的属性名保持一致
        const data = {
            name: '贾飞天',
            sexTypes: $("#test").val()
        };
		
		// 使用fetch发送请求,提交前台json数据
        const result = await fetch(ctxPath + '/enum/getValue', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json;charset=utf-8'
            },
            body: JSON.stringify(data)
        })
        
        // 获取后台返回的json数据
        const json = await result.json();
        console.log(json);
    }
</script>
</html>

枚举类

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;

import java.util.Arrays;

/*
	SexTypes被组合到Teacher实体类中,当SpingBoot接收到前台的数据进行封装的时候
	需要使用jackson中的注解指定封装到枚举类中
*/ 
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum SexTypes {

    男性("1"),
    女性("2"),
    保密("3");
    
    private String code;

    SexTypes(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    /*
    	根据code获取枚举类对象
    	SpringBoot在将前台数据封装的时候,通过@JsonCreator注解对应的方法
    	指定前台的性别code转换为对应的枚举类
	*/ 
    @JsonCreator
    public static SexTypes fromCode(String code) {
        return Arrays.stream(SexTypes.values())
                .filter(item -> item.code.equals(code)).findAny().orElse(null);

    }

    public static SexTypes fromName(String name) {

        return Arrays.stream(SexTypes.values())
                .filter(item -> item.name().equals(name)).findAny().orElse(null);
    }
}

实体类

public class Teacher {

    private String name;
    private SexTypes sexTypes;

    public Teacher(String name, SexTypes sexTypes) {
        this.name = name;
        this.sexTypes = sexTypes;
    }

    // 省略get,set,toString...
}

数据库

Mybatis自定义枚举类转换器

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

// 数据库字段所对应的类型
@MappedJdbcTypes({JdbcType.VARCHAR})
// 需要转换为JAVA侧的类型
@MappedTypes(value = SexTypes.class)
// 进行类型转换需要继承Mybatis的BaseTypeHandler类
public class CustomEnumTypeHandler extends BaseTypeHandler<SexTypes> {
    
    // 重写BaseTypeHandler中的方法
    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, SexTypes parameter, JdbcType jdbcType) throws SQLException {
    	/*
    		当插入数据的时候(#{参数名}),会调用此方法,将枚举类中的code当做参数插入
    		因为数据库中的sex为varchar类型,因此设置参数类型为string
		*/ 
        preparedStatement.setString(i, parameter.getCode());
    }
	
	// 当进行查询的时候,会通过code获取到对应的枚举类
    @Override
    public SexTypes getNullableResult(ResultSet resultSet, String s) throws SQLException {
        String code = resultSet.getString(s);
        return SexTypes.fromCode(code);
    }

    @Override
    public SexTypes getNullableResult(ResultSet resultSet, int i) throws SQLException {
        String code = resultSet.getString(i);
        return SexTypes.fromCode(code);
    }

    @Override
    public SexTypes getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        String code = callableStatement.getString(i);
        return SexTypes.fromCode(code);
    }
}

将自定义枚举类转换器添加到全局配置文件application.properties中

# 指定转换器包所在的路径
mybatis.type-handlers-package=com.example.demo.EnumPack

Mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.TestEnumInsert">
    <select id="insertEnumData" parameterType="com.example.demo.form.EnumTestFrom">
      INSERT
        INTO myblog.enumuser(name, sex)
        <!--
        	由于我们配置了枚举类转换器,因此直接插入枚举类属性即可
        	转换器会将枚举类中的code获取出来当做参数插入
		-->
        VALUES (#{name}, #{sexTypes})
    </select>

    <select id="selectAllData" resultType="com.example.demo.mybatisTest.Teacher">
    	<!--枚举类转换器会将sex的code转换为对应的枚举类-->
        SELECT * from myblog.enumuser
    </select>
</mapper>

public interface TestEnumInsert {
	
	// 插入枚举类数据
    void insertEnumData(EnumTestFrom form);
	
	// 查询所有的数据
    List<Teacher> selectAllData();
}

插入后查询

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import java.util.EnumMap;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Controller
@RequestMapping("/enum")
public class EnumTestController {

    @Autowired
    private TestEnumInsert mapper;

    @GetMapping("/init")
    public ModelAndView init() {
    
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("enum");
        // 将枚举类数组传给前台下拉列表使用
        modelAndView.addObject("enums", SexTypes.values());
        return modelAndView;
    }

    @PostMapping("/getValue")
    @ResponseBody
    public ResultInfo getValueFromView(@RequestBody EnumTestFrom form) {
		
		// 先将前台的数据插入数据库
        mapper.insertEnumData(form);
		
		// 插入完成之后查询所有的Teacher数据
        List<Teacher> teachers = mapper.selectAllData();

        // 教师按照性别枚举类进行分组
        EnumMap<SexTypes, Set<Teacher>> collect = teachers.stream().collect(
                Collectors.groupingBy(
                        // 参数一: 分组按照什么进行分类,此处按照教师性别进行分类
                        Teacher::getSexTypes,
                        // 参数二: 分组最后用什么容器保存返回,默认是HashMap::new.此处我们指定使用EnumMap
                        () -> new EnumMap<>(SexTypes.class),
                        // 参数三: 按照第一个参数分类之后,对应的分类的结果如何收集,默认是Collectors.toList
                        Collectors.toSet()
                )
        );
        System.out.println(collect);
		
		// 将封装好的EnumMap数据封装到自定义实体类中返回前台
        return new ResultInfo("成功", collect);
    }
}

效果

枚举类数据通过自定义转换器处理,插入数据库成功

对数据查询,通过自定义转换器封装为枚举类

将数据封装为EnumMap这种枚举类为key的数据格式

前台接收到后台返回值

Java学习记录——枚举类之自定义枚举类

一、什么是枚举类？

1.所谓的枚举类，就是有限个类的对象。比如说定义了一个星期类，而星期是有限的，只有一至七；
再比如说，定义了一个季节类，春夏秋冬是有限的季节类的对象。这就是枚举类。说白了，就是一个一个数出来，有点类似于遍历，但与遍历的概念不等同。
2.当需要定义一组产量时，强烈建议使用枚举类。
3.当枚举类当中只有一个对象，则可以作为单例模式的实现方式。
	（1）啥是单例模式？简言之：确保某个类只有一个对象实例。单例类	必须自己创建自己的唯一实例。单例类必须给所有其他对象提供这一实例。

二、如何定义枚举类？

（以下的定义枚举类的方法采用的是JDK5.0之前的方式定义）

以定义一个季节类为示例，供大家学习。

public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);//输出
    }
}
//自定义枚举类
class Season{
    //1.声明Season对象的属性：private final 修饰 作为Season的实例变量,习惯上将属性声明为private，而对象是常量了，而对象的属性一般也是产量了，所以用final
    private final String seasonName;
    private final String seasonDesc;
    
    //2.私有化构造器（原因：构造器不是私有的话，那么构造器在外面就可被调用，就不知道对象有多少个，就不是属于枚举类了）
    //这里用构造器来赋值，如果显示赋值或者在代码块中赋值，那么显示的内容是一样的。
    private Season(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }
    
    //3.提供当前枚举类的多个对象
    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("冬天","冰天雪地");
    
    //4.诉求1：获取属性，只有get方法可以调。因为对象是一个常量，不可以修改的，所以拿到的只有get方法。

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    //4.诉求2：输出
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}