Java基础进阶注解

灰太狼 2023-10-08 16:54 48阅读 0赞

注解，或者叫做**注释类型**，英文单词是：Annotation

注解Annotation是一种**引用数据类型**。**编译之后也是生成xxx.class文件。**

怎么自定义注解呢？语法格式？

[修饰符列表] @interface 注解类型名{
        
    
     }

注解怎么使用，用在什么地方？

*  第一：注解使用时的语法格式是：  
    **@注解类型名**
 *  第二：**注解可以出现在类上、属性上、方法上、变量上等…**  
    注解还可以出现在注解类型上。

JDK内置了哪些注解呢？

java.lang包下的注释类型：

*  掌握：  
    **Deprecated 用 @Deprecated 注释的程序元素，**  
    **不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。**
 *  掌握：  
    **Override 表示一个方法声明打算重写超类中的另一个方法声明。**
 *  不用掌握：  
    SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的  
    所有程序元素）中取消显示指定的编译器警告。

元注解  
什么是元注解？

*  **用来标注“注解类型”的“注解”，称为元注解。**

常见的元注解有哪些？

*  Target
 *  Retention

**关于Target注解：**

*  这是一个元注解，用来标注“注解类型”的“注解”
 *  **这个Target注解用来标注“被标注的注解”可以出现在哪些位置上。**
    
     *  @Target(ElementType.METHOD)：表示“被标注的注解”只能出现在方法上。  
        @Target(value=\{CONSTRUCTOR, FIELD, LOCAL\_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE\})
        
         *  表示该注解可以出现在：
         *  构造方法上
         *  字段上
         *  局部变量上
         *  方法上
         *  类上…
         *  …

**关于Retention注解：**

*  这是一个元注解，用来标注“注解类型”的“注解”
 *  这个Retention注解用来标注“被标注的注解”最终保存在哪里。

**@Retention(RetentionPolicy.SOURCE)：表示该注解只被保留在java源文件中。**  
**@Retention(RetentionPolicy.CLASS)：表示该注解被保存在class文件中。**  
**@Retention(RetentionPolicy.RUNTIME)：表示该注解被保存在class文件中，并且可以被反射机制所读取。**

**Retention的源代码**

//元注解	
    public @interface Retention {
        
    //属性
    	RetentionPolicy value();
    }
    
    RetentionPolicy的源代码：
    	public enum RetentionPolicy {
        
    		 SOURCE,
    		 CLASS,
    		 RUNTIME
    	}
    
    //@Retention(value=RetentionPolicy.RUNTIME)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation{
        }

**Target的源代码**

public @interface Target {
        
        /**
         * Returns an array of the kinds of elements an annotation type
         * can be applied to.
         * @return an array of the kinds of elements an annotation type
         * can be applied to
         */
        ElementType[] value();
    }
    public enum ElementType {
        
        /** Class, interface (including annotation type), or enum declaration */
        TYPE,
    
        /** Field declaration (includes enum constants) */
        FIELD,
    
        /** Method declaration */
        METHOD,
    
        /** Formal parameter declaration */
        PARAMETER,
    
        /** Constructor declaration */
        CONSTRUCTOR,
    
        /** Local variable declaration */
        LOCAL_VARIABLE,
    
        /** Annotation type declaration */
        ANNOTATION_TYPE,
    
        /** Package declaration */
        PACKAGE,
    
        /**
         * Type parameter declaration
         *
         * @since 1.8
         */
        TYPE_PARAMETER,
    
        /**
         * Use of a type
         *
         * @since 1.8
         */
        TYPE_USE
    }

#### 示例代码01: ####

// 默认情况下，注解可以出现在任意位置。
    
    @MyAnnotation
    public class AnnotationTest01 {
        
    
        @MyAnnotation
        private int no;
    
        @MyAnnotation
        public AnnotationTest01(){
        }
    
        @MyAnnotation
        public static void m1(){
        
            @MyAnnotation
            int i = 100;
        }
    
        @MyAnnotation
        public void m2(@MyAnnotation
                       String name,
                       @MyAnnotation
                       int k){
        
    
        }
    }
    
    @MyAnnotation
    interface MyInterface {
        
    
    }
    
    @MyAnnotation
    enum Season {
        
        SPRING,SUMMER,AUTUMN,WINTER
    }
    /*
    自定义注解：MyAnnotation
     */
    public @interface MyAnnotation {
        
        // ??????
    }
    // 注解修饰注解。
    @MyAnnotation
    public @interface OtherAnnotation {
        
    }

标识性注解，给编译器做参考的。  
编译器看到方法上有这个注解的时候，编译器会自动检查该方法是否重写了父类的方法。  
如果没有重写，报错。

这个注解只是在编译阶段起作用，和运行期无关！

#### 示例代码02： ####

// @Override这个注解只能注解方法。
    // @Override这个注解是给编译器参考的，和运行阶段没有关系。
    // 凡是java中的方法带有这个注解的，编译器都会进行编译检查，如果这个方法不是重写父类的方法，编译器报错。
    
    //@Override
    public class AnnotationTest02 {
        
    
        //@Override
        private int no;
    
        @Override
        public String toString() {
        
            return "toString";
        }
    }

