Java反射03

3.通过反射获取类的结构信息

3.1java.lang.Class类

getName:获取全类名
getSimpleName:获取简单类名
getFields:获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields:获取本类中所有属性
getMethods:获取所有public修饰的方法，包含本类以及父类的
getDeclaredMethods:获取本类中所有方法
getConstructors:获取本类中所有public修饰的构造器
getDeclaredConstructors:获取本类中所有构造器
getPackage:以Package形式返回包信息
getSuperClass:以Class形式返回父类信息
getInterfaces:以Class形式返回接口信息
getAnnotations:以Annotation形式返回注解信息

例子1：

package li.reflection;

import org.junit.jupiter.api.Test;

import java.lang.annotation.Annotation;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

//演示如何通过反射获取类的结构信息

public class ReflectionUtils {

    public static void main(String[] args) {

    }

    //第一组方法 API

    @Test

    public void api_01() throws ClassNotFoundException {

        //得到Class对象

        Class<?> personCls = Class.forName("li.reflection.Person");

        //1. getName:获取全类名

        System.out.println(personCls.getName());//li.reflection.Person

        //2. getSimpleName:获取简单类名

        System.out.println(personCls.getSimpleName());//Person

        //3. getFields:获取所有public修饰的属性，包含本类以及父类的

        Field[] fields = personCls.getFields();

        for (Field field : fields) {//增强for

            System.out.println("本类以及父类的属性=" + field.getName());

            //本类以及父类的属性=name

            //本类以及父类的属性=hobby

        }

        //4. getDeclaredFields:获取本类中所有属性

        Field[] declaredFields = personCls.getDeclaredFields();

        for (Field declaredField : declaredFields) {

            System.out.println("本类中所有属性=" + declaredField.getName());

        }

        //5. getMethods:获取所有public修饰的方法，包含本类以及父类的

        //这里的父类包括的不只是直接父类，包括object的共有方法也会获取

        Method[] methods = personCls.getMethods();

        for (Method method : methods) {

            System.out.println("获取包含本类以及父类的所有public修饰的方法=" + method.getName());

        }

        //6. getDeclaredMethods:获取本类中所有方法

        Method[] declaredMethods = personCls.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {

            System.out.println("获取本类中所有方法" + declaredMethod.getName());

        }

        //7. getConstructors:获取本类中所有public修饰的构造器

        Constructor<?>[] constructors = personCls.getConstructors();

        for (Constructor<?> constructor : constructors) {

            System.out.println("本类的public构造器=" + constructor.getName());

        }

        //8. getDeclaredConstructors:获取本类中所有构造器

        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();

        for (Constructor<?> declaredConstructor : declaredConstructors) {

            System.out.println("获取本类中所有构造器=" + declaredConstructor.getName());//这里只是输出名字

        }

        //9. getPackage:以Package形式返回包信息

        System.out.println(personCls.getPackage());//package li.reflection

        //10. getSuperClass:以Class形式返回父类信息

        Class<?> superclass = personCls.getSuperclass();

        System.out.println("父类的Class对象=" + superclass);//class li.reflection.A

        //11. getInterfaces:以Class形式返回接口信息

        Class<?>[] interfaces = personCls.getInterfaces();

        for (Class<?> anInterface : interfaces) {

            System.out.println("接口信息" + anInterface);

            //接口信息interface li.reflection.IA

            //接口信息interface li.reflection.IB

        }

        //12. getAnnotations:以Annotation形式返回注解信息

        Annotation[] annotations = personCls.getAnnotations();

        for (Annotation annotation : annotations) {

            System.out.println("注解信息" +annotation);//注解信息@java.lang.Deprecated()

        }

    }

}

class A {

    public String hobby;

    public void hi() {

    }

    public A() {

    }

}

interface IA {

}

interface IB {

}

@Deprecated

class Person extends A implements IA, IB {

    //属性

    public String name;

    protected int age;

    String job;

    private double sal;

    public Person() {

    }

    public Person(String name) {

        this.name = name;

    }

    //私有

    private Person(String name, int age) {

    }

    //方法

    public void m1() {

    }

    protected void m2() {

    }

    void m3() {

    }

    private void m4() {

    }

}

