Java——反射及注解

最新推荐文章于 2024-04-19 00:11:54 发布
最新推荐文章于 2024-04-19 00:11:54 发布
阅读量433 收藏 1
点赞数
分类专栏： 基础 文章标签： java
原文链接：https://www.bilibili.com/video/BV1uJ411k7wy?p=475
版权

反射：框架设计的灵魂



概念

将类的各个组成部分封装为其他对象。

优点

1.可以在程序运行过程中，操作Class对象
2.可以解耦，提高程序的可扩展性

获取Class对象的方式

/*
            获取Class对象的三种方式
            1.Class.forName("全类名");
            2.类名.class;
            3.对象名.getClass();
         */
        //1.Class.forName()
        Class cls1 = Class.forName("包名.类名");
        
        //2.类名.class
        Class cls2 = Person.class;
        
        //3.对象名.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();

tips：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪种方式获取的对象都是同一个。


Class对象功能

1.获取成员变量

Field：成员变量
	操作： 
		1.设置值
			void set(Object obj , Object value)
		2.获取值
			get(Object obj)
		3.忽略访问权限修饰符的安全检查(暴力反射)
			setAccessible(true)

public static void main(String[] args) throws Exception {

        //获取public修饰的成员变量
        getField();
        
        System.out.println("-----------------------------------------");
        
        //获取所有成员变量
        getDeclaredField();
    }

    /**
     * 1.1 获取所有public修饰的成员变量
     *         对象名.getFields();
     *         对象名.getField(变量名);
     */
    public static void getField() throws Exception {
        Person p = new Person();
        //获取类对象
        Class personClass = Person.class;

        // (1)--getFields()
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        // (2)--getField
        Field a = personClass.getField("a");
        //获取public修饰的成员变量的值
        Object value = a.get(p);
        System.out.println(value);//null
        a.set(p,"迪丽热巴");
        System.out.println(p);//Person{name='null', age=0, a='迪丽热巴', b='null', c='null'}
    }

    /**
     * 1.2 获取所有成员变量
     *        对象名.getDeclaredFields();
     *        对象名.getDeclaredField(变量名);
     */
    public static void getDeclaredField() throws Exception {
        Person p = new Person();
        //获取类对象
        Class personClass = Person.class;

        // (1)--getDeclaredFields()
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        // (2)--getDeclaredField()
        Field name = personClass.getDeclaredField("name");
        //忽略访问权限修饰的安全检查(暴力反射)
        name.setAccessible(true);
        //然后给非public修的变量设值
        name.set(p,"佟丽娅");
        Object value = name.get(p);
        System.out.println(value);
    }

Person类

public class Person {

    private String name;
    private int age;
    public String a;
    protected String b;
    String c;

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

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }

    public String getB() {
        return b;
    }

    public void setB(String b) {
        this.b = b;
    }

    public String getC() {
        return c;
    }

    public void setC(String c) {
        this.c = c;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                '}';
    }
    
	public void play(String game) {
        System.out.println("我想打" + game);
    }

	public void play() {
		System.out.pringln("play...");
	}
}

2.获取构造方法

Constructor:构造方法
	创建对象
		T newInstance(Object... initargs)

    public static void getConstructor() throws Exception {
        //获取类对象
        Class personClass = Person.class;

        //获取无参构造方法
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //获取有参构造方法
        Constructor constructor2 = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor2);

        //创建对象
        //通过构造方法
        Object person1 = constructor1.newInstance();
        System.out.println(person1);
    }

3.获取成员方法

Method:方法对象
	执行方法：
		Object invoke(Object obj , Object...args)
	获取方法名称：
		String getName();

/*
	获取public修饰的成员方法
	若想获取全部成员方法，使用getDeclaredMethod();(同1.获取成员变量)
*/
public static void getMethod() throws Exception {
        Person p =new Person();
        //获取类对象
        Class personClass = Person.class;

        //1.获取指定成员方法
        Method methodPlay = personClass.getMethod("play", String.class);
        //执行方法并传参
        methodPlay.invoke(p,"cod16");

        //2.获取全部public修饰的成员方法(包含父类中方法)
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            //获取成员方法名称
            String name = method.getName();
            System.out.println(name);
            System.out.println(method);
        }
    }

