枚举学习笔记

最新推荐文章于 2024-07-22 14:10:07 发布

契合c'c'c

最新推荐文章于 2024-07-22 14:10:07 发布

阅读量77

点赞数

文章标签：学习 java spring

本文链接：https://blog.csdn.net/qq_44794656/article/details/128336261

版权

枚举

enumeration  简称enum
枚举是一组常量的集合
枚举属于一种特殊的类，里面只包含一组有限的特定的对象

package Enum_;

public class Enumeration01 {
    public static void main(String[] args) {
        Season season1 = new Season("春天", "温暖");
        Season season2 = new Season("夏天", "温暖");
        Season season3 = new Season("秋天", "温暖");
        Season season4 = new Season("冬天", "温暖");
        //对于季节而言，只有固定的4种
        //无法体现季节是4个固定的对象
        //使用枚举类--->把具体的对象一个一个的例举出来的类称为枚举类
        //修改：季节的值是有限的几个值，只读不需要修改
        Season season5 = new Season("红天", "温暖");
    }
}
class Season{
    private String name;
    private String desc;

    public String getName() {
        return name;
    }

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

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
}

枚举的两种实现方式
	自定义类实现枚举
	使用enum关键字实现枚举

1、自定义类实现枚举

1、不要提供set方法，因为枚举对象值通常为只读

2、对枚举对象/属性使用final+static修饰，实现底层优化

3、枚举对象通常使用全部大写，常量的命名规范

4、枚举对象根据需要，也可以有多个属性

package Enum_;

/**
 * 自定义枚举类
 */
public class Enumeration02 {
    public static void main(String[] args) {
        //使用方法
        System.out.println(Season02.AUTUMN);
        System.out.println(Season02.SPRING);
        System.out.println(Season02.SUMMER);
        System.out.println(Season02.WINTER);
//        Season02 season02 = new Season02();//Season02(java.lang.String, java.lang.String)' 在 'Enum_.Season02' 中具有 private 访问权限

    }
}
class Season02{
    private String name;
    private String desc;

    public String getName() {
        return name;
    }
    //3、在season02内创建固定的对象
    //优化：可以加入final修饰符
    public final static Season02 SPRING=new Season02("春天", "温暖");
    public final static Season02 WINTER=new Season02("夏天", "温暖");
    public final static Season02 AUTUMN=new Season02("秋天", "温暖");
    public final static Season02 SUMMER=new Season02("冬天", "温暖");
//    public void setName(String name) {
//        this.name = name;
//    }

    public String getDesc() {
        return desc;
    }
    //2、去掉set方法，防止属性被修改
//    public void setDesc(String desc) {
//        this.desc = desc;
//    }