3.2java.lang.reflect.Field类

getModifiers：以int形式返回修饰符

[说明：默认修饰符default是0，public 是1 ，private是2，protected是4，static是8，final是16]

如果有叠加的修饰符，如 public static ...，那么返回的int值就是相加的结果，public(1)+static(8)=9
getType：以Class形式返回类型，即返回该属性对应的类的Class对象
getName：返回属性名

3.3java.lang.reflect.Method类

getModifiers：以int形式返回修饰符

[说明：默认修饰符default是0，public 是1 ，private是2，protected是4，static是8，final是16]

如果有叠加的修饰符，如 public static ...，那么返回的int值就是相加的结果，public(1)+static(8)=9
getReturnType：以Class形式获取返回值的类型的Class对象
getName：返回方法名
getParameteTypes：以Class[]返回参数类型数组

3.4java.lang.reflect.Constructor类

getModifiers：以int形式返回修饰符
getName：返回构造器名（全类名）
getParameteTypes：以Class[]返回参数类型数组

例子2：使用Field类、Method类、Constructor类

package li.reflection;

import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

//演示如何通过反射获取类的结构信息

public class ReflectionUtils {

    public static void main(String[] args) {

    }

    //第二组方法 API

    @Test

    public void api_02() throws ClassNotFoundException {

        //得到Class对象

        Class<?> personCls = Class.forName("li.reflection.Person");

        //getDeclaredFields：获取本类中所有属性

        //[说明：默认修饰符default是0，public 是1 ，private是2，protected是4，static是8，final是16]

        Field[] declaredFields = personCls.getDeclaredFields();

        for (Field declaredField : declaredFields) {

            System.out.println("本类中所有属性=" + declaredField.getName()

                    + " 该属性的修饰符值=" + declaredField.getModifiers()

                    + " 该属性的类型=" + declaredField.getType());

        }

        //getDeclaredMethods：获取本类中所有方法

        Method[] declaredMethods = personCls.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {

            System.out.println("本类中的所有方法=" + declaredMethod.getName()

                    + " 该方法的访问修饰符=" + declaredMethod.getModifiers()

                    + " 该方法返回类型=" + declaredMethod.getReturnType());

            //输出当前这个方法的形参数组情况

            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();

            for (Class<?> parameterType : parameterTypes) {

                System.out.println("该方法的形参类型=" + parameterType);

            }

        }

        //getDeclaredConstructors:获取本类中所有构造器

        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();

        for (Constructor<?> declaredConstructor : declaredConstructors) {

            System.out.println("=================");

            System.out.println("本类中所有构造器=" + declaredConstructor);

            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();

            for (Class<?> parameterType : parameterTypes) {

                System.out.println("该构造器的形参类型=" + parameterType);

            }

        }

    }

}

class A {

    public String hobby;

    public void hi() {

    }

    public A() {

    }

}

interface IA {

}

interface IB {

}

@Deprecated

class Person extends A implements IA, IB {

    //属性

    public String name;

    protected static int age;

    String job;

    private double sal;

    public Person() {

    }

    public Person(String name) {

        this.name = name;

    }

    //私有

    private Person(String name, int age) {

    }

    //方法

    public void m1(String name, int age, double sal) {

    }

    protected String m2() {

        return null;

    }

    void m3() {

    }

    private void m4() {

    }

}

4.通过反射创建对象

方式一：调用类中的public修饰的无参构造器
方式二：调用类中的指定构造器
Class类的相关方法
- newInstance：调用类中的无参构造器，获取对应类的对象
- getConstructor（Class...clazz）：根据参数列表，获取对应的public构造器对象
- getDecalaredConstructor（Class...clazz）：根据参数列表，获取对应的所有构造器对象
Constructor类相关方法
- setAccessible：暴破
- newInstance（Object...obj）:调用构造器

例子：

package li.reflection;

import java.lang.reflect.Constructor;

//演示通过反射机制创建实例

public class ReflectCreatInstance {

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

        //1.先获取到User类的Class对象

        Class<?> userClass = Class.forName("li.reflection.User");

        //2.通过public的无参构造器创建实例

        Object o = userClass.newInstance();

        System.out.println(o);

