java学习之枚举

只读有限个，不能修改
enumeration 枚举
枚举是一组特殊的类
可以这样理解：里面有一组特定对象的类

枚举

枚举的二种实现方式

自定义实现枚举

//原本状态
class Season{
    private String name;
    private String description;

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

    public String getName() {
        return name;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

改进后

public class Demo {
    public static void main(String[] args) {
        System.out.println(Season.SPRING.toString());
        System.out.println(Season.SUMMER.toString());
        System.out.println(Season.AUTUMN.toString());
        System.out.println(Season.WINTER.toString());

    }
}


class Season{
    private String name;
    private String description;
    //1.将构造器私有化，导致无法new对象
    private Season(String name, String description) {
        this.name = name;
        this.description = description;
    }
    //1. 将构造器私有化,目的防止 直接 new
    //2. 去掉 setXxx 方法, 防止属性被修改
    //3. 在 Season 内部，直接创建固定的对象
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season SUMMER = new Season("夏天", "炎热");
    //4. 优化，可以加入 final 修饰符
    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

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

1. 构造器私有化
2. 本类内部创造一组对象
3. 不需要提供SetXxx方法，因为枚举通常为只读可以提供（getXxx方法）
4. 对枚举的对象/属性使用 fianl static 共同修饰 ，实现底层优化（向外暴露对象）
5. 枚举通常使用大写【常量的命名规范】
6. 枚举对象根据须需要有多个属性

enum关键字实现枚举

1. 使用关键字 enum 替代 class
2. public static final Season SPRING = new Season(“春天”, “温暖”) 直接使用
   SPRING(“春天”, “温暖”) 解读 常量名(实参列表)
3. 如果有多个常量(对象)， 使用 ,号间隔即可
4. 如果使用 enum 来实现枚举，要求将定义常量对象，写在前面
5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()

public class Demo {
    public static void main(String[] args) {
        System.out.println(Season.SPRING.toString());
        System.out.println(Season.SUMMER.toString());
        System.out.println(Season.AUTUMN.toString());
        System.out.println(Season.WINTER.toString());

    }
}


enum Season{
    SPRING("春天","温暖"),SUMMER("夏天","炎热"),
    AUTUMN("秋天","凉爽"),WINTER("冬天","寒冷");
    private String name;
    private String description;
    //1.将构造器私有化，导致无法new对象
    private Season(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

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

枚举的注意事项

1. 当我们使用enum 关键字开发一个枚举类时，默认会继承Enum类, 而且是一个final 类[如何证明],老师使用javap 工具来演示
2. 传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”)， 这里必
   须知道，它调用的是哪个构造器.
3. 如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略
4. 当有多个枚举对象时，使用,间隔，最后有一个分号结尾
5. 枚举对象必须放在枚举类的行首
   图中发现 Enum是final类
   几个常量的修饰词是固定，都为public static final
   Enum还有其他成员方法和静态代码块

Enum的成员方法

1. toString:Enum 类已经重写过了，返回的是当前对象
   名,子类可以重写该方法，用于返回对象的属性信息
2. name：返回当前对象名（常量名），子类中不能重写
3. ordinal：返回当前对象的位置号，默认从 0 开始
4. values：返回当前枚举类中所有的常量
5. valueOf：将字符串转换成枚举对象，要求字符串必须
   为已有的常量名，否则报异常！
   可以看作是给枚举类对象创建引用变量名
6. compareTo：比较两个枚举常量，比较的就是编号！
   返回的前面的编号减去后面的编号

//下面的枚举类Season是借助上面的枚举类Season
public class Demo {
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        //name()  输出当前枚举对象的名称，优先使用toString方法
        System.out.println(autumn.name());
        //ordinal()方法，输出的是该枚举对象的次序（从0开始编号）
        System.out.println(autumn.ordinal());

		//valueOf方法，可以看作是给枚举类的某个对象创建引用变量名
		Season2 autumn1 = Season2.valueOf("AUTUMN");
        //values() 枚举所有对象（正常看不到该方法，反编译可以看到该方法）
        Season[] values = Season.values();
        for (Season season: values) { //增强for循环
            System.out.println(season);
        }
        //从枚举类去找，是否有该常量名
        //找到返回，没找到报错
        Season autumn1 = Season.valueOf("AUTUMN");
        System.out.println(autumn1);
        //compare to 是比较ordinal编号   返回的是前面的编号减去后面的编号
        System.out.println(Season.AUTUMN.compareTo(Season.SPRING));
    }
}

关于增强for循环的知识

public class Demo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        //普通for循环
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
        //增强for循环
        //for(需要打印东西的数据类型  变量名（自取）： 东西的来源)
        for (int i : array) {
            System.out.print(i + "\t");
        }
    }
}

其他细节

1. enmu类不能继承其他类，
   因为他继承enmu类，
   java类的继承必须满足单继承
2. enmu实现的枚举类，仍然是一个枚举类，所以还是能实现接口的
   enmu××× implements A，B{ }