1. 枚举类的使用

1.1 自定义枚举类

枚举类的概念与背景

当类的对象只有有限个，确定个时，此类称为枚举类。当需要定义一组常量时，强烈建议使用枚举类

星期：Monday(星期一)、......、Sunday(星期天)
性别：Man(男)、Woman(女)
季节：Spring(春节)......Winter(冬天)

JDK1.5之前需要自定义枚举类，JDK1.5新增的enum关键字用于定义枚举类。

若枚举只有一个对象, 则可以作为一种单例模式的实现方式。

自定义创建一个枚举类


public class SeasonTest {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        System.out.println(season.toString());//Season{seasonName='春天', seasonDecs='春暖花开'}
    }
}

class Season{
    //1.声明Season对象的属性：private final修饰
    private final String seasonName;
    private final String seasonDecs;
    //2.私有化类的构造器
    private Season(String seasonName,String seasonDecs){
        this.seasonName = seasonName;
        this.seasonDecs = seasonDecs;
    }
    //3.提供当前枚举类的多个对象
    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("冬天","冰天雪地");
    //4.其它诉求
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDecs() {
        return seasonDecs;
    }

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

1.2 关键字enum定义枚举类

使用关键字enum创建一个枚举类


public class SeasonTest {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        //这是因为枚举类自动继承了java.long.Enum类，以及它的toString()，所以不会返回地址值
        System.out.println(season);//SPRING
    }
}

enum Season{
    //1.首先提供当前枚举类的对象，省略了多个相同的关键字，多个对象之间用','隔开，用';'结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性：private final修饰
    private final String seasonName;
    private final String seasonDecs;

    //3.私有化类的构造器
    private Season(String seasonName,String seasonDecs){
        this.seasonName = seasonName;
        this.seasonDecs = seasonDecs;
    }
    
    //4.其它诉求
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDecs() {
        return seasonDecs;
    }

}

1.3 Enum类的主要方法

三大主要方法

values()：返回枚举类型的对象数组
valueOf(String objName)：返回枚举类中对象名是objName的对象
toString()：返回当前枚举类对象常量的名称


public class SeasonTest {
    public static void main(String[] args) {
        Season season = Season.SPRING;

        //1.values()：返回枚举类型的对象数组
        Season[] values = Season.values();
        for(int i = 0;i < values.length;i++){
            System.out.println(values[i]);//SPRING、SUMMER、AUTUMN、WINTER
        }

        //2.valueOf（String objName）：返回枚举类中对象名是0bjName的对象。
        Season winter =Season.valueOf("WINTER");
        System.out.println(winter);//WINTER

        //3.toString()：返回当前枚举类对象常量的名称
        System.out.println(season.toString());//SPRING
    }
}
enum Season{
    //1.首先提供当前枚举类的对象，省略了多个相同的关键字，多个对象之间用','隔开，用';'结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");
    //2.声明Season对象的属性：private final修饰
    private final String seasonName;
    private final String seasonDecs;
    //3.私有化类的构造器
    private Season(String seasonName,String seasonDecs){
        this.seasonName = seasonName;
        this.seasonDecs = seasonDecs;
    }
    //4.其它诉求
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDecs() {
        return seasonDecs;
    }
}

其他方法

1.4 实现接口的枚举类

实现接口，在enum中实现抽象方法，每个对象的抽象方法不同，这是一种正常情况
实现接口，让枚举类的对象分别实现抽象方法，每个对象的抽象方法不同

package first.knowlodge.code05;

public class SeasonTest {
    public static void main(String[] args) {
        Season[] values = Season.values();
        for(int i = 0;i < values.length;i++){
            values[i].show();
            /*
            这是一个春暖花开的春天
            这是一个夏日炎炎的夏天
            这是一个秋高气爽的秋天
            这是一个冰天雪地的冬天
            */
        }
    }
}
interface info{
    void show();
}

enum Season implements info{
    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("这是一个冰天雪地的冬天");
        }
    };
    private final String seasonName;
    private final String seasonDecs;
    
    private Season(String seasonName,String seasonDecs){
        this.seasonName = seasonName;
        this.seasonDecs = seasonDecs;
    }
    
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDecs() {
        return seasonDecs;
    }
}

2. 注解的使用

2.1 注解概述

从JDK5.0开始, Java增加了对元数据的支持, 也就是Annotation(注解)。
Annotation其实就是代码里的特殊标记，这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。
Annotation可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。
在JavaSE中，注解的使用目的比较简单，在JavaEE/Android中注解占据了更重要的角色。

2.2 常见的Annotation示例

示例一：生成文档相关的注解

@author：标明开发该类模块的作者，多个作者之间使用,分割
@version：标明该类模块的版本
@see：参考转向，也就是相关主题
@since：从哪个版本开始增加的
@param：对方法中某参数的说明，如果没有参数就不能写
@return：对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception：对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写其中

示例二：在编译时进行格式检查(JDK内置的三个基本注解)

@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选
@SuppressWarnings: 抑制编译器警告

示例三：跟踪代码依赖性，实现替代配置文件功能

2.3 自定义Annotation

注解声明为：@interface
内部定义成员，通常使用用value表示
可以指定成员的默认值，使用default定义
如果自定义注解没有成员，表明是一个标识作用

public @interface MyAnnotation {
    String value() default "hi"
}

@MyAnnotation("hello")
class CalssTest{
    @MyAnnotation //可以不写值，因为已经有默认值"hi"
    void show(){
        System.out.println("这是一个注解测试");
    }
}

2.4 JDK中的元注解

什么是元注解

元注解是指用于修饰其它注解的注解

JDK中的4个元注解

Retention： 用于指定该 Annotation 的生命周期：SOURCE、CLASS、RUNTIME。
Target：用于指定被修饰的 Annotation 能用于修饰哪些程序元素。
Documented：被该元注解修饰的Annotation 类将被javadoc工具提取成文档。
Inherited：被它修饰的Annotation将具有继承性。如果某个类使用了被@Inherited修饰的Annotation，则其子类将自动具有该注解。

2.5 JDK8中注解的新特性

可重复注解

使用注解修饰时，可以使用该注解多次修饰，JDK8之前的方法是创建该注解的数组注解，进行修饰，JDK8之后可以重复行修饰。

使用步骤：

在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
MyAnnotation的Target和Retention注解与MyAnnotations相同

类型注解

ElementType.TYPE_PARAMETER：表示该注解能写在类型变量的声明语句中（如：泛型声明）。
ElementType.TYPE_USE：表示该注解能写在使用类型的任何语句中。

Java：枚举类和注解