4.获取类名

public static void getClassName() {
	//获取类对象
	Class personClass = Person.class;

	//获取类名
	String className = personClass.getName;
	System.out.println(className);
}

案例

需求：写一个反射类，在不改变该类的任何代码的前提下，可以帮我们创建该类的对象并执行其中的任意方法
	步骤：
		1.将需要创建对象的全类名和需要执行的方法定义在配置文件中
		2.在程序中加载读取配置文件
		3.使用反射来加载类文件进内存
		4.创建对象
		5.执行方法

public static void main(String[] args) throws Exception {
        //1.加载配置文件
        //1.1创建Properties对象(把硬盘中存储的文件读取到集合中使用)
        Properties prop = new Properties();//Properties是HashTable的子类
        //1.2获取配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();//通过类对象获取类加载器()
        InputStream resource = classLoader.getResourceAsStream("prop.properties");//类加载器找到配置文件返回IO流
        //1.3加载配置文件
        prop.load(resource);

        //2.获取配置文件中定义的数据
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //3.获取类对象
        Class cls = Class.forName(className);

        //4.创建对象
        Object obj = cls.getDeclaredConstructor().newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }

配置文件(prop.properties)

tips：路径在src/main/resources下，不然找不到

className=包名.Person
methodName=play


注解

注解：说明程序的，给计算机看的。
注释：用文字描述程序的，给人看的。

定义

注解(Annotation),也叫元数据，一种代码级别的说明。
是JDk1.5引入的新特性。

作用分类

1.编写文档：通过代码里标识的注解生成doc文档
2.代码分析：通过代码里标识的注解对代码进行解析（使用反射）
3.编译检查：通过代码里标识的注解让编译器能够实现基本的代码检查（Override）

JDK中预定义的注解

1.@Override
2.@Deprecated:代表已过时
3.@SuppressWarnings:压制警告

自定义注解

格式与本质

//格式
public @interface MyAnno {}
//注解本质上就是接口
publi interface MyAnno extends java.lang.annotation.Annotation {}

反编译

元注解

用于描述注解的注解
	@Target：描述注解能够作用的位置
	@Retention：描述注解被保留的阶段(source、class、runtime)
	@Docemented：描述注解是否被抽取到api文档中
	@Inherited：描述注解是否被子类继承

@Target(ElementType.TYPE)//作用于类上
@Retention(RetentionPolicy.RUNTIME)//被描述的注解，会被保留到class字节码文件中，并被JVM读取到
public @interface MyAnno {
}

@Target(ElementType.METHOD)//作用于方法上
@Retention(RetentionPolicy.CLASS)//作用到字节码阶段
public @interface MyAnno {
}

@Target(ElementType.FIELD)//作用于成员变量上
@Retention(RetentionPolicy.SOURCE)//作用于源码阶段
public @interface MyAnno {
}

案例

使用注解完成上面反射篇中的案例

Prop.java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Prop {

    String className();
    String methodName();

}

主方法

@Prop(className = "cn.annotation.Student",methodName = "sleep")
public class ReflectTest {

    public static void main(String[] args) throws Exception {
        //1.解析注解
        //1.1获取注解(接口)的实现类对象
        Prop prop = ReflectTest.class.getAnnotation(Prop.class);
        //1.2通过实现类对象获取返回的数据
        String className = prop.className();
        String methodName = prop.methodName();

        //同reflect\ReflectTest.java
        //2.获取类对象
        Class<?> cls = Class.forName(className);
        //3.创建对象
        Object obj = cls.getDeclaredConstructor().newInstance();
        //4.获取方法对象
        Method method = cls.getMethod(methodName);
        //5.执行方法
        method.invoke(obj);
    }

}

学生类

public class Student {

