第10章枚举类与注解

m0_49073190

已于 2024-05-14 17:23:58 修改

阅读量8

点赞数

分类专栏：尚硅谷java基础文章标签： java

于 2024-05-10 15:09:11 首次发布

原文链接：https://www.bilibili.com/video/BV1Kb411W75N/?p=513&share_source=copy_web&vd_source=df3a2d56252b40828d113d70ef8c376a

版权

尚硅谷java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第10章枚举类与注解

10-1 枚举类的使用

主要内容：

如何自定义枚举类
如何使用关键字enum定义枚举类☆
Enum类的主要方法☆
实现接口的枚举类

10.1.1 枚举类的使用：入门

枚举类的使用：入门

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

枚举类的使用
idea快捷键：ctrl + alt + shift + j —> 批量修改变量

10.1.4Enum类的主要方法

Enum类的主要方法
主要看这仨方法

package com.atguigu.java;

/**
 * 一、枚举类的使用
 * 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
 * 2.当需要定义一组常量时，强烈建议使用枚举类
 * 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式
 *
 * 二、如何定义枚举类
 * 方式一：jdk5.0之前，自定义枚举类
 * 方式二：jdk5.0，可以使用关键字enum关键字定义枚举类
 *
 * 三、Enum类中的常用方法:
 *    values()方法：返回枚举类型的对象数组。该方法可以很方便的遍历所有枚举值。
 *    valueOf(String str):可以把字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”，如不是，会有运行时异常
 *    toString():返回当前枚举类对象常量的名称
 *
 * 四、使用enum关键字定义的枚举类实现接口的情况
 *    情况一：实现接口，在enum类中实现抽象方法
 *    情况二：让枚举类的对象分别实现接口中的抽象方法
 *
 * @author 2023/09/12
 */
public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}

//自定义枚举类,继承于object
class Season{
    //1.声明Season对象的属性：private 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 + '\'' +
//                '}';
//    }
}

package com.atguigu.java;

/**
 * 使用enum关键字定义枚举类
 * 说明：定义的枚举类默认继承于java.lang.Enum
 * @author 2023/09/13
 */
public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());//SUMMER,没有重写toSring()时，将使用java.lang.Enum的toSring()--->默认只打印名字

//        System.out.println(summer.getClass().getSuperclass());
        System.out.println("********values**********");
        //values():返回所有的枚举类对象构成的数组
        Season1[] values = Season1.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
            values[i].show();
        }

        System.out.println("********Thread.State[]**********");
        //线程的状态
        Thread.State[] values1 = Thread.State.values();
        for (int i = 0; i < values1.length; i++) {
            System.out.println(values1[i]);
        }


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

        winter.show();
    }
}

interface Info{
    void show();
}
//自定义枚举类
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("大约在冬季");
        }
    };

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

    //2.私有化类的构造器，并给对象属性赋值
    private Season1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求1：提供枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

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

//    //实现接口，在enum类中实现抽象方法
//    @Override
//    public void show() {
//        System.out.println("这是一个季节");
//    }

}

10-2 注解的使用（Annotation）

主要内容
注解（Annotation）概述

10.2.1 注解（Annotation）概述

注解（Annotation）概述

10.2.2 常见的Annotation示例

常见的Annotation示例

常见的Annotation示例
在这里插入图片描述

10.2.3 自定义Annotation

在这里插入图片描述

@SuppressWarning：抑制编译器警告在eclipse体现更明显

10.2.4 JDK中的元注解

元注解

元注解：修饰其他注解的注解
元数据：对现有数据修饰的一种数据
String name = “atguigu”中
“String” “name” 都是元数据，用来修饰“atguigu”

@Retention

jdk中的元注解

RetentionPolicy.SOURCE：表示在javac生成.class时不会保留此注解。即反编译时，看不到此注解

RetentionPolicy.CLASS：编译时有，运行时不存在
RetentionPolicy.RUNTIME：编译时存在，内存中也存在，反编译时也存在

@SuppressWarning：编译时的校验，生命周期比较短，所以反编译看不到此注解

@Retention

在这里插入图片描述

@Target

在这里插入图片描述

10.2.6 JDK8中注解的新特性

可重复注解

在这里插入图片描述

类型注解

在这里插入图片描述

package com.atguigu.java1;

import org.junit.Test;

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

