2023年6月3日,枚举，枚举底层实现

1. 枚举

1. 枚举

枚举是一种受限制的类，枚举第一行必须创建对象，枚举不能显示继承父类(枚举没有父类)，所有的自定义枚举类默认继承Enum类

package com.wz.enum01;

public enum  Season {
    spring("春天","春雨绵绵"),
    summer("夏天","烈日炎炎"),
    autumn("秋天","硕果累累"),
    winter("冬天","寒风凌冽")
    ;
    private String name;
    private String info;
    private Season(){

    }

    private Season(String name, String info) {
        this.name = name;
        this.info = info;
    }

    public String getName() {
        return name;
    }

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

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return this.name+":"+this.info;
    }
}

package com.wz.enum01;

public class test01 {
    /**
     * 知识点：枚举
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(Season.spring);
        System.out.println(Season.summer);
        System.out.println(Season.autumn);
        System.out.println(Season.winter);
    }
}

2. 枚举的特点

• 枚举就是一个受限制的类，默认继承Enum
• 枚举的第一行必须定义该枚举类型的对象
• 枚举类型对象默认添加： public static final 类型
• 枚举没有继承明确类(自定义枚举类默认继承Enum，Enum默认继承Object)
• 枚举类不能被继承
• 枚举里可以有构造方法、成员方法、静态方法、抽象方法
• 枚举可以实现接口
• 枚举里没有定义方法，可以在最后一个对象后面加逗号、分号或什么都不加

3. 枚举的优势

• 增强代码可读性
• 枚举型可直接与数据库交互
• switch语句优势
• 编译优势

(枚举类编译时，没有把常量值编译到代码中，即使常量值发生改变，也不会影响引用常量的类 )

• 将常量组织起来，统一管理
• 去除equals两者判断 由于常量值地址唯一，使用枚举可以直接通过“==”进行两个值之间的对比，性能会有所提高

2.枚举方法

1. 枚举方法

方法名	解释
Enum.valueOf(Class enumType, String name)	根据字符串找到该枚举类中的对象
public static void values()	获取该枚举类对象数组
public static void valueOf(String args0)	根据字符串获取该枚举类中的对象
public final String name()	获取该枚举对象名字
public final Class getDeclaringClass()	获取枚举对象的枚举类型相对应的Class对象
public final int hashCode()	获取该枚举对象的hash值
public final int compareTo(E o)	两个枚举对象进行比较
public final boolean equals(Object other)	比较两个枚举对象是否相同

package com.wz.enum01;

public class test02 {
    /**
     * 知识点：枚举的方法
     *
     */
    public static void main(String[] args) {
        //根据字符串找到该枚举类中的对象
        Season season1 = Enum.valueOf(Season.class, "spring");
        System.out.println(season1);
        //根据字符串获取该枚举类中的对象
        Season season2 = Season.valueOf("spring");
        System.out.println(season2);
        System.out.println(season1==season2);
        //获取该枚举队对象的名字
        Season[] seasons = Season.values();
        for (Season season:seasons
             ) {
            System.out.println(season.name());
        }

    }
}

2. 枚举底层

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    //枚举对象名
    private final String name;
    //枚举编号 -- 从0开始
    private final int ordinal;
    
    //获取枚举对象名
    public final String name() {
        return name;
    }
    
    //获取枚举编号
    public final int ordinal() {
        return ordinal;
    }
    
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
    
}

package com.qf.enum02;

//枚举是一个特殊的类，默认继承Enum
public final class Season extends Enum{

    //该类的对象引用
	public static final Season spring;
	public static final Season summer;
	public static final Season autumn;
	public static final Season winter;
    
    //该类的属性
	private String name;//成员属性
	private String info;//成员属性
	private static final Season[] ENUM$VALUES;//枚举对象数组

    //public Season(){}
	private Season(String s, int i){
		super(s, i);
	}

