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

随机推荐

Note -「狄利克雷前缀和」
学到一个诡异东西,当个 Trick 处理用吧. 现在有一个形如 \(\sum \limits _{i = 1} ^{n} \sum \limits _{d | i} f(d)\) 的柿子,不难发现可以 ...
GIS技术在医疗行业的应用：利用切片地图发布技术解决dmetrix数字病理切片在线浏览
最近一直在研究切片地图发布技术,解决各种矢量和栅格数据的切片地图制作和发布问题.这块的技术在土地评估和调查类公司中应用较多,因为他们经常需要使用各地地图,传统的文件管理方式很难适应工作现状,如果将各种 ...
发布自己的npm组件库
发布自己的npm组件库前期准备 **git上建立自己的仓库,这样子是为了在本地初始化时,可以直接生成对应的 package.json ** 克隆仓库创建仓库成功后,gitbush本地,执行 git ...
C++ 实现可变参数的三个方法
有时我们无法提前预知应该向函数传递几个实参.例如,我们想要编写代码输出程序产生的错误信息,此时最好用同一个函数实现该项功能,以便对所有错误的处理能够整齐划一.然而,错误信息的种类不同,所以调用错误输出 ...
Nuget打包并上传教程
一.准备 1 . 下载 Download NuGet.exe 2 . windows 系统下设置环境变量 path中或者在dos 命令窗口下cd转到 nuget.exe 所在目录,这里为了每次使用 ...
MySQL金融应用场景下跨数据中心的MGR架构方案（2）
GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源. 如何在多个数据中心部署多套MGR集群,并实现故障快速切换. 上篇文章介绍了如何在多数据中心部署多套MGR集群,并构建集群间 ...
如果Controller里有私有的方法，能成功访问吗？
目录背景原因 cglib代理的锅换成JDK动态代理呢参考背景写代码的时候,复制粘贴的时候,没注意到方法的属性,就导致了Controller里有了一个私有的方法,然后访问这个接口的时候就报了 ...
Luogu2375 [NOI2014]动物园（KMP）
写炸,上网,不同KMP形态. 无力,照该,一换写法就过. 横批:我是垃圾求\(next\)时\(DP\)出\(num\),路径压缩防卡\(n^2\) AC #include <iostream ...
Luogu3870 [TJOI2009]开关（分块）
线段树做法很简单,但分块好啊 #include <iostream> #include <cstdio> #include <cstring> #include & ...
Debezium的基本使用（以MySQL为例）
GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源. GreatSQL是MySQL的国产分支版本,使用上与MySQL一致. 一.Debezium介绍摘自官网: Debeziu ...

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

随机推荐

热门专题