Java注解

Java注解

目录

注解概述

3、注解

	3.1、注解，或者叫做注释类型，英文单词是：Annotation
		疑问：注解到底是干啥的？？？？？？？？？

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

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

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

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

		第一：注解使用时的语法格式是：
			@注解类型名
		
		第二：注解可以出现在类上、属性上、方法上、变量上、形参等....
		注解还可以出现在注解类型上。
	
	3.5、JDK内置了哪些注解呢？

		java.lang包下的注释类型：
	
			掌握：
			Deprecated 用 @Deprecated 注释的程序元素，表示该元素已过时。
			不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。 

			掌握：
			Override 表示一个方法声明打算重写超类中的另一个方法声明。如果
            修改了重写的方法或者父类中没有该方法，那么使用该注解就会在编译阶段报错！

			不用掌握：
			SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的
			所有程序元素）中取消显示指定的编译器警告。 
	
	3.6、元注解
		什么是元注解？
			用来标注“注解类型”的“注解”，称为元注解。

		常见的元注解有哪些？
			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文件中，并且在运行时可以被反射机制所读取。
		
	3.7、Retention的源代码

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

			//@Retention(value=RetentionPolicy.RUNTIME)
			@Retention(RetentionPolicy.RUNTIME)
			public @interface MyAnnotation{}



	3.8、Target的源代码
		

	3.9、注解在开发中有什么用呢？

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


4、JDK新特性
	后续。。。。。。。

一、如何定义和使用注解？

自定义注解：

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

}

//自定义注解
public @interface MyAnnotation {
}

使用注解：如果没有使用 @Target 的话可以在任何位置上使用注解：

如：类 / 接口 / 枚举 /注解 / 上。

属性、方法、方法形参上。

@Target 是什么注解，有什么用，有哪些属性值？

用来标注“被标注的注解”可以出现在哪些位置上。

  • ANNOTATION_TYPE：注释类型声明
  • CONSTRUCTOR：构造方法声明
  • LOCAL_VARIABLE：局部变量声明
  • TYPE：类、接口（包括注释类型）或枚举声明
  • FIELD：字段声明（包括枚举常量）
  • METHOD：方法声明
  • PARAMETER：参数声明
  • PACKAGE：包声明
@MyAnnotation   //出现在类上
public class Person {
    @MyAnnotation   //出现在属性上
    private int no;
    @MyAnnotation
    private String name;

    @MyAnnotation   //出现在方法上
    public Person() {
    }

    @MyAnnotation
    public Person(@MyAnnotation int no, @MyAnnotation String name) {    //出现在参数上
        this.no = no;
        this.name = name;
    }

    @MyAnnotation
    public int getNo() {
        return no;
    }

    @MyAnnotation
    public void setNo(int no) {
        this.no = no;
    }

    @MyAnnotation
    public String getName() {
        return name;
    }

    @MyAnnotation
    public void setName(String name) {
        this.name = name;
    }
}

二、JDK lang包下的Override注解

Override注解的特点：

  1. 该注解只能注解方法。
  2. 该注解给是给编译器参考的，和运行阶段没有关系。
  3. 凡是java中的方法带有这个注解的，编译器都会进行编译检查，如果这个方法不是重写父类的方法，编译器报错。
/*
关于JDK lang包下的Override注解
源代码：
public @interface Override {
}

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

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

 */

// @Override这个注解只能注解方法。
// @Override这个注解是给编译器参考的，和运行阶段没有关系。
// 凡是java中的方法带有这个注解的，编译器都会进行编译检查，如果这个方法不是重写父类的方法，编译器报错。

//@Override
public class AnnotationTest02 {

    //@Override
    private int no;

    @Override
    public String toString() {
        return "toString";
    }

}

三、@Deprecated 表示当前元素已过时

@Deprecated 可以用在类上、方法上、属性上...表示当前元素已经过时。

@Deprecated 用在类上表示该类已经过时。

image-20200918202947288

image-20200918202732846

@Reprecated 用在方法上表示该方法已经过时。

image-20200918203136047

image-20200918203229896

@Reprecated 用在字段上表示该字段已经过时。

image-20200918203632288

// 表示这个类已过时。
@Deprecated
public class AnnotationTest03 {

    @Deprecated
    private String s;

    public static void main(String[] args) {
        AnnotationTest03 at = new AnnotationTest03();
        at.doSome();
    }

    @Deprecated
    public void doSome(){
        System.out.println("do something!");
    }