/**
 * 注解的使用
 *
 * 1.理解Annotation:
 * ① jdk 5.0 新增的功能
 * ② Annotation 其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行响应的处理。
 * 通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。
 * 代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
 * ③在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。
 * 在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的冗杂的代码和XML配置等。
 * ④ Annotation可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明，
 * 这些信息被保存在Annotation的“name=value”中
 * 2.Annotation的使用示例
 * 示例一：生成文档相关的注解
 * 示例二：在编译时进行格式检查（JDK内置的三个基本注解）
 *      @Override：限定重写父类方法，该注解只能用于方法
 *      @Deprecated:用于表示所修饰的元素（类、方法等）已过时。通常是因为所修饰的解构很危险或存在更好的选择
 *      @SuppressWarning：抑制编译器警告
 * 示例三：跟踪代码依赖性，实现替代配置文件功能
 *
 * 3.如何自定义注解：参照@SuppressWarning定义
 *  ①注解声明为：@interface
 *  ②内部定义成员，通常使用value标识
 *  ③可以使用成员的默认值，使用default定义
 *  ④如果自定义注解没有成员，表明是一个标识作用。
 *
 * 如果注解有成员，在使用成员时，需要指明成员的值。有默认值时不用
 * 自定义注解必须配上注解的信息处理流程（使用反射）才有意义
 * 自定义注解都会指定两个元注解：Retention、Target
 *
 * 4.jdk 提供的4种元注解
 *  元注解：对现有注解进行解释说明的注解
 *  Retention：指定所修饰的Annotation的生命周期：SOURCE\CLASS（默认行为）\RUNTIME
 *              只有声明为RUNTIME生命周期的注解，才能通过反射获取。
 *  Target：用于指定被修饰的Annotation 能用于修饰哪些程序元素
 *  *********出现的频率较低******************
 *  Documented：表示所修饰的注解在被javadoc解析时，保留下来。（默认情况下，javadoc是不包括注解的） Deprecated
 *  Inherited：被@Inherited修饰的Annotation具有继承性
 *
 *  5.通过反射获取注解信息---反射内容时系统讲解
 * 	 要求此注解的元注解Retention中声明的生命周期状态为：RUNTIME
 *
 *  6.jdk 8 中注解的新特性：可重复注解、类型注解
 *      6.1 可重复注解：①在MyAnnotation上声明@Repeatable，成员值为MyAnnotation.class
 *                   ②MyAnnotation的@Target、@Retention等元注解与MyAnnotations相同
 *
 *      6.2 类型注解：ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
 *                  ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
 *
 *
 * @author 2023/09/14
 */
public class AnnotationTest {
    public static void main(String[] args) {
        Person p = new Student();
        p.walk();

        //Deprecated
        Date date = new Date(2020, 10, 11);
        System.out.println(date);

        @SuppressWarnings("unused")
        int num = 10;
//        System.out.println(num);

        //泛型；SuppressWarnings数组形式，可以写多个值
        @SuppressWarnings({"unused","rawtypes"})
        ArrayList<Object> list = new ArrayList<>();

    }

    //测试Inherited
    @Test
    public void testGetAnnotation() {
        Class clazz = Student.class;
        Annotation[] annotations = clazz.getAnnotations();
        for (int i = 0; i < annotations.length; i++) {
            System.out.println(annotations[i]);
        }
    }

}

//@MyAnnotation(value = "hello")
//可以使用默认值，或者改默认值
//jdk 8 之前的写法：
//@MyAnnotations({@MyAnnotation(value = "hi"),@MyAnnotation(value = "abc")})
@MyAnnotation(value = "hi")
@MyAnnotation(value = "abc")

class Person{
    private String name;
    private int age;

    public Person() {
    }

    @MyAnnotation//构造器也能使用注解
    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }
    public void walk(){
        System.out.println("人走路");
    }

    public void eat(){
        System.out.println("人吃饭");
    }

}
interface Info{
    void show();
}
//因为@Inherited，Student继承了Person的注解@MyAnnotation
class Student extends Person implements Info{

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

    @Override
    public void show() {

    }
}

class Generic<@MyAnnotation T>{
    public void show() throws @MyAnnotation RuntimeException{

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

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

package com.atguigu.java1;

import java.lang.annotation.*;

import static java.lang.annotation.ElementType.*;

/**
 * @author 2024/04/22
 */
//@Inherited
@Repeatable(MyAnnotations.class)
//可重复注解
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
//@Target({TYPE})表示自定义注解MyAnnotation能修饰类
public @interface MyAnnotation {

//    String value();
    String value() default "hello";//可以使用默认值
}

package com.atguigu.java1;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;

/**
 * @author 2024/05/08
 */
//可重复注解
@Retention(RetentionPolicy.RUNTIME)//和MyAnnotation绑定，需一致
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
    MyAnnotation[] value();
}