#### 示例代码03： ####

// 表示这个类已过时。
    @Deprecated
    public class AnnotationTest03 {
        
    
        @Deprecated
        private int no;
    
        @Deprecated
        public void doSome() {
        
            System.out.println("doSome....");
        }
    
        // Deprecated这个注解标注的元素已过时。
        // 这个注解主要是向其它程序员传达一个信息，告知已过时，有更好的解决方案存在。
        @Deprecated
        public static void doOther() {
        
            System.out.println("doOther...");
        }
    }
    
    class T{
        
        public static void main(String[] args) throws ClassNotFoundException {
        
            AnnotationTest03 an3 = new AnnotationTest03();
            an3.doSome();
            AnnotationTest03.doOther();
    
        }

#### 运行结果： ####

![在这里插入图片描述][206a11dc3c29458bab7c2aef4238d53e.png]

#### 示例代码04： ####

public @interface MyAnnotation {
        
    
        /**
         * 我们通常在注解当中可以定义属性，以下这个是MyAnnotation的name属性。
         * 看着像1个方法，但实际上我们称之为属性name。
         * @return
         */
        String name();
    
        /*
        颜色属性
         */
        String color();
    
        /*
        年龄属性
         */
        int age() default 25;//属性指定默认值
    
    }
    public class MyAnnotationTest {
        
    
        // 报错的原因：如果一个注解当中有属性，那么必须给属性赋值。（除非该属性使用default指定了默认值。）
        /*@MyAnnotation
        public void doSome(){
    
        }*/
    
        //@MyAnnotation(属性名=属性值,属性名=属性值,属性名=属性值)
        //指定name属性的值就好了。
        @MyAnnotation(name="zhangsan",color="red")
        public void doSome(){
        
    
        }
    
    }

#### 示例代码05： ####

public @interface MyAnnotation {
        
    
        /*
       指定一个value属性。
        */
        String value();
    
        //String email();
    }
    /*
    如果一个注解的属性的名字是value，并且只有一个属性的话，在使用的时候，该属性名可以省略。
     */
    public class MyAnnotationTest {
        
    
        // 报错原因：没有指定属性的值。
        /*@MyAnnotation
        public void doSome(){
    
        }*/
    
        @MyAnnotation(value = "hehe")
        public void doSome(){
        
    
        }
    
        @MyAnnotation("haha")
        public void doOther(){
        
    
        }
    }
    =====================================================================================
    public @interface OtherAnnotation {
        
    
    
        String name();
    }
    // 报错了。因为属性名是name，不能省略。
    //@OtherAnnotation("test")
    public class OtherAnnotationTest {
        
    
        /*@OtherAnnotation(value="hh")
        public void doSome(){
    
        }*/
    
        // 正确的。
        @OtherAnnotation(name="test")
        public void doSome(){
        
    
        }
    }

#### 示例代码06： ####

public @interface MyAnnotion {
        
        /*
        注解当中的属性可以是哪一种类型？
            属性的类型可以是：
                byte short int long float double boolean char String Class 枚举类型
                以及以上每一种的数组形式。
         */
    
        int value1();
    
        int[] value6();
    
        String value2();
    
        String[] value3();
    
        Season value4();
    
        Season[] value5();
    
        Class value7();
    
        Class[] value8();
    
    
    }
    public @interface MyAnnotion {
        
        /*
        注解当中的属性可以是哪一种类型？
            属性的类型可以是：
                byte short int long float double boolean char String Class 枚举类型
                以及以上每一种的数组形式。
         */
    
        int value1();
    
        int[] value6();
    
        String value2();
    
        String[] value3();
    
        Season value4();
    
        Season[] value5();
    
        Class value7();
    
        Class[] value8();
    
    
    }
    public enum Season {
        
        SPRING,SUMMER,AUTUMN,WINTER
    }
    =================================================================================
    public @interface OtherAnnotation {
        
    
        /**
         * 字符串数组，name数组
         * @return
         */
        String[] name();
    
        /**
         * 季节数组，Season是枚举类型
         * @return
         */
        Season[] season();
    }
    public class OtherAnnotationTest {
        
    
        // 数组是大括号
        @OtherAnnotation(name={
        "zahngsan","lisi","wangwu"},season = {
        Season.SPRING,Season.AUTUMN})
        public void doSome(){
        
    
        }
    
        // 数组是大括号
        @OtherAnnotation(name="zhangsan",season = Season.WINTER)
        public void doOther(){
        
    
        }
    }

#### 示例代码07： ####

//元注解
    @Target({
        ElementType.TYPE,ElementType.METHOD})//定义此注解只能出现在类和方法上
    @Retention(RetentionPolicy.RUNTIME)//定义此注解保存在字节码（class）文件中，并且能被反射机制读取到
    @interface MyAnnotation {
        
    
        String value() default "广东深圳";
    }
    @MyAnnotation("广东省")
    class MyAnnotationTest {
        
    
        @MyAnnotation("广东省")
        public void doSome(){
        
    
        }
    }
    //通过反射获取注解的属性值
    public class ReflectAnnotationTest {
        
    
        public static void main(String[] args) throws ClassNotFoundException {
        
            //获取到MyAnnotation类
            Class c = Class.forName("annotation5.MyAnnotationTest");
            //判断类中是否存在某注解
            boolean flag = c.isAnnotationPresent(MyAnnotation.class);
            //如果存在，通过反射获取类的属性，并输出
            if(flag){
        
                MyAnnotation Myannotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
                String value = Myannotation.value();
                System.out.println("该注解的属性名是：" + value);
            }
            System.out.println(flag);
    
            //判断字符串类中是否存在该注解
            Class stringclass = Class.forName("java.lang.String");
            boolean flag1 = stringclass.isAnnotationPresent(MyAnnotation.class);
            System.out.println(flag1);
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][a2b20229c8d243dfb9e83001f5bea28a.png]

#### 示例代码08： ####

@Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation {
        
    
        String username();
    
        String password();
    }
    public class MyAnnotationTest {
        
    
        @MyAnnotation(username="admin",password="123123")
        public void doSome(){
        
    
        }
    
        public static void main(String[] args) throws Exception{
        
    
            //获取MyAnnotationTest类
            Class c = Class.forName("annotation6.MyAnnotationTest");
    
            //获取类中的方法
            Method doSome = c.getDeclaredMethod("doSome");
            //判断doSome方法上是否有注解，如果有，就输出注解属性值
            if(doSome.isAnnotationPresent(MyAnnotation.class)){
        
                MyAnnotation Myannotation = doSome.getAnnotation(MyAnnotation.class);
                System.out.println(Myannotation.username());
                System.out.println(Myannotation.password());
            }
        }
    }

#### 运行结果： ####

![在这里插入图片描述][aa3e94ce9b8642e0b1fb6311b572d9f4.png]

**需求：**

*  **假设有这样一个注解，叫做：@Id**
 *  **这个注解只能出现在类上面，当这个类上有这个注解的时候，**
 *  **要求这个类中必须有一个int类型的id属性。如果没有这个属性就报异常。**
 *  **如果有这个属性则正常执行！**

#### 示例代码09： ####

//自定义异常
    class HasntIdPropertyException extends RuntimeException{
        
    
        public HasntIdPropertyException(){
        
        }
    
        public HasntIdPropertyException(String s){
        
            super(s);
        }
    }
    public class Test {
        
        public static void main(String[] args) throws Exception{
        
    
            //获取类
            Class c = Class.forName("annotation7.User");
    
            //判断类中是否存在Id注解
            if(c.isAnnotationPresent(Id.class)){
        
                //获取类属性
                boolean isOk = false;// 给一个默认的标记
                // 当一个类上面有@MustHasIdPropertyAnnotation注解的时候，要求类中必须存在int类型的id属性
                // 如果没有int类型的id属性则报异常。
                // 获取类的属性
                Field[] fields = c.getDeclaredFields();
                for(Field field : fields) {
        
                    if ("no".equals(field.getName()) && "int".equals(field.getType().getSimpleName())) {
        
                        // 表示这个类是合法的类。有@Id注解，则这个类中必须有int类型的id
                        isOk = true;// 表示合法
                        break;
                    }
                }
                // 判断是否合法
                    if(!isOk){
        
                        throw new HasntIdPropertyException("被@NustHasIdPropertyAnnotation注解标注的类中必须有一个int类型的的的Id属性！");
                    }
                }
            }
        }
    @Id
    class User {
        
    
        String no;
        String name;
        int age;
    }
    // 表示这个注解只能出现在类上面
    @Target({
        ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
    // 该注解可以被反射机制读取到
    @Retention(RetentionPolicy.RUNTIME)
    @interface Id {
        
    }

#### 运行结果： ####

![在这里插入图片描述][3c5939e1b53a4386a52a1b6239f69a5f.png]  
![在这里插入图片描述][6627531b37ed4da587e53c0505385cd7.png]

[206a11dc3c29458bab7c2aef4238d53e.png]: https://img-blog.csdnimg.cn/206a11dc3c29458bab7c2aef4238d53e.png
[a2b20229c8d243dfb9e83001f5bea28a.png]: https://img-blog.csdnimg.cn/a2b20229c8d243dfb9e83001f5bea28a.png
[aa3e94ce9b8642e0b1fb6311b572d9f4.png]: https://img-blog.csdnimg.cn/aa3e94ce9b8642e0b1fb6311b572d9f4.png
[3c5939e1b53a4386a52a1b6239f69a5f.png]: https://img-blog.csdnimg.cn/3c5939e1b53a4386a52a1b6239f69a5f.png
[6627531b37ed4da587e53c0505385cd7.png]: https://img-blog.csdnimg.cn/6627531b37ed4da587e53c0505385cd7.png