第十四章新特性 - 1.JDK5新特性 - 《Java基础》

枚举

自动拆装箱
泛型
可变参数
静态导入
增强for循环
互斥锁
枚举

枚举

枚举概述

是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。例：一周只有7天，一年只有12个月等。

回想单例设计模式：单例类是一个类只有一个实例. 那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例，这才能是枚举类。

手动实现枚举

实现无参构造枚举

class MonthEnum{
    /**
     * 私有构造，不让外部创建实例
     */
    private MonthEnum(){
    }
    /**一月*/
    public static final MonthEnum month_1 = new MonthEnum();
    /**二月*/
    public static final MonthEnum month_2 = new MonthEnum();
    /**三月*/
    public static final MonthEnum month_3 = new MonthEnum();
}

实现有参构造的枚举

class MonthEnum2{
    private String name;
    public MonthEnum2(String name){
        this.name = name;
    }
    public static final MonthEnum2 month_1 = new MonthEnum2("一月");
    public static final MonthEnum2 month_2 = new MonthEnum2("二月");
    public static final MonthEnum2 month_3 = new MonthEnum2("三月");
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return name;
    }
}

使用抽象类实现枚举

/**
 * 抽象类
 */
abstract class MonthEnum3{
    private String name;
    public MonthEnum3(String name){
        this.name = name;
    }
    /**
     * 添加抽象方法
     */
    public abstract void show();
    public static final MonthEnum3 month_1 = new MonthEnum3("一月"){
        @Override
        public void show() {
            System.out.println("show 一月");
        }
    };
    public static final MonthEnum3 month_2 = new MonthEnum3("二月"){
        @Override
        public void show() {
            System.out.println("show 二月");
        }
    };
    public static final MonthEnum3 month_3 = new MonthEnum3("三月"){
        @Override
        public void show() {
            System.out.println("show 三月");
        }
    };
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return name;
    }
}

测试枚举类

/**
     * 实现无参构造的枚举类测试
     */
    @Test
    public void demo1(){
        MonthEnum month_1 = MonthEnum.month_1;
        MonthEnum month_2 = MonthEnum.month_2;
        MonthEnum month_3 = MonthEnum.month_3;
    }
    /**
     * 实现有参构造的枚举类测试
     */
    @Test
    public void demo2(){
        MonthEnum2 month_1 = MonthEnum2.month_1;
        MonthEnum2 month_2 = MonthEnum2.month_2;
        MonthEnum2 month_3 = MonthEnum2.month_3;
        System.out.println(month_1);
        System.out.println(month_2);
        System.out.println(month_3);
    }
    /**
     * 使用抽象类
     */
    @Test
    public void demo3(){
        MonthEnum3 month_1 = MonthEnum3.month_1;
        MonthEnum3 month_2 = MonthEnum3.month_2;
        MonthEnum3 month_3 = MonthEnum3.month_3;
        month_1.show();
        month_2.show();
        month_3.show();
        System.out.println("=================");
        System.out.println(month_1);
        System.out.println(month_2);
        System.out.println(month_3);
    }

通过enum关键字实现枚举

无参构造枚举

/**
 * 定义枚举类要用关键字enum
 */
enum Week{
    /**
     * 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
     */
    MON,TUE,WED;
}

有参构造枚举

/**
 * 枚举类可以有构造器，但必须是private的，它默认的也是private的。
 */