    //1、将构造器私有化，防止直接new对象
    private Season02(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "Season02{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

小结：
	1、构造器私有化
	2、本类对象创建一组对象（例子：春夏秋冬）
	3、对外暴漏对象--->通过对象添加public final static修饰符
	4、可以提供get方法，但是不能提供set方法----->get查 set改--->因为只读

2、使用enum关键字实现枚举

package Enum_;

/**
 * 使用enum关键字实现枚举
 */
public class Enumeration02 {
    public static void main(String[] args) {
        //使用方法
        System.out.println(Season02.AUTUMN);
        System.out.println(Season02.SPRING);
        System.out.println(Season02.SUMMER);
        System.out.println(Season02.WINTER);
//        Season02 season02 = new Season02();//Season02(java.lang.String, java.lang.String)' 在 'Enum_.Season02' 中具有 private 访问权限

    }
}
enum Season02{
    
//    public final static Season02 SPRING=new Season02("春天", "温暖");
//    public final static Season02 WINTER=new Season02("夏天", "温暖");
//    public final static Season02 AUTUMN=new Season02("秋天", "温暖");
//    public final static Season02 SUMMER=new Season02("冬天", "温暖");
    //如果使用enum来实现枚举类
    //1、使用enum替代class
    //2、public final static Season02 SPRING=new Season02("春天", "温暖");直接使用SPRING ("春天", "温暖");-->等价
    //SPRING ("春天", "温暖");  理解  常量名（实参列表）
    //3、如果有多个常量（对象），使用,号间隔
    //4、如果使用关键字enum实现枚举，要求把定义常量对象写在最前
    SPRING ("春天", "温暖"),
    WINTER("夏天", "温暖"),
    AUTUMN("秋天", "温暖"),
    SUMMER("冬天", "温暖");
    private String name;
    private String desc;
    
    public String getDesc() {
        return desc;
    }
    public String getName() {
        return name;
    }
    private Season02(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "Season02{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

3、enum关键字实现枚举注意事项

1、当我们使用enum关键字开发一个枚举类是，默认会继承Enum类,而且是一个final类–>反编译查看javap Season02.class

在这里插入图片描述

2、传统的public final static Season02 SPRING=new Season02(“春天”, “温暖”);j简化使用SPRING (“春天”, “温暖”);应该知道使用的是那个构造器---->根据实参列表判断

3、如果使用无参构造器创建枚举对象，则实参列表和小括号可以省略

    SPRING ("春天", "温暖"),
    WINTER("夏天", "温暖"),
    AUTUMN("秋天", "温暖"),
    SUMMER("冬天", "温暖"),
    WHAT;//3、如果使用无参构造器创建枚举对象，则实参列表和小括号可以省略
    private String name;
    private String desc;

    Season02() {//无参构造
    }

    public String getName() {
        return name;
    }
    private Season02(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

4、当有多个枚举对象时，使用 , 号间隔，最后一个使用分号结尾

5、枚举对象必须放在枚举类的第一行

4、enum常用方法

1、toString():Enum类已经重写过了，返回档期那对象名，子类可以重写该方法，用于返回对象的属性信息
2、name 返回当前对象名（常量名），子类中不能重写
3、ordinal 返回档期那对象的位置号，默认从0开始
4、values 返回当前枚举类中所有的常量
5、valueOf 将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
6、compareTo 比较两个枚举常量，比较的是位置号

package Enum_;

/**
 * 演示Enum各种方法的使用
 *
 * 1、toString():Enum类已经重写过了，返回档期那对象名，子类可以重写该方法，用于返回对象的属性信息
 * 2、name 返回当前对象名（常量名），子类中不能重写
 * 3、ordinal 返回档期那对象的位置号，默认从0开始
 * 4、values 返回当前枚举类中所有的常量
 * 5、valueOf 将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
 * 6、compareTo 比较两个枚举常量，比较的是位置号
 */
public class EnumMethod {
    public static void main(String[] args) {
        Season03 autumn = Season03.AUTUMN;
        //2、name 返回当前对象名（常量名），子类中不能重写
        System.out.println(autumn.name());
        //ordinal()输出该枚举对象的次序/编号 从0开始
        System.out.println(autumn.ordinal());
        System.out.println(autumn.toString());
        //从反编译可以看出，返回一个数组，该数组包含定义的所有枚举对象
        Season03[] values = Season03.values();
        //遍历
        for (Season03 s:values){//增强for循环
            System.out.println(s);
        }
        // 5、valueOf 将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
        //执行流程：
        //1、根据你输入的AUTUMN到Season03的枚举对象中去查找
        //2、如果找到了就返回，没有找到就报错
        Season03 autumn2 = Season03.valueOf("AUTUMN");
        System.out.println("autumn2"+autumn2);
        //判断autumn和autumn2是否是一个对象
        System.out.println(autumn==autumn2);
        // * 6、compareTo 比较两个枚举常量，比较的是位置号
        /**
         * public final int compareTo(E o) {
         *         Enum<?> other = (Enum<?>)o;
         *         Enum<E> self = this;
         *         if (self.getClass() != other.getClass() && // optimization
         *             self.getDeclaringClass() != other.getDeclaringClass())
         *             throw new ClassCastException();
         *         return self.ordinal - other.ordinal;
         *     }
         *     Season03.AUTUMN的编号-Season03.SUMMER的编号---->3-4=-1
         */
        System.out.println(Season03.AUTUMN.compareTo(Season03.SUMMER));
    }
}
enum Season03{

    SPRING ("春天", "温暖"),
    WINTER("夏天", "温暖"),
    AUTUMN("秋天", "温暖"),
    SUMMER("冬天", "温暖");
    private String name;
    private String desc;

    Season03() {//无参构造
    }

    public String getName() {
        return name;
    }
    private Season03(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season02{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

5、enum实现接口

1、使用enum关键字后，就不能再继承其他类，因为enum会隐式继承enum，而Java采用的是单继承机制，所以不能在继承其他类

2、枚举类和普通类一样，可以实行接口

enum 类名 implements 接口1，接口2{}

public String toString() {
return “Season02{” +
“name='” + name + ‘’’ +
“, desc='” + desc + ‘’’ +
‘}’;
}
}


### 5、enum实现接口

1、使用enum关键字后，就不能再继承其他类，因为enum会隐式继承enum，而Java采用的是单继承机制，所以不能在继承其他类

2、枚举类和普通类一样，可以实行接口

enum 类名 implements 接口1，接口2{}

契合c'c'c

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
枚举学习笔记

枚举学习笔记
复制链接

扫一扫