狂神说Java:注解和反射

最新推荐文章于 2021-12-02 11:13:21 发布

晒太阳的小猫咪

最新推荐文章于 2021-12-02 11:13:21 发布

阅读量284

点赞数

分类专栏：狂神说Java笔记文章标签： java

本文链接：https://blog.csdn.net/cat_2_love_dog/article/details/114075340

版权

狂神说Java笔记专栏收录该内容

6 篇文章 5 订阅

订阅专栏

[参考](https://blog.csdn.net/qq_42449963/article/details/109406428
笔记文字部分参照链接文，代码部分为自测代码

前言

1 什么是注解

1.1 注解概念

Annotation是从JDK5.0开始引入的新技术
Annotation的作用：
- 可以对程序作出解释，这一点和注释comment类似
- 对程序进行检查和约束，例如@Override
- 可以被其他程序（比如：编译器等）读取
Annotation的格式：
- 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarning(value=”unchecked”)
Annotation在哪里使用？
- 可以附加在package、class、method、field等上面，相等于给他们添加了额外的辅助信息，然后结合反射机制实现对这些元数据的访问。

2 内置注解

2.1 内置注解

@Override：
- 定义在java.lang包中，此注解只适用于修饰方法，表示该方法打算重写父类中的同名方法，并且具有检查作用

class BuyTickets implements Runnable{
    @Override
    public void run() {
        System.out.println("这里是重写的方法");
    }
}

@Deprecated：
- 定义在java.lang包中，此注释可以修饰方法、属性、类，注释
- @Deprecated的程序元素是程序员不鼓励使用的程序元素，通常是因为它是危险的，或者因为它已经过时了，然后存在更好的替代方法，但是你使用也没有任何影响，使用案例如下：

	@Deprecated
	public void test1(){
		System.out.println("这是不推荐再使用的方法");
	}

@SupressWarnings：定义在java.lang包中，用来抑制编译时产生的黄色警告信息，虽然这些警告信息不会影响编译结果，但是看着不舒服，然后该注释和前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，具体参数信息如下所示：
- @SuppressWarnings(“all”) // 压制所有警告，下面有例子：
- @SuppressWarnings(“unchecked”) // 压制"unchecked"警告
- @SuppressWarnings(value={“unchecked”, “deprecation”}) // 压制"unchecked", "deprecation"警告

    @SuppressWarnings("all")
    public void test2(){
        ArrayList<> objects = new ArrayList<>();
    }

注意：

public @interface SuppressWarnings {String[] value();}，其中value是参数名，而String[]是参数是类型，当注解只使用value这一个参数的时候，value可以省略，例如上面的@SuppressWarnings(“all”)和@SuppressWarnings(“unchecked”)就是省略了前面的value，但是仅限参数名是value，并且注解中只使用value这一个参数的情况才可以省略value

package com.xibukaiyuan.reflection;

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

public class TestAnnotate {
    public static void main(String[] args) {
        
    }

    @MyAnnotation2("")
    public void test1(){
        
    }
}

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation{
    String[] name();
}

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation2{
    String value();
}

3 什么是元注解

3.1 元注解

元注解作用：
- 负责注解其他注解，Java中定义了4个标准的元注解（）类型，他们被用来对其他注解类型进行解释说明限制
元注解位置：
- 在java.lang.annotation包中

3.2 元注解四大类型

@Target：用于描述注解的使用范围，也就是描述注解可以使用在什么地方，public @interface Target {ElementType[] value();}可以看出可以它是一个数组，可以有多个值，里面的值设置的都是定义的注解MyAnnotation的使用范围，比如在类上、方法上等等，你可以通过@Target，然后点击里面的ElementType去查看

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation{
    String[] name();
}

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
}

@Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE < CLASS < RUNTIME），SOURCE是源码级别，CLASS 是源码级别和编译之后的字节码文件中有效，RUNTIME是在源码级别、编译之后的字节码文件、JVM中运行都有效，最常用的就是RUNTIME

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation2{
    String value();
}

@Documented：说明该注解将被包含在javadoc文档中

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@interface MyAnnotation3{
    String name() default "cat";
}