    public void sleep() {
        System.out.println("早睡早起身体倍儿棒~");
    }

}
呲溜滑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java反射、注解
浅谈Android
09-25 1834
最近本着不求甚解的态度重温了一下主流框架的源码，所以趁热打铁的总结一下，学习框架或开发框架所必备的基础知识： Java反射 Java注解 注解代码自动生成 Java动态代理 AOP 一、反射 1.1、简介 本文简单总结一下Java反射和注解，反射可以算是必备条件了，基本学习的主流框架中都会看到反射的身影，他的灵活使用也为很多逻辑的扩展提供了可能，通过Java的反射机制，可以在程序中访...
Java反射和注解
weixin_50264963的博客
07-26 192
一.反射 1.定义 对于任意一个类，都能够知道这个类的所有属性和方法。对于任意一个对象，都能够调用它的任意一个方法和属性，这是由Class对象来完成的，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 2.作用 反射机制可以用来： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象; 在运行时判断任意一个类所具有的成员变量和方法; 在运行时调用任意一个对象的方法； 生成动态代理 应用场景： 逆向代码 ，例如反编译 与注...
java 反射和注解
weixin_41765786的博客
07-19 1416
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
java反射和注解
loque的博客
11-20 711
ReflectionAndAnnotation本文讲解java的 Reflect、Annotation 反射 和 注解的使用 文中的测试代码请前往 ReflectAndAnnotation反射java的反射机制运行程序在运行时通过反射的APIs取得class的内部信息。 关于反射的文字的说明可以看另一篇博文http://blog.csdn.net/renyuanchunby/article/de
Java高级特性——注解：注解实现Excel导出功能
最新发布
2401_84414763的博客
04-19 968
千千万万要记得：多刷题！！多刷题！！之前算法是我的硬伤，后面硬啃了好长一段时间才补回来，算法才是程序员的灵魂！！！！篇幅有限，以下只能截图分享部分的资源！！（1）多线程（这里以多线程为代表，其实整理了一本JAVA核心架构笔记集）（2）刷的算法题（还有左神的算法笔记）（3）面经+真题解析+对应的相关笔记（很全面）（4）视频学习（部分）ps：当你觉得学不进或者累了的时候，视频是个不错的选择在这里，最后只一句话：祝大家offer拿到手软！！
【原创】深入理解Java——注解和反射
a602389093的博客
11-27 738
版权声明：本文为博主ExcelMann的原创文章，未经博主允许不得转载。 Java基础——注解和反射 作者：ExcelMann，转载需注明。 该篇文章的内容来源于B站视频的总结（up主：遇见狂神说）。 内容目录： 什么是注解 内置注解 元注解 自定义注解 反射概述 获得反射对象 得到Class类的几种方式 所有类型的Class对象 类加载内存分析 分析类初始化 类加载器 获取类的运行时结构 动态创建对象执行方法 性能对比分析 获取泛型信息 获取注解信息 一、什么是注解 Annotation是从JDK5
Java基础——枚举与注解
lt_xiaodou的博客
07-30 957
枚举类类的对象只有有限个，确定的。当需要定义一组常量时，强烈建议使用枚举类。如果枚举类中只有一个对象，则可以作为单例模式的实现。使用enum定义的枚举类默认继承了java.lang.Enum类，因此不能再继承其他类。从JDK5.0开始，Java增加了对元数据（MetaData）的支持，也就是Annotation（注解）。Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。代码示例5}69}10。...
java——Junit单元测试、反射、注解
m0_52196529的博客
11-10 307
java——Junit单元测试、反射、注解
【狂神说笔记—— Java基础13-注解与反射】
weixin_46055348的博客
07-10 249
【狂神说笔记—— Java基础13-注解与反射】
java注解与反射的基本使用（这一篇就够了！）
12-21
一、注解（Annotation） 1.什么是注解？ 相信大家对注解应该并不陌生，在现在信息飞速发展的年代，各种优秀的框架或许都离不开注解的使用，像我们在实现接口一个方法时，也会有@Override注解。注解说白了就是对程序做出解释，与我们在方法、类上的注释没有区别，但是注解可以被其他程序所读取，进行信息处理，否则与注释没有太大的区别。 2.内置注解 内置注解就是我们的jdk所带的一些注解。常用的三个注解： @Override 这个应该都不陌生，修辞方法，表示打算重写超类中的方法声明。 @Deprecated 这个注解我们应该也不会陌生，我们可能看不到这个注解，但是我们肯定在使用一些方法时会出现
Java反射与注解
qq_43456605的博客
06-11 2067
Annotation是JDK5.0开始引入的新技术，Annotation不是程序本身，它可以对程序作出解释（这一点和注释没什么区别），但它可以被其他程序读取。注解（Annotations）是一种用于提供元数据的机制，可以被用于类、方法、变量、参数和包等。这些元数据本身对代码的逻辑没有直接影响，但可以被用来影响编译、运行时行为，或者被用来做代码生成、测试和API文档等。标准注解：Java 提供的标准注解，比如 @Override, @Deprecated, @SuppressWarnings。
反射与注解的使用
tbdp6411的专栏
07-10 908
作用：注解是附加在代码中的一些信息，用于编译、运行时解析和使用，起到说明配置作用  主要学习两方面1 元注解，2 自定义注解  一、元注解  包括：1.@Target, 　2.@Retention 　3.@Documented, 4.@Inherited 几种 1 @Target    作用：用于描述注解的使用范围（即 注解是描述：包、类、字段、方法、参数、接口等）
Java中的反射和注解
To_be_Designer
08-05 1627
反射　　反射是将类抽象为一个Class对象。将类看成对象，分析它的构造方法，成员变量，方法以及内部类。 　　对类的分析，是将类抽象为Class对象；对构造方法的分析，是将构造方法抽象为Constructor类的对象；对成员变量的分析，是将变量抽象为Feild类的对象；对方法的分析，是将方法抽象为Method类的对象。 举个例子：public class Student { public
java——反射与注解
Why_does_it_work的博客
06-24 6172
我们可以通过Java的元注解来自定义注解。Java的元注解包括@Retention、@Target、@Inherited和@Documented。其中，@Retention用于指定注解的生命周期，@Target用于指定注解可以应用于哪些元素，@Inherited用于指定子类是否继承注解，@Documented用于指定注解是否出现在Java文档中。上述代码定义了一个名为MyAnnotation的注解，它有两个属性：name和age。
java中的反射和注解
qq_37717458的博客
04-09 570
文章目录Junit单元测试白盒测试反射Class对象的功能：获取功能：获取Class对象的方式获取成员变量们获取构造方法们获取成员方法获取类名忽略访问权限修饰符的安全检查通过构造方法创建对象Method:方法对象配置文件反射注解实例 Junit单元测试 白盒测试 定义一个测试类（测试用例，测试类名：测试类Test，包名：…test） 定义测试方法：可以独立运行 给方法加注解@test 导入Jun...
java的反射和注解
weixin_43145539的博客
05-07 930
什么是注解 Java 注解(Annotation)又称 Java 标注，是 JDK5.0 引入的一种注释机制。 Java 语言中的类、方法、变量、参数和包等都可以被标注。和注释不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行 时可以获取到标注内容 。当然它也支持自定义 Java 标注。 注解与注释的区别： 注解是给机器看的注释，而注释是给程序员看的提示，编译时自动忽略注释。 注解的使用场景 编译格式检查 反射中解析 生成
Java 基础-反射与注解
Gzejia
06-04 694
Java 是世界上最好的语言。“不信你看 Kotlin 跟上来了，那又如何？”其实际上 Java 的编程思想与基础实现这些，难道不都是互通的嘛。
Java注解与反射深度解析
本文将深入探讨Java编程中的两个重要概念——注解（Annotation）和反射（Reflection）。这些特性自JDK 5.0版本起被引入，极大地丰富了Java语言的功能，并在实际开发中有着广泛的应用。 12.1 注解 注解是一种元编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值