Java枚举

啥叫枚举？

一个一个的举例出来
前提：有限、确定

自定义枚举类(JDK 1.5之前)

在java中，类的对象是有限个，确定的。这个类我们可以定义为枚举类。
举例：
星期：一二三四五六日
性别：男女
季节：春夏秋冬

package com.lxg.enums;

/**
 * @author lxg
 * @description 季节枚举类
 * @date 2021/9/23
 */
public class Season {
    //属性
    private final String seasonName;//季节名称
    private final String seasonDesc;//季节描述
    //利用构造器对属性进行赋值操作，并将构造器私有化，外界不能调用这个构造器，只能season内部自己调用
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //提供枚举类有限的、确定的对象
    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("冬天","冰天雪地");

    //额外因素
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

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

package com.lxg.enums;

/**
 * @author lxg
 * @description 测试类
 * @date 2021/9/23
 */
public class Test {
    public static void main(String[] args) {
        Season summer = Season.SUMMER;
        System.out.println(summer);
    }
}

使用enum关键字创建枚举类（JDK 1.5 之后）

定义枚举类

package com.lxg.enums;

/**
 * 使用关键字enum创建枚举类
 */
public enum Season2 {
    //提供枚举类有限的、确定的对象

    /**
     * enum 枚举类要求对象（常量）必须放在最开始的位置上
     * 多个对象之间使用逗号隔开，最后一个对象之后使用分号
     */
    SPRING("春天","春暖花开"),
    SUMMER("夏天","烈日炎炎"),
    AUTUMN("秋天","硕果累累"),
    WINTER("冬天","冰天雪地");


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

    
    //额外因素
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

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

使用枚举类

package com.lxg.enums;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * @author lxg
 * @description 测试类2
 * @date 2021/9/23
 */
public class Test2 {
    public static void main(String[] args) {
        Season2 winter = Season2.WINTER;
        System.out.println(winter);

        //enum关键子对应的枚举类上层父类是Java.lang.Enum
        //自定义的枚举类上层父类是Object
        System.out.println(Season2.class.getSuperclass().getName());
    }
}

在源码中经常看见下面这种形式代码，因为这个枚举类没有属性，构造器，toString,get方法都删掉不写，然后在常量中如下SPRING()都可以不写()变成了SPRING的形式。
看到的形态就只有常量（对象）名了。

package com.lxg.enums;

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

案例：

如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;
    }

Enum 中常用方法

package com.lxg.enums;

/**
 * @author lxg
 * @description 测试类
 * @date 2021/9/23
 */
public class Test3 {
    public static void main(String[] args) {

        /**
         * 使用enum关键字创建的Season枚举类父类是java.lang.Enum,父类中的方法，子类可以
         * 拿来用，常用方法有一下部分：
         */

        //toString():获取对象名字
        Season3 autumn = Season3.AUTUMN;
        System.out.println(autumn);

        //values():返回枚举对象的数组
        Season3[] values = Season3.values();
        for (Season3 s:values) {
            System.out.println(s);
        }

        //valueOf():通过对象名获取枚举对象
        //注意：对象的名字必须写对，否则会抛出异常
        Season3 autumn1 = Season3.valueOf("AUTUMN");
    }
}

枚举类实现接口

定义一个接口

package com.lxg.enums;

public interface TestInterface {
    void show();
}

枚举类实现接口

package com.lxg.enums;

/**
 * 枚举类实现接口
 */
public enum Season4 implements TestInterface{
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;

    /**
     * 重写接口中的抽象方法
     */
    @Override
    public void show() {
        System.out.println("这是Season4");
    }
}

测试

package com.lxg.enums;

/**

• @author lxg
• @description 测试类
• @date 2021/9/23
  */
  public class Test4 {
  public static void main(String[] args) {
  //所有的枚举对象，调用show()方法的时候都是一样的
  Season4.SPRING.show();
  Season4.SUMMER.show();
  Season4.AUTUMN.show();
  Season4.WINTER.show();
  }
  }

新需求：

要求每个对象调用show()方法结果不同该怎么搞？
如下：

package com.lxg.enums;


/**
 * 枚举类实现接口
 */
public enum Season4 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("这是Season4");
    }*/
}

实际应用

定义性别

package com.lxg.enums;

public enum Gender {
    男,
    女;
}

package com.lxg.enums;

/**
 * @author lxg
 * @description Person
 * @date 2021/9/23
 */
public class Person {

    private String name;
    private Gender sex;
    private int age;

    public String getName() {
        return name;
    }

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

    public Gender getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

package com.lxg.enums;

/**
 * @author lxg
 * @description 测试类
 * @date 2021/9/23
 */
public class Test5 {

    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(19);
        p.setName("lili");
        p.setSex(Gender.男);//传入枚举类Gender的对象：-->在入口处对参数进行了限制
        System.out.println(p);
    }
}

过枚举结合switch处理

package com.lxg.enums;

/**
 * @author lxg
 * @description ceshilei
 * @date 2021/9/23
 */
public class Test6 {
    public static void main(String[] args) {
        Gender sex = Gender.男;

        //switvh后面的（）中可以放入枚举
        //switvh后面的():int、short、byte、char、String、枚举
        switch(sex){
            case 男:
                System.out.println("男孩");
                break;
            case 女:
                System.out.println("女孩");
            default:
                System.out.println("人妖");
        }
    }
}