@Inherited：说明子类可以继承父类中的该注解

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@Inherited
@interface MyAnnotation3{
    String name() default "cat";
}

4 自定义注解

4.1 自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口
@interface 用来声明一个注解，格式是：修饰符 @interface 注解名{定义内容}
- 内容中的每一个方法实际上是声明了一个配置参数，方法的名称就是参数的名称，方法的返回值类型就是参数的类型
- 返回值类型只能是基本类型、Class、String、enum，如果返回值是String[]的时候，赋值的时候要用{“X1”, “X2”}这种形式，见：MyAnnotation
- 可以通过default来声明参数的默认值，声明默认值的可以不在自定义注解中赋值，反之必须赋值。见：MyAnnotation3
- 如果只有一个参数成员，一般参数名使用value字段，这是因为当参数名称是value并且自定义注解中只需要写一个参数的时候，可以省略参数名称，只有value可以这样，其他的都不行。见：MyAnnotation2
- 注解元素必须有值，我们定义注解元素时，经常使用空字符串、0、-1等作为默认值，当默认值为-1，代表不存在

package com.xibukaiyuan.reflection;

import java.lang.annotation.*;

public class TestAnnotate {
    public static void main(String[] args) {

    }

    @MyAnnotation(name={"a","b"})
    @MyAnnotation2("a")
    @MyAnnotation3
    public void test1(){

    }
}

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation{
    String[] name();
}

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation2{
    String value();
}

@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@Inherited
@interface MyAnnotation3{
    String name() default "cat";
}

5 反射概述

5.1 反射概念

Reflection(反射)是Java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并且能直接操作任意对象的内部属性以及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子可以看到类的结构，这就是反射。

6 获取反射对象

6.1 反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理
……

6.2 反射相关的主要API

java.lang.Class：代表一个类，它就是Object类getClass()方法的返回值，它是唯一的所以类都指向它
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器
……

6.3 反射初体验

package com.xibukaiyuan.reflection;

public class TestReflection {
    public static void main(String[] args) throws ClassNotFoundException {
        Cat cat = new Cat();
        Class c1 = Class.forName("com.xibukaiyuan.reflection.Cat");
        Class c2 = Class.forName("com.xibukaiyuan.reflection.Cat");
        //同一个类只有一个Class对象
        System.out.println(c1.hashCode()==c2.hashCode());
    }
}

class Cat{
    private String name;
}

class Dog{
    private String name;
}

6.4 Class类详解

在这里插入图片描述

7 得到Class类的几种方式

7.1 Class类

Class本身也是一个类，不过这个类只有一个，所有的类都执行它，例如User类、Person类等
Class对象是Class类的对象，一个加载的类(例如User.java)在JVM中只会有一个Class对象
一个Class对象对应的是一个加载到JVM中的对应的XXX.class文件
每个类(例如User.java)的实例(例如User u = new User()中的u)都会记着自己是由哪个Class对象所生成
通过CLass对象可以完整地得到一个类(例如User.java)中所有被加载的信息
Class类(只有一个，和Object类中getClass()方法中返回的Class是同一个)是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得类(例如User.java)对应的Class对象
以上说了三个部分：Class类、Class对象、类、类的实例，通过类可以创建类的实例，通过Class类可以获取某类的Class对象，通过Class对象可以获取类中的所有信息(方法、属性等等)，当然也可以创建类的实例，另外Class对象是类具有的，类可以做的它也能做

7.2 Class类的常用方法

在这里插入图片描述

7.3 获取Class类的实例

package com.xibukaiyuan.reflection;

import java.lang.reflect.Constructor;

public class TestReflection1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //通过类的class属性获取，该方法最为安全可靠，程序性能最高
        Class c1 = Horse.class;
        System.out.println(c1);

        //通过类的实例中的getClass()方法获取
        Horse horse = new Horse();
        Class c2 = horse.getClass();
        System.out.println(c2);

        //通过类的全限定类名获取
        Class c3 = Class.forName("com.xibukaiyuan.reflection.Horse");
        System.out.println(c3);

        //通过基本内置类型的包装类的Type属性（了解）
        //int
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        //通过ClassLoader类加载器获取
        Class c5 = c1.getDeclaredConstructor(null).getDeclaringClass();
        System.out.println(c5);
    }
}