    // Deprecated这个注解标注的元素已过时。
    // 这个注解主要是向其它程序员传达一个信息，告知已过时，有更好的解决方案存在。
    @Deprecated
    public static void doOther(){
        System.out.println("do other...");
    }
}

class T {
    public static void main(String[] args) {
        AnnotationTest03 at = new AnnotationTest03();
        at.doSome();

        AnnotationTest03.doOther();

        try {
            Class c = Class.forName("java.util.Date");
            Object obj = c.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、注解中定义属性

重要结论：如果一个注解当中有属性，那么必须给属性赋值。（除非该属性使用default指定了默认值)

@MyAnnotation(属性名=属性值,属性名=属性值,属性名=属性值)

MyAnnotation注解：

public @interface MyAnnotation {

    /**
     * 我们通常在注解当中可以定义属性，以下这个是MyAnnotation的name属性。
     * 看着像1个方法，但实际上我们称之为属性name。
     * @return
     */
    String name();

    /*
    颜色属性
     */
    String color();

    /*
    年龄属性
     */
    int age() default 25; //属性指定默认值

}

MyAnnotationTest：测试

public class MyAnnotationTest {

    // 报错的原因：如果一个注解当中有属性，那么必须给属性赋值。（除非该属性使用default指定了默认值。）
    /*@MyAnnotation
    public void doSome(){

    }*/

    //@MyAnnotation(属性名=属性值,属性名=属性值,属性名=属性值)
    //指定name属性的值就好了。
    @MyAnnotation(name = "zhangsan", color = "红色")
    public void doSome(){
    }
}

五、注解中属性只有value时可以省略

如果一个注解的属性的名字是value，并且只有一个属性的话，在使用的时候，该属性名可以省略。

注意：只有是属性名是value的时候才可以，如果是name，哪怕该注解只有这一个属性，也不可能省略。

public @interface MyAnnotation {

    /*
    指定一个value属性。
     */
    String value();

    //String email();	//在这要是再有个email，那value属性名就不能省略了。
}

/*
如果一个注解的属性的名字是value，并且只有一个属性的话，在使用的时候，该属性名可以省略。
 */
public class MyAnnotationTest {

    // 报错原因：没有指定属性的值。
    /*@MyAnnotation
    public void doSome(){

    }*/

    @MyAnnotation(value = "hehe")
    public void doSome(){

    }

    @MyAnnotation("haha")	//value可以省略
    public void doOther(){

    }
}

六、注解当中属性的种类

  1. 注解当中的属性可以是哪一种类型？

    属性的类型可以是：byte short int long float double boolean char String Class 枚举类型
    以及以上每一种的数组形式。

    public @interface MyAnnotation {
 int value1();

 String value2();

 int[] value3();

 String[] value4();

 Season value5();

 Season[] value6();

 Class parameterType();

 Class[] parameterTypes();
}

  2. 在使用注解给属性赋值时，数组形式用｛属性值，属性值，属性值...｝

  3. 在使用注解给属性赋值时，数组形式也可用｛枚举值，枚举值，枚举值...｝

    public class OtherAnnotationTest {

    // 数组是大括号
    @OtherAnnotation(age = 25, email = {"zhangsan@123.com", "zhangsan@sohu.com"}, seasonArray = Season.WINTER)
    public void doSome(){

    }

    // 如果数组中只有1个元素：大括号可以省略。
    @OtherAnnotation(age = 25, email = "zhangsan@123.com", seasonArray = {Season.SPRING, Season.SUMMER})
    public void doOther(){
    }
}

七、通过反射获取注解对象属性的值

示例1:获得类上注解的属性的值

注解类：MyAnnotation

注意：如果想通过反射获取注解相关的内容。

则元注解 @Retention 的值必须是 @Retention(RetentionPolicy.RUNTIME)

否者反射获取不到，会报错！

//只允许该注解可以标注类、方法
@Target({ElementType.TYPE, ElementType.METHOD})
// 希望这个注解可以被反射
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    /*
    value属性,有默认值。
     */
    String value() default "北京大兴区";
}

测试类：MyAnnotationTest

@MyAnnotation("上海浦东区")
public class MyAnnotationTest {

    //@MyAnnotation	//编译报错
    int i;

    //@MyAnnotation，编译报错，不能用在构造方法上
    public MyAnnotationTest(){

    }

