Java复习九：枚举类+注解

枚举类

自定义枚举类

package com.xiazhui.java;

/**
 * TODO
 * 枚举类的使用
 *
 * 枚举类：类的对象只有有限个，确定的。
 * 当需要定义一组常量时，强烈建议使用枚举类
 * 如果枚举类的只有一个对象，可以作为单例模式的实现方式
 *
 * 枚举类的定：
 * 方式一：jdk5.0之前，自定义枚举类
 *          步骤:1 声明对象的属性：private final修饰
 *              2 私有化类的构造器，并给对象属性赋值
 *              3 提供当前枚举类的多个对象：public static final
 *              4 其他需要
 * 方式二：jdk5.0,可以使用enum关键字定义枚举类
 *
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/13/16:16
 */
public class EnumTest {
}

class Season{
    private final String seasonName;
    private final String seasonDesc;

    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 + '\'' +
                '}';
    }
}

使用enum关键字实现枚举类

package com.xiazhui.java;

/**
 * TODO
 * 枚举类的使用
 *
 * 枚举类默认继承java.lang.Enum
 * 枚举类的toString方法打印枚举类的名字
 *
 * 步骤：1 提供枚举类的对象，多个对象之间逗号隔开
 *      2 提供当前枚举类属性，private final
 *      3 私有化类的构造器，并给对象属性赋值
 *      4 其他需要
 *
 * Enum类中的常用方法:
 *      1 toString() 返回当前枚举类对象常量的名称
 *      2 values() 返回枚举类型的对象数组。该方法可以很方便的遍历所有的枚举值
 *      3 valueOf(String str) 可以把一个字符串转为对应的枚举类型。
 *          要求字符串必须是枚举类型对象，否则IllegalAugmentException
 *
 *  关键字enum枚举类实现接口
 *      情况一：实现接口，在enum中实现抽象方法
 *      情况二：让每个枚举类的对象分别实现接口中的抽象方法
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/13/16:35
 */
public class EnumClassTest {
    public static void main(String[] args) {
        Season1 spring = Season1.SPRING;
        System.out.println(spring.toString());

        //枚举类默认继承java.lang.Enum类
        System.out.println(spring.getClass().getSuperclass());

        Season1[] values = Season1.values();
        for (Season1 value : values) {
            System.out.println(value);
        }

        Thread.State[] values1 = Thread.State.values();
        for (Thread.State state : values1) {
            System.out.println(state);
        }

        Season1 winter = Season1.valueOf("WINTER");
        System.out.println(winter);

        spring.info();
    }
}

interface method{
    void show();
    void info();
}
enum Season1 implements method{


    SPRING("春天","春暖花开"){
        @Override
        public void info() {
            System.out.println("春天在哪二");
        }
    },
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    private final String seasonName;
    private final String seasonDesc;

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


    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public void show() {
        System.out.println("季节");
    }

    @Override
    public void info() {
        System.out.println("季节的哥");
    }
}

注解

自定义注解

package com.xiazhui.java;

import org.junit.jupiter.api.Test;


import java.lang.annotation.Annotation;
import java.util.ArrayList;

/**
 * TODO
 * 注解的使用
 *
 * 1 Annotation:
 *      jdk5.0新增的功能
 *      Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取
 *          并执行相应的处理，通过使用Annotation,程序员可以在不改变原有逻辑的情况下
 *          ，在源文件中嵌入一些补充信息。代码分析工具，开发工具和部署工具可以通过这些
 *          补充信息进行验证或者进行部署
 *      在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/
 *          Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE
 *          旧版中所遗留的繁冗代码和XML配置等
 *
 * 2 Annotation的使用实例
 *      1 完成文档相关的注解
 *      2 在编译时进行格式检查（JDK内置三个基本注解）
 *          @Override 限定重写父类方法，改注解只能用于方法
 *          @Deprecated 表示元素（类，方法）过时 所修饰的结构危险或者存在更好的选择
 *          @SuppressWarnings （抑制编译器警告）
 *      3 跟踪代码依赖性，实现配置文件功能
 *
 *  3 自定义注解 参照@SuppressWarnings
 *      1 注解声明为：@interface
 *      2 内部定义成员，使用value()表示,以无参方法的形式来定义
 *      3 可以指定成员的默认值，使用default定义
 *      4 如果自定义注解没有成员，表明是一个标识作用
 *
 *      如果注解有成员，在使用注解时，需要指明成员的值
 *      自定义注解必须配上注解的信息处理流程（使用反射）才有意义
 *
 *  4 JDK中提供的元注解
 *      元注解：对现有的注解进行解释说明的注解
 *          Retention 指定所修饰的Annotation的生命周期 SOURCE(default),CLASS.RUNTIME
 *          Target 用于指示Annotation可以修饰的程序元素
 *          Documented 用于指定修饰的Annotation作为注解在被javadoc解析时，保留下来，默认不包括注解
 *          Inherited 被他修饰的Annotation具有可继承性 子类继承父类的注解
 *
 *  5 可重复注解
 *      1 在MyAnnotation上声明@Repeatable,成员值为MyAnnotation.class
 *      2 在MyAnnotation的target和Retention,Inherited等元注解和MyAnnotations相同
 *
 *      或者在MyAnnotations注解中声明成员数组之后，通过（{}）赋值
 *
 * 6 类型注解
 *      ElementType.TYPE_PARAMETER:表示该注解能写在类型变量的声明语句中（如 泛型声明）
 *      ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/13/17:25
 */
public class AnnotationTest {
    public static void main(String[] args) {
        //IDEA不提示这种警告，不加警告则时灰色的
        @SuppressWarnings("unused")
        int num=10;


    }

    @Test
    public void test1(){
        Class studentClass = Student.class;
        Annotation[] annotations = studentClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

@MyAnnotation
@MyAnnotation
class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public void Walk(){
        System.out.println("人走路");
    }
}

class Student extends Person{
    @Override
    public void Walk() {
        System.out.println("学生蹦蹦跳的走");
    }
}

class Generic<@MyAnnotation T>{
    public void show() throws @MyAnnotation RuntimeException{
        ArrayList<@MyAnnotation  String> list=new ArrayList<>();
        int num=(@MyAnnotation int)10L;
    }
}

自定义和可重复注解

package com.xiazhui.java;

import java.lang.annotation.*;

/**
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/14/5:23
 */
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER,
        ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE,ElementType.TYPE_PARAMETER,
        ElementType.TYPE_USE})
public @interface MyAnnotation {
    String value() default "Hello";
}

package com.xiazhui.java;

import java.lang.annotation.*;

/**
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/14/6:18
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER,
        ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE,ElementType.TYPE_PARAMETER,
        ElementType.TYPE_USE})
public @interface MyAnnotations {
    MyAnnotation[] value();
}