class Horse{
}

7.4 其他

获取父类类型

        Class c6 = c1.getSuperclass();
        System.out.println(c6);

获取Duck对象

        Duck duck1 = (Duck) c1.newInstance();
        System.out.println(duck1);

使用构造器创建Duck对象

        Duck duck2 = (Duck) c1.getDeclaredConstructor(null).newInstance(null);
        System.out.println(duck2);

通过反射调用普通方法

        Duck duck3 = (Duck) c1.newInstance();

        //单一参数的函数的调用方法：
        //方法名.invoke(对象名,方法参数)
        Method run = c1.getDeclaredMethod("run", String.class);
        run.invoke(duck3,"100");

        //空参函数的调用方法：
        //方法名.invoke(对象名,null)
        Method eat = c1.getDeclaredMethod("eat", null);
        eat.invoke(duck3,null);

        //多参函数的调用方法：
        //方法名.invoke(对象名,null)
        Method drink = c1.getDeclaredMethod("drink", String.class, String.class);
        drink.invoke(duck3,"呱呱","苹果汁");

通过反射给属性赋值

        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(duck3,"呱呱");
        System.out.println("鸭子的名字叫"+duck3.getName());

8 所有类型的Class对象

8.1 具有CLass对象的类型

class：外部类、成员内部类和静态内部类、局部内部类、匿名内部类

	Class c1 = Object.class;

	Class c4 = ArrayList.class;

interface：接口

	Class c2 = Runnable.class;

[]：数组

	Class c3 = Integer[].class;

enum：枚举

	//class java.lang.annotation.ElementType
	Class c5 = ElementType.class;

annotation：注解

	//interface java.lang.Override
	Class c6 = Override.class;
	System.out.println(c6);

基本内置类型的包装类，例如Integer等

        //short
        Class c7 =short.class;
        System.out.println(c7);

        //class java.lang.Short
        Class c8 =Short.class;
        System.out.println(c8);

void

        //class java.lang.Void
        Class c9 = Void.class;
        System.out.println(c9);

Class类

        //class java.lang.Class
        Class c10 = Class.class;
        System.out.println(c10);

8.2 元素类型、维度和Class对象的关系

元素类型相同，维度相同，但是具体内容不同，Class对象相同

        //class [I
        Class c1 = int[].class;
        int[] ints1 = new int[10];
        int[] ints2 = new int[100];

        System.out.println(c1.hashCode());                  //1639705018
        System.out.println(ints1.getClass().hashCode());    //1639705018
        System.out.println(ints2.getClass().hashCode());    //1639705018

元素类型相同，但是维度不同，Class对象不同

        //class [I
        Class c1 = int[].class;
        //class [[I
        Class c2 = int[][].class;
        //[Ljava.lang.String;
        Class c3 = String[].class;
        System.out.println(c1.hashCode());                  //1639705018
        System.out.println(c2.hashCode());                  //1627674070
        System.out.println(c3.hashCode());                  //1360875712

元素类型不同，Class对象不同

        //class [I
        Class c1 = int[].class;
        //[Ljava.lang.String;
        Class c3 = String[].class;
        System.out.println(c1.hashCode());                  //1639705018
        System.out.println(c3.hashCode());                  //1627674070

9 性能对比分析

package com.xibukaiyuan.reflection;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestReflection3 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Fruit fruit1 = new Fruit();
        long s1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            fruit1.getColor();
        }
        long e1 = System.currentTimeMillis();
        //普通方式调用方法耗时8
        System.out.println("普通方式调用方法耗时"+(e1-s1));

        Method getColor = Fruit.class.getDeclaredMethod("getColor", null);
        long s2 = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getColor.invoke(fruit1,null);
        }
        long e2 = System.currentTimeMillis();
        //反射方式调用方法耗时4202
        System.out.println("反射方式调用方法耗时"+(e2-s2));
    }
}

class Fruit{
    String color;

    public String getColor() {
        return color;
    }
}

晒太阳的小猫咪

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
狂神说Java:注解和反射

[添加链接描述](https://blog.csdn.net/qq_42449963/article/detail提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考一、pandas是什么？示例
复制链接

扫一扫