    @MyAnnotation
    public void doSome(){

        //@MyAnnotation	//编译报错
        int i;
    }
}

通过反射获取注解对象属性的值：ReflectAnnotationTest

public class ReflectAnnotationTest {
    public static void main(String[] args) throws Exception{
        // 获取这个类
        Class c = Class.forName("com.example.java.annotation5.MyAnnotationTest");
        // 判断类上面是否有@MyAnnotation
        //System.out.println(c.isAnnotationPresent(MyAnnotation.class)); // true
        if(c.isAnnotationPresent(MyAnnotation.class)){
            // 获取该注解对象
            MyAnnotation myAnnotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
            //System.out.println("类上面的注解对象" + myAnnotation); // @com.bjpowernode.java.annotation5.MyAnnotation()
            // 获取注解对象的属性怎么办？和调接口没区别。
            String value = myAnnotation.value();
            System.out.println(value);
        }

        // 判断String类上面是否存在这个注解
        Class stringClass = Class.forName("java.lang.String");
        System.out.println(stringClass.isAnnotationPresent(MyAnnotation.class)); // false
    }
}

示例2：获得方法上注解上属性的值

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    /*
    username属性
     */
    String username();

    /*
    password属性
     */
    String password();
}

public class MyAnnotationTest {

    @MyAnnotation(username = "admin", password = "456456")
    public void doSome(){

    }

    public static void main(String[] args) throws Exception{
        // 获取MyAnnotationTest的doSome()方法上面的注解信息。
        Class c = Class.forName("com.bjpowernode.java.annotation6.MyAnnotationTest");
        // 获取doSome()方法
        Method doSomeMethod = c.getDeclaredMethod("doSome");
        // 判断该方法上是否存在这个注解
        if(doSomeMethod.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation myAnnotation = doSomeMethod.getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation.username());	//admin
            System.out.println(myAnnotation.password());	//456456
        }
    }
}

八、案例：注解在开发中有什么用？

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

首先定义一个注解：

// 表示这个注解只能出现在类上面
@Target(ElementType.TYPE)
// 该注解可以被反射机制读取到
@Retention(RetentionPolicy.RUNTIME)
public @interface MustHasIdPropertyAnnotation {

}
// 这个注解@Id用来标注类，被标注的类中必须有一个int类型的id属性，没有就报异常。

然后自定义一个异常类，在没有这个id属性显示异常信息:

//自定义异常类
public class HasNotIdPropertyException extends RuntimeException {
    public HasNotIdPropertyException(){

    }
    public HasNotIdPropertyException(String s){
        super(s);
    }
}

使用注解的类：

@MustHasIdPropertyAnnotation
public class User {
    int id;
    String name;
    String password;
}

测试类：

实现步骤：

  1. 获得使用注解的类的字节码文件：Class userClass = Class.forName("com.example.java.annotation7.User");

  2. 判断类上是否存在 Id 注解。if(userClass.isAnnotationPresent(MustHasIdPropertyAnnotation.class)){}

    1. 存在id注解，判断有没有id字段，如果有id字段且类型是int型。

      Field[] fields = userClass.getDeclaredFields();
boolean isOk = false; // 给一个默认的标记
for(Field field : fields){
    if("id".equals(field.getName()) && "int".equals(field.getType().getSimpleName())){
        // 表示这个类是合法的类。有@Id注解，则这个类中必须有int类型的id
        isOk = true; // 表示合法
        break;
    }
}

    2. Id 注解或者没有id字段或者类型不是int型。

      // 判断是否合法
if(!isOk){
    throw new HasNotIdPropertyException("被@MustHasIdPropertyAnnotation注解标注的类中必须要有一个int类型的id属性！");
}

完整代码：

public class Test {
    public static void main(String[] args) throws Exception{
        // 获取类
        Class userClass = Class.forName("com.example.java.annotation7.User");
        // 判断类上是否存在Id注解
        if(userClass.isAnnotationPresent(MustHasIdPropertyAnnotation.class)){
            // 当一个类上面有@MustHasIdPropertyAnnotation注解的时候，要求类中必须存在int类型的id属性
            // 如果没有int类型的id属性则报异常。
            // 获取类的属性
            Field[] fields = userClass.getDeclaredFields();
            boolean isOk = false; // 给一个默认的标记
            for(Field field : fields){
                if("id".equals(field.getName()) && "int".equals(field.getType().getSimpleName())){
                    // 表示这个类是合法的类。有@Id注解，则这个类中必须有int类型的id
                    isOk = true; // 表示合法
                    break;
                }
            }

            // 判断是否合法
            if(!isOk){
                throw new HasNotIdPropertyException("被@MustHasIdPropertyAnnotation注解标注的类中必须要有一个int类型的id属性！");
            }

        }
    }
}
posted @ 2020-09-19 08:47  笑到不能自已  阅读(424)  评论(0)  编辑  收藏  举报