        //3.通过public的有参构造器创建实例

        /**

         *  此时的 constructor 对象 就是

         *   public User(String name) {//public有参构造器

         *      this.name = name;

         *     }

         */

        //3.1先得到对应的构造器

        Constructor<?> constructor = userClass.getConstructor(String.class);

        //3.2再去创建实例，并传入实参

        Object bob = constructor.newInstance("bob");

        System.out.println(bob);

        //4.通过非public的有参构造器创建实例

        //4.1得到private的构造器对象

        Constructor<?> declaredConstructor =

                userClass.getDeclaredConstructor(int.class, String.class);

        //4.2创建实例

        //暴破（暴力破解），使用反射可以访问 私有的构造器/私有的属性/私有的方法

        declaredConstructor.setAccessible(true);

        Object user2 = declaredConstructor.newInstance(99, "张三丰");

        System.out.println(user2);

    }

}

class User {//User类

    private int age = 10;

    private String name = "jack";

    public User() {//public无参构造器

    }

    public User(String name) {//public有参构造器

        this.name = name;

    }

    private User(int age, String name) {//private有参构造器

        this.age = age;

        this.name = name;

    }

    @Override

    public String toString() {

        return "User [age=" + age + ", name=" + name + "]";

    }

}

5.通过反射访问类中的成员

访问属性
1. 根据属性名获取Field对象
  
  Field f = class对象.getDeclaredField(属性名);
2. 爆破：f.setAccessible(true);//f是Field
3. 访问
  
  f.set(o,值)；//o表示对象
  
  syso(f.get(o)); //o表示对象
4. 注意：如果是静态属性，则set和get中的参数o，可以写为null

例子：

package li.reflection;

import java.lang.reflect.Field;

//演示反射操作属性Field

public class ReflectAccessProperty {

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

        //1.得到Student类对应的Class对象

        Class<?> stuClass = Class.forName("li.reflection.Student");

        //2.创建对象

        Object o = stuClass.newInstance();//o的运行类型就是Student

        System.out.println(o.getClass());//Student

        //3.使用反射得到age属性对象（公有）

        Field age = stuClass.getField("age");

        age.set(o,88);//通过反射来操作属性

        System.out.println(o);//Student [age=88, name = null]

        //或者

        System.out.println(age.get(o));//返回age属性的值 88

        //4.使用反射操作name属性（私有静态的属性）

        Field name = stuClass.getDeclaredField("name");

        //因为name是私有的属性，需要对 name进行爆破

        name.setAccessible(true);

        name.set(o,"jack");//也可以写name.set(null,"jack");因为name是静态属性，与类有关，与对象无关

        System.out.println(o);

        System.out.println(name.get(o));//jack

    }

}

class Student {

    public int age;

    private static String name;

    public Student() {

    }

    @Override

    public String toString() {

        return "Student [age=" + age + ", name = " + name + "]";

    }

}

访问方法
1. 根据方法名和参数列表获取Method方法对象：
  
  Method m = 类的Class对象.getDeclaredMethod(方法名，XX.class);//得到本类的所有方法
  
  XX.class指方法的参数对应的class
2. 获取对象：Object o = 类的Class对象.newInstance();
3. 爆破：m.setAccessible(true);
4. 访问：Object returnValue = m.invoke(o,实参列表)；
5. 注意：如果过是静态方法，则invoke的参数o可以写为null

例子：

package li.reflection;

import java.lang.reflect.Method;

//演示通过反射操作方法

public class ReflectAccessMethod {

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

        //1.得到Boss类对应的Class对象

        Class<?> bossCls = Class.forName("li.reflection.Boss");

        //2.创建对象

        Object o = bossCls.newInstance();

        //3.调用普通的public的hi方法

        //3.1得到hi方法对应的方法对象

        Method hi = bossCls.getMethod("hi", String.class);

        //3.2调用

        hi.invoke(o, "孙悟空");

        //4.调用private static 方法

        //注意点：1.private：要使用爆破；2.static：在invoke时的参数可以写null