    //public Season(String name,String info){}
	private Season(String s, int i, String name, String info)
	{
		super(s, i);
		this.name = name;
		this.info = info;
	}

	public String getName()
	{
		return name;
	}

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

	public String getInfo()
	{
		return info;
	}

	public void setInfo(String info)
	{
		this.info = info;
	}

	public String toString()
	{
		return (new StringBuilder(String.valueOf(name))).append(" -- ").append(info).toString();
	}

    //获取该枚举类所有的对象
	public static Season[] values()
	{
		Season aseason[];
		int i;
		Season aseason1[];
		System.arraycopy(aseason = ENUM$VALUES, 0, aseason1 = new Season[i = aseason.length], 0, i);
        
        //思路：创建新数组，将ENUM$VALUES中所有的元素复制到新数组中，返回新数组
        //设计思想：不把ENUM$VALUES暴露给外界，因为怕外界修改数组中的元素，所以创建新数组复制并返回
        //aseason = ENUM$VALUES;
        //int i = aseason.length;
        //Season aseason1[] = new Season[i];
        //System.arraycopy(aseason, 0, aseason1, 0, i);
        
		return aseason1;
	}

	public static Season valueOf(String s)
	{
		return (Season)Enum.valueOf(com/qf/enum02/Season, s);
	}

    //静态代码块 -- 目的：枚举类的初始化工作
	static {
        //创建枚举对象(枚举名,对象编号,自定义属性,自定义属性)
        //枚举名对象编号的数据传入父类中 -- super(s,i)
		spring = new Season("spring", 0, "春天", "春雨绵绵");
		summer = new Season("summer", 1, "夏天", "烈日炎炎");
		autumn = new Season("autumn", 2, "秋天", "硕果累累");
		winter = new Season("winter", 3, "冬天", "寒风凛凛");
        
        //初始化枚举对象数组
		ENUM$VALUES = (new Season[] {
			spring, summer, autumn, winter
		});
	}
}

3. 枚举的switch实现

创建数组，获取枚举对象的int值

package com.qf.enum02;

import java.io.PrintStream;

public class Test03{

    //[1,2,3,4]
	private static int $SWITCH_TABLE$com$qf$enum02$Season[];

	public static void main(String args[]){
        
        //switch底层处理枚举类型是获取到枚举类对象对应的int值
		switch ($SWITCH_TABLE$com$qf$enum02$Season()[Season.spring.ordinal()]){
            case 1:
                System.out.println("春天");
                break;

            case 2:
                System.out.println("夏天");
                break;

            case 3:
                System.out.println("秋天");
                break;

            case 4:
                System.out.println("冬天");
                break;

            default:
                System.out.println("默认");
                break;
		}
	}

    
    //初始化$SWITCH_TABLE$com$qf$enum02$Season数组 - 获取到枚举对象在switch的编号
    //注意1：枚举对象在枚举类中的编号是从0开始
    //注意2：枚举对象在switch中的编号从1开始 -- 思想：第几个枚举对象
	static int[] $SWITCH_TABLE$com$qf$enum02$Season(){
       
		//创建int数组 -- new int[4]
		int ai[] = new int[Season.values().length];
		try
		{
            //ai[获取枚举对象的编号]
            //ai[2] = 3;
			ai[Season.autumn.ordinal()] = 3;
		}
		catch (NoSuchFieldError ) { }
		try
		{
            //ai[0] = 1;
			ai[Season.spring.ordinal()] = 1;
		}
		catch (NoSuchFieldError ) { }
		try
		{
            //ai[1] = 2;
			ai[Season.summer.ordinal()] = 2;
		}
		catch (NoSuchFieldError ) { }
		try
		{
            //ai[3] = 4;
			ai[Season.winter.ordinal()] = 4;
		}
		catch (NoSuchFieldError ) { }
		return $SWITCH_TABLE$com$qf$enum02$Season = ai;
	}
}