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

随机推荐

jdbc 06: 实现登陆页面
jdbc连接mysql,实现简单的登陆验证 package com.examples.jdbc.o6_实现登录界面; import java.sql.*; import java.util.HashM ...
多人共用一个Linux用户, 实现Bash配置文件独立
本文中提到的账户, 用户均表示同一概念. 例如 ssh wbourne@192.168.xxx.101, 账户, 用户指的均是 wbourne. 背景在工作中, 我们经常会连接Linux服务器 ...
ShardingSphere数据库读写分离
码农在囧途最近这段时间来经历了太多东西,无论是个人的压力还是个人和团队失误所带来的损失,都太多,被骂了很多,也被检讨,甚至一些不方便说的东西都经历了,不过还好,一切都得到了解决,无论好坏,这对于个人 ...
一个小 Trick
平方变两次一个状态 \(S\) 有一个贡献,所有状态 \(S\) 组成集合 \(U\) . 然后我们要统计下面这个东西 \[ans=\sum_{S\in U}f^2(S) \] 然后我们就可以看作是 ...
linux 安装 apache+mysql+php
http://www.cnblogs.com/lufangtao/archive/2012/12/30/2839679.html
Quicker程序实用及获取
-- 仅代表个人见解 --官方网站:https://getquicker.net/主界面截图桌面图标截图 3分钟快速体验Quicker https://getquicker.net/KC/ ...
powershell 执行策略
前言上一篇博文,我介绍了一下powershell和cmd的对比.通过学习,我发现powershell的确比cmd更加power,也更加适应现在的使用场景. 那么本文将继续介绍一个powershell ...
Mybatis完整版详解
一.简介 1.什么是MyBatis MyBatis 是一款优秀的持久层框架它支持自定义 SQL.存储过程以及高级映射. MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作 ...
Luogu3904 三只小猪（组合数学，第二类斯特林数，高精）
即使\(n<=50\),斯特林数也会爆long long. #include <iostream> #include <cstdio> #include <cstr ...
275. H 指数 II--Leetcode_暴力
来源:力扣(LeetCode) 链接:https://leetcode.cn/problems/h-index-ii 著作权归领扣网络所有.商业转载请联系官方授权,非商业转载请注明出处. 题目的大意是 ...

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

随机推荐

热门专题