        //4.1得到 say 方法对象

        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);

        //4.2爆破

        say.setAccessible(true);

        //4.3invoke的null

        System.out.println(say.invoke(o, 100, "张三", '男'));

        System.out.println(say.invoke(null, 999, "李四", '女'));//因为是静态的方法，所以o可以写为null

        //5.在反射中，如果方法有返回值，统一返回Object,但其运行类型和方法定义的返回类型一致

        Object reVal = say.invoke(null, 300, "jack", '男');

        System.out.println("reVal的运行类型=" + reVal.getClass());//String

    }

}

class Boss {

    public int age;

    private static String name;

    public Boss() {

    }

    private static String say(int n, String s, char c) {//静态方法

        return n + " " + s + " " + c;

    }

    public void hi(String s) {//普通的public方法

        System.out.println("hi " + s);

    }

}

6.本章作业

6.1练习1：通过反射修改私有成员变量

定义privateTest类，有私有属性name，并且属性值为"hellokitty"
提供getName的公有方法
创建PrivateTest的类，利用Class类的到私有属性name，修改其属性值，并调用getName()的方法打印name属性值

package li.reflection.homework;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class homework01 {

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

        //1.得到PrivateTest对应的Class对象

        Class<?> privateTestCls = Class.forName("li.reflection.homework.PrivateTest");

        //2.创建对象

        Object o = privateTestCls.newInstance();

        //3.得到name属性对象

        Field name = privateTestCls.getDeclaredField("name");

        //4.爆破

        name.setAccessible(true);

        name.set(o,"天龙八部");

        //5.得到getName方法的对象

        Method method = privateTestCls.getMethod("getName");

        //6.因为getName是public方法，直接调用即可

        Object invoke = method.invoke(o);

        System.out.println("name属性的值="+invoke);

    }

}

class PrivateTest{

    private String name = "HelloKitty";

    public String getName(){

        return name;

    }

}

6.2练习：利用反射和File完成以下功能

利用Class类的forName方法得到File类的class对象
在控制台打印File类的所有构造器
通过newInstance方法创建File对象，并创建d:\mynew.txt文件

提示：创建文件的正确写法如下：

File file = new File("d:\mynew.txt");

file.creatNewFile();

package li.reflection.homework;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

public class homework02 {

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

        //得到File类对应的class类对象

        Class<?> fileCls = Class.forName("java.io.File");

        //得到所有的构造器

        Constructor<?>[] declaredConstructors = fileCls.getDeclaredConstructors();

        System.out.println("=====File的所有构造器=====");

        //遍历输出构造器

        for (Constructor<?> declaredConstructor : declaredConstructors) {

            System.out.println(declaredConstructor);

        }

        //指定得到 public java.io.File(java.lang.String)

        Constructor<?> constructor = fileCls.getConstructor(String.class);

        //创建File类对象

        Object file = constructor.newInstance("d:\\mynew.txt");

        //获取createNewFile方法的对象

        Method createNewFile = fileCls.getDeclaredMethod("createNewFile");

        //调用

        createNewFile.invoke(file);

    }

}

day44-反射03的更多相关文章