enum Week2{
    MON("星期一"),TUE("星期二"),WED("星期三");
    private String name;
    private Week2(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

抽象方法枚举

/**
 * 枚举类也可以有抽象方法，但是枚举项必须重写该方法
 */
enum Week3{
    MON("星期一"){
        @Override
        public void show() {
            System.out.println("show 星期一");
        }
    },TUE("星期二"){
        @Override
        public void show() {
            System.out.println("show 星期二");
        }
    },WED("星期三"){
        @Override
        public void show() {
            System.out.println("show 星期三");
        }
    };
    public abstract void show();
    private String name;
    private Week3(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

测试枚举类

/**
     * 测试无参构造的枚举类
     */
    @Test
    public void demo1(){
        Week mon = Week.MON;
        Week tue = Week.TUE;
        Week wed = Week.WED;
        System.out.println(mon);
        System.out.println(tue);
        System.out.println(wed);
    }


    /**
     * 测试带参构造的枚举类
     */
    @Test
    public void demo2(){
        Week2 mon = Week2.MON;
        Week2 tue = Week2.TUE;
        Week2 wed = Week2.WED;
        System.out.println(mon.getName());
        System.out.println(tue.getName());
        System.out.println(wed.getName());
    }


    /**
     *带抽象方法的枚举类
     */
    @Test
    public void demo3(){
        Week3 mon = Week3.MON;
        Week3 tue = Week3.TUE;
        Week3 wed = Week3.WED;

        mon.show();
        tue.show();
        wed.show();
        System.out.println("===================");
        System.out.println(mon.getName());
        System.out.println(tue.getName());
        System.out.println(wed.getName());
    }

枚举在switch语句中的使用

switch可接收哪些类型？

基本类型：byte short int char
1.5版本起可以接收enum

1.7版本起可以接收string

  @Test
  public void demo4(){
      Week mon = Week.TUE;
      switch (mon){
          case MON:
              System.out.println("星期一");
          break;
          case TUE:
              System.out.println("星期二");
              break;
          case WED:
              System.out.println("星期三");
              break;
          default:
              System.out.println("其他");
              break;
      }

  }

枚举的注意事项

定义枚举类要用关键字enum
所有枚举类都是Enum的子类
枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
枚举类可以有构造器，但必须是private的，它默认的也是private的。
枚举类也可以有抽象方法，但是枚举项必须重写该方法

枚举类的常见方法

int ordinal()
int compareTo(E o)
String name()
String toString()
T valueOf(Class type,String name)

values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

enum MyEnum{
 Value1("Value1"),
 Value2("Value2"),
 Value3("Value3");

 private String name;
 private MyEnum(String name){
     this.name = name;
 }

 public String getName() {
     return name;
 }

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

```java public class Demo03Enum {

/**
 * 枚举类的常见方法
 *  int ordinal()
 */
@Test
public void demo1(){
    MyEnum value1 = MyEnum.Value1;
    MyEnum value2 = MyEnum.Value2;
    MyEnum value3 = MyEnum.Value3;

    /**
     *  获取实例名称
     */
    System.out.println("获取实例名称:");
    System.out.println(value1.getName());
    //调用重写之后的toString
    System.out.println(value1.toString());


    /**
     * 枚举项都是有编号的
     */
    System.out.println("枚举项都是有编号的:");
    System.out.println(value1.ordinal());//0
    System.out.println(value2.ordinal());//1
    System.out.println(value3.ordinal());//2



    /**
     * 枚举项比较的都是编号
     */
    System.out.println("枚举项比较的都是编号:");
    int i1 = value1.compareTo(value2);
    System.out.println(i1);
    int i2 = value1.compareTo(value3);
    System.out.println(i2);


}


/**
 * 通过字节码文件获取枚举项对象
 *  <T> T valueOf(Class<T> type,String name)
 */
@Test
public void demo2(){
    MyEnum value = MyEnum.valueOf(MyEnum.class, "Value2");

    System.out.println(value.toString());

    /**
     * 输出结果：
     *
     * MyEnum{name='Value2'}
     */
}


/**
 * 遍历枚举类所有枚举项
 * values()
 *  此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法。
 */
@Test
public void demo3(){
    MyEnum[] values = MyEnum.values();
    for (MyEnum value : values) {
        System.out.println(value);
    }

    /**
     * 输出结果：
     *
     * MyEnum{name='Value1'}
     * MyEnum{name='Value2'}
     * MyEnum{name='Value3'}
     */
}

} ```