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 ...

随机推荐

Nginx第三方模块Ngx-dyups安装过程
Ngx-dyups是什么,能干什么它是一个Nginx第三方动态Upstream配置模块,可以实现在不重启Nginx情况下动态更新反向代理Upstream表.该模块由淘宝开发团队维护,淘宝自家的Ten ...
题解【CodeForces 910A The Way to Home】
题目大意一只青蛙现在在一个数轴上,它现在要从点 \(1\) 跳到点 \(n\) ,它每次可以向右跳不超过 \(d\) 个单位.比如,它可以从点 \(x\) 跳到点 \(x+a\)(\(1\le a\ ...
《ABP Framework 极速开发》教程首发
写在发布之前有没有小伙伴跟我刚开始接触 ABP Framework 的感觉一样"一看文档深似海",看完文档之后,想要上手却找不着头绪. 本套教程写作的目的之一是为初学者提供一条相 ...
react环境搭建及文件配置
webpack简介构建工具(基于Nodejs)node(v16)前端工程化. 环境搭建创建一个空的package.json npm init webpack核心包(提供了API,插件) npm i ...
无痕模式下 this.StorageManager.setItem) 本地存储丢失
在无痕模式下,存的this.StorageManager.setItem("recharge", JSON.stringify(recharge))本地存储会丢失,所以我们改成使用 ...
Java SE 17 新增特性
Java SE 17 新增特性作者:Grey 原文地址:Java SE 17 新增特性源码源仓库: Github:java_new_features 镜像仓库: GitCode:java_new ...
linux 旁路掉协议栈的处理点
对于协议栈的发展,目前有三种处理趋势,一种是类似于使用dpdk的方式,然后将协议栈放到用户态来做,做得比较好的一般都是以bsd的协议栈为底子,可以参考的是腾讯开源的的方案,另外一种是,继续放在内核,但 ...
.NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件
常用的定时任务组件有 Quartz.Net 和 Hangfire 两种,这两种是使用人数比较多的定时任务组件,个人以前也是使用的 Hangfire ,慢慢的发现自己想要的其实只是一个能够根据 Cron ...
Flink介绍
1,简介 Flink是Apache基金会旗下的一个开源大数据处理框架.Flink很牛逼,好多牛逼的公司都在用. 2,特征 *高吞吐和低延迟.每秒处理百万个时间,毫秒级延迟.有点既要老婆好,又要彩礼少的 ...
n【c#】委托：delegate 学习笔记
类似于c/c++的指针,只不过c#的委托存储的是某个方法的调用,派生子System.Delegate

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的更多相关文章

随机推荐

热门专题