Java反射03 : 获取Class的注解、修饰符、父类、接口、字段、构造器和方法
java.lang.Class类提供了获取类的各种信息对象的静态方法. 本文转载自:https://blog.csdn.net/hanchao5272/article/details/79363921 ...
与《YII框架》不得不说的故事—5篇目录
与<YII框架>不得不说的故事—基础篇第1章课程目标 1-1 课程目标 (00:54) 第2章课前知识准备 2-1 YII的启动和安装 (05:12) 2-2 YII请求处理流程 ( ...
Spring笔记01（基础知识）
1.基础知识 01.Spring:轻量级Java EE开源框架,它是由Rod Johnson为了解决企业应用程序开发的复杂性而创建. 02.目标:实现一个全方位的整合框架,实现“一站式”的企业应用开发 ...
01SpringBase
Spring (容器) 概述: 01.Java EE开发者的春天 02.主要目的是降低业务逻辑层和其他层的耦合度 IOC 03.spring容器是用来创建(new)和管理(对象之间的关系)程序中所有 ...
「JavaSE 重新出发」05.03.02 在运行时使用反射分析对象
在编写程序时,如果知道想要查看的域名和类型,查看指定的域是一个很容易的事,而利用反射机制可以查看在编译时还不清楚的对象域. java Employee tank = new Employee(&quo ...
「JavaSE 重新出发」05.03 反射
能够分析类能力的程序称为反射(reflection). 反射库(reflection library)提供了一个非常丰富且精心设计的工具集,以便编写能够动态操纵 Java 代码的程序. 反射机制可以用 ...
03.反射--01【反射机制】【反射的应用场景】【Tomcat服务器】
https://blog.csdn.net/benjaminzhang666/article/details/9408611 https://blog.csdn.net/benjaminzhang66 ...
「JavaSE 重新出发」05.03.03 使用反射编写泛型数组代码
Employee[] a = new Employee[100]; // ... // array is full a = Arrays.copyOf(a, 2 * a.length); 如何编写这样 ...
「JavaSE 重新出发」05.03.01 利用反射分析类
在 java.lang.reflect 包中有三个类 Field, Method 和 Constructor 分别用于描述类的域.方法和构造器. Class 类中的 getFields, getMet ...

随机推荐

RabbitMQ消费者消失与 java OOM
原因: 下午先是收到钉钉告警有一个消费者系统任务积压, 当时以为就是有范围上量没有当回事,后来客服群开始反馈说有客户的数据没有生成.这个时候查看mq的后台,发现任务堆积数量还是很多. 这个时候登录一台 ...
Spring基础入门
一.Spring了解 Spring:程序员们的春天 Spring主要技术是IOC.AOP两个大概念它是轻量级的,每个jar包就1M ~ 3M 左右,所以速度快面向接口编程:降低了耦合度面向切面编 ...
AtCoder Beginner Contest 260 E // 双指针 + 差分
题目传送门:E - At Least One (atcoder.jp) 题意: 给定大小为N的两个数组A,B,求长度分别为1~M的满足以下条件的连续序列数量,条件为: 对于每个i(从1~N),Ai和B ...
【Java线程池】 java.util.concurrent.ThreadPoolExecutor 分析
线程池概述线程池,是指管理一组同构工作线程的资源池. 线程池在工作队列(Work Queue)中保存了所有等待执行的任务.工作者线程(Work Thread)会从工作队列中获取一个任务并执行,然后返 ...
YII总结学习7（在一个视图中显示另外一个视图）
controller\hello <?php namespace app\controllers; use yii\web\Controller; class helloController e ...
虚言妙诀终虚见，面试躬行是致知，Python技术面试策略与技巧实战记录
原文转载自「刘悦的技术博客」https://v3u.cn/a_id_183 2021年,对于正在找工作的朋友来说,笼罩在新冠肺炎疫情之下,今年的就业季显得更加具有挑战性,更有意思的是,每当这个时候,各 ...
Mybatis的使用（4）
1:解决实体类成员变量和数据库表中字段名称不一致的问题: 方法1:在写sql语句时,给表中的列名起别名,名字和实体类名称一样方法2:使用resultMap来解决: 例如:实体类中成员变量为id,na ...
只要9.9元！零基础学习MySQL
GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源. 导语经过一段时间的筹备和整理,万里数据库<零基础学习MySQL>课程正式在腾讯课堂上线了. 课程地址:htt ...
es6中的Proxy和vue中的数据代理的异同
1:概述 1-1:Proxy 用于修改某些操作的默认行为,Proxy可以说在对对象进行各种访问或者操作的时候在外层进行一层拦截,在操作之前都需要经过这种拦截.proxy返回的是一个新对象,可以通过操作 ...
我在Apache DolphinScheduler的心路历练
摘要:Apache DolphinScheduler 目前是 Apache 孵化项目,目前正在快速发展中.加入Apache DolphinScheduler社区已一年多,已有 400+ 公司在生产上使 ...

day44-反射03

Java反射03

3.通过反射获取类的结构信息

3.1java.lang.Class类

3.2java.lang.reflect.Field类

3.3java.lang.reflect.Method类

3.4java.lang.reflect.Constructor类

4.通过反射创建对象

5.通过反射访问类中的成员

6.本章作业

6.1练习1：通过反射修改私有成员变量

6.2练习：利用反射和File完成以下功能

day44-反射03的更多相关文章

随机推荐

热门专题