对比Java 5.0前后的枚举类的定义和使用

package js;

/**
 * @Author:asher
 * @Date:2021/7/11 23:05
 * @Description:js
 * @Version:1.0
 */
public class DBEnumTest {
    public static void main(String[] args) {
        System.out.println(DBEnum.MSSQL.getDbName());
        DBEnum dbEnum = DBEnum.ORACLE;
        System.out.println(dbEnum);
    }
}

class DBEnum {
//    2定义若干常量，其实就是定义枚举类对象的成员变量(属性)，要用private final来修饰
//    题外话，final变量初始化有3种常见方式：定义时；constructor、static code 实例化；
//    但是，我们这里不能用1，3种，为什么？这两种方式的实例化，将导致每个成员变量的属性值都是一致的
    private final String dbName;
    private final String dbVendor;

  //1 私有化该类的构造方法，目的就是不让你在类外面实例化该类的对象。否则，如果可以在外面实例化的话，
//    则不能控制该类的对象的个数是有限个的；这和枚举类的特性相违背了，所有构造方法要私有化；
    private DBEnum(String dbName,String dbVendor) {
        this.dbName = dbName;
        this.dbVendor = dbVendor;
    }

    //    3提供当前枚举类的多个对象(这里的多个，就是要确定的且是有限个的，这里创建了几个，就有几个)
  //static关键字表示的是，将来可以直接通过DBEnum.ORACLE的方式来直接使用这个对象
  //final关键字表示的是，这个对象一旦实例化，在当前类外面，就不可以再次对它执行初始化了
    public static final DBEnum ORACLE = new DBEnum("Oracle", "@Oracle corporation");
    public static final DBEnum DB2 = new DBEnum("DB2", "@IBM corp");
    public static final DBEnum MSSQL = new DBEnum("SQL Server", "@Microsoft corp");

//    4提供枚举类对象属性(dbName,dbVendor)的getter，因为它们是private的，所以不能有setter


    public String getDbName() {
        return dbName;
    }

    public String getDbVendor() {
        return dbVendor;
    }

//    提供toString()方法

    @Override
    public String toString() {
        return "DBEnum{" +
                "dbName='" + dbName + '\'' +
                ", dbVendor='" + dbVendor + '\'' +
                '}';
    }
}
//执行结果：
SQL Server
DBEnum{dbName='Oracle', dbVendor='@Oracle corporation'}

/**
 * @Author:asher
 * @Date:2021/7/12 08:38
 * @Description:js
 * @Version:1.0
 */
public class SeasonTest {
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        System.out.println(autumn.getSeasonName() + autumn.getSeasonDesc());
        System.out.println(autumn);
    }
}
enum Season{
    SPRING("SPRING", "春天"),
    SUMMER("SUMMER","夏天"),
    AUTUMN("AUTUMN","秋天"),
    WINTER("WINTER","冬天");

    private final String seasonName;
    private final String seasonDesc;

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

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
}

enum DBEnum1 {
    //    3提供当前枚举类的多个对象(这里的多个，就是要确定的且是有限个的)
  //由于是通过enum关键字来定义的枚举类，要求一上来就要定义枚举类的对象，本来应该是写成
  //public static final DBEnum1 ORACLE = new DBEnum1("Oracle", "@Oracle corporation")
  //这种格式的。但是，有多个对象，所以就把前面的public static final关键字省略了，接着把类名DBEnum1
  //和后面的 = new DBEnum1也省略了。最后变成了"对象名(成员变量列表)"的格式了。
    ORACLE("Oracle", "@Oracle corporation"),
    DB2("DB2", "@IBM corp"),
    MSSQL("SQL Server", "@Microsoft corp");

    //    2定义若干常量，其实就是定义枚举类对象的成员变量，要用private final来修饰
//    题外话，final变量初始化有3种常见方式：定义时；constructor、static code 实例化；
//    但是，我们这里不能用1，3种，为什么？这两种方式的实例化，将导致每个成员变量的属性值都是一致的
    private final String dbName;
    private final String dbVendor;
    //1 私有化该类的构造方法，目的就是不让你在类外面实例化该类的对象。否则，如果可以在外面实例化的话，
//    则不能控制该类的对象的个数是有限个的；这和枚举类的特性相违背了，所有构造方法要私有化；
    DBEnum1(String dbName,String dbVendor) {
        this.dbName = dbName;
        this.dbVendor = dbVendor;
    }


//    4提供枚举类对象属性(dbName,dbVendor)的getter，因为它们是private的，所以不能有setter
    public String getDbName() {
        return dbName;
    }

    public String getDbVendor() {
        return dbVendor;
    }

//    提供toString()方法
    //通过enum定义的枚举类，不再需要重写toString()方法，因为，此时的枚举类是Enum类的子类，不再直接继承于Object类。

}

/**
 * @Author:asher
 * @Date:2021/7/11 17:22
 * @Description:js
 * @Version:1.0
 */
public class EnumTest {
    public static void main(String[] args) {
        Thread.State[] values = Thread.State.values();
        for (Thread.State s: values ) {
            System.out.println(s);
        }
    }
}