JavaSE之枚举与注解

枚举类

理解

​ 类的对象只有有限个，确定的。我们称此类为枚举类。

​ 当需要定义一组常量时，强烈建议使用枚举类

​ 如果枚举类中只有一个对象，则可以作为单例模式的实现方式。

如何定义

方式一：自定义枚举类

public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}
//自定义枚举类
class Season{
    //1.声明Season对象的属性:private final修饰（对象都是final的，因此属性也干脆声明成final）
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值(不私有化构造器，外部可能会调用，因此不能确定有多少对象，和枚举类的定义产生矛盾)
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //3.提供当前枚举类的多个对象：public static final的(对象是肯定的，明确数目)
    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.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求1：提供toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

方式二：用关键字enum来定义枚举类

interface Info{//接口
    void show();
}

//使用enum关键字枚举类
enum Season1 implements Info{//实现接口
    //1.提供当前枚举类的对象
    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("大约在冬季");
        }
    };

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

    //2.私有化类的构造器,并给对象属性赋值

    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    
public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;//类调用对象
        //toString():返回枚举类对象的名称
        System.out.println(summer);//结果为SUMMER
        
//        System.out.println(Season1.class.getSuperclass());
//        定义的枚举类默认继承于java.lang.Enum类
        
        System.out.println("****************");
        //values():返回所有的枚举类对象构成的数组
        Season1[] values = Season1.values();
        for(int i = 0;i < values.length;i++){
            System.out.println(values[i]);//结果是所有对象名SPRING\SUMMER\AUTUMN\WINTER
            values[i].show();//调用各个对象中重写的show方法
        }
        
        System.out.println("****************");
        Thread.State[] values1 = Thread.State.values();
        for (int i = 0; i < values1.length; i++) {
            System.out.println(values1[i]);//输出线程有哪些状态
        }

        //valueOf(String objName):返回枚举类中对象名是objName的对象。
        Season1 winter = Season1.valueOf("WINTER");
        //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
//        Season1 winter = Season1.valueOf("WINTER1");
        System.out.println(winter);//输出结果就是WINNER，即对象名
        winter.show();
    }
}

注解(Annotation)

理解

​ Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。

使用示例

示例一：生成文档相关注释

/**
*@author
*@create
*/

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

1. @Override: 限定重写父类方法, 该注解只能用于方法

    @Override
       public void walk() {
           System.out.println("学生走路");
       }
   

2. @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择

   旧版本已过时的方法、类，在新版本中不建议使用，但仍可以使用，避免使用了新版jdk而导致旧代码失效

   @Deprecated
       public Date(int year, int month, int date) {
           this(year, month, date, 0, 0, 0);
       }
   

​ 若使用了则会出现 横线

3. @SuppressWarnings: 抑制编译器警告

   @SuppressWarnings("unused")
           int num = 10;
   //z未使用num这一变量时，系统会有提示，而此注解可以关闭系统提示
   

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

自定义注解

参照@SuppressWarnings定义

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

如果注解有成员，在使用注解时，需要指明成员的值。

自定义注解必须配上注解的信息处理流程(使用反射)才有意义。

自定义注解通过都会指明两个元注解：Retention、Target

jdk提供的四种元注解

元注解：对现有的注解进行解释说明的注解

Retention

​ 指定所修饰的 Annotation 的生命周期：

1. SOURCE\
2. CLASS（默认行为）\
3. RUNTIME只有声明为RUNTIME生命周期的注解，才能通过反射获取。

Target

​ 用于指定被修饰的 Annotation 能用于修饰哪些程序元素

@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})

Documented

​ 表示所修饰的注解在被javadoc解析时，保留下来。

Inherited

​ 被它修饰的 Annotation 将具有继承性。

Java8中的新注解

可重复注解

6.1 可重复注解：① 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。

@Inherited
@Repeatable(MyAnnotations.class)//
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {

    String value() default "hello";
}

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {

    MyAnnotation[] value();
}

类型注解

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

ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

class Generic<@MyAnnotation T>{//TYPE_PARAMETER

    public void show() throws @MyAnnotation RuntimeException{//TYPE_USE

        ArrayList<@MyAnnotation String> list = new ArrayList<>();//TYPE_USE

        int num = (@MyAnnotation int) 10L;//TYPE_USE
    }

}