day33 反射

已于 2022-07-23 19:18:23 修改
阅读量105 收藏
点赞数
文章标签： java jvm 开发语言
于 2020-02-28 23:55:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41874888/article/details/104535253
版权

       JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

       要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

一、Class类

  阅读API的Class类得知，Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的

获取Class对象的三种方式

方式一: 通过Object类中的getObject()方法

Person p = new Person();

Class c = p.getClass();

方式二: 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。

Class c2 = Person.class;

方式三: 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。

Class c3 = Class.forName("Person");    

注意：第三种和前两种的区别

前两种你必须明确Person类型.

后面是指定这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了

代码演示

/*

 * 获取.class字节码文件对象的方式

 *      1：通过Object类中的getObject()方法

 *      2: 通过 类名.class 获取到字节码文件对象

 *      3: 反射中的方法,

 *          public static Class<?> forName(String className) throws ClassNotFoundException

 *          返回与带有给定字符串名的类或接口相关联的 Class 对象

 */

public class ReflectDemo {

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

        // 1： 通过Object类中的getObject()方法

        // Person p1 = new Person();

        // Class c1 = p1.getClass();

        // System.out.println("c1 = "+ c1);

        // 2: 通过 类名.class 获取到字节码文件对象

        // Class c2 = Person.class;

        // System.out.println("c2 = "+ c2);

        // 3: 反射中的方法

        Class c3 = Class.forName("cn.Reflect.Person");// 包名.类名

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

    }

}

Person类

package cn.Reflect;

public class Person {

    //成员变量

    public String name;

    public int age;

    private String address;

    //构造方法

    public Person() {

        System.out.println("空参数构造方法");

    }

   

    public Person(String name) {

        this.name = name;

        System.out.println("带有String的构造方法");

    }

    //私有的构造方法

    private Person(String name, int age){

        this.name = name;

        this.age = age;

        System.out.println("带有String，int的构造方法");

    }

   

    public Person(String name, int age, String address){

        this.name = name;

        this.age = age;

        this.address = address;

        System.out.println("带有String, int, String的构造方法");

    }

   

    //成员方法

    //没有返回值没有参数的方法

    public void method1(){

        System.out.println("没有返回值没有参数的方法");

    }

    //没有返回值，有参数的方法

    public void method2(String name){

        System.out.println("没有返回值，有参数的方法 name= "+ name);

    }

    //有返回值，没有参数

    public int method3(){

        System.out.println("有返回值，没有参数的方法");

        return 123;

    }

    //有返回值，有参数的方法

    public String method4(String name){

        System.out.println("有返回值，有参数的方法");

        return "哈哈" + name;

    }

    //私有方法

    private void method5(){

        System.out.println("私有方法");

    }

    @Override

    public String toString() {

        return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";

    }

}

二、通过反射获取构造方法并使用

       在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法：

1. 返回一个构造方法

      ①public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法

      ②public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)

2. 返回多个构造方法

     ①public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法

     ②public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)

获取构造方法的代码演示：

public class ReflectDemo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {

        //获取Class对象

        Class c = Class.forName("cn.Reflect.Person");//包名.类名

       

        //获取所有的构造方法

        //Constructor[] cons = c.getConstructors();

        Constructor[] cons = c.getDeclaredConstructors();

        for (Constructor con : cons) {

            System.out.println(con);

        }

       

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

        //获取一个构造方法

        //public Person()

        Constructor con1 = c.getConstructor(null);

        System.out.println(con1);

       

        //public Person(String name)

        Constructor con2 = c.getConstructor(String.class);

        System.out.println(con2);

       

        //private Person(String name, int age)

        Constructor con3 = c.getDeclaredConstructor(String.class, int.class);

        System.out.println(con3);

       

        //public Person(String name, int age, String address)

        Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);

        System.out.println(con4);

    }

}

2.1 通过反射方式，获取构造方法，创建对象

获取构造方法，步骤如下：

      1. 获取到Class对象

      2. 获取指定的构造方法

      3. 通过构造方法类Constructor中的方法，创建对象

      public T newInstance(Object... initargs)

代码演示

public class ConstructorDemo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        //1,获取到Class对象

        Class c = Class.forName("cn.Reflect.Person");//包名.类名

        //2,获取指定的构造方法

        //public Person()

        //Constructor con = c.getConstructor(null);

       

        //public Person(String name, int age, String address)

        Constructor con = c.getConstructor(String.class, int.class, String.class);

       

        //3,通过构造方法类中Constructor的方法，创建对象

        //Object obj = con.newInstance(null);

        Object obj = con.newInstance("小明", 22, "哈尔滨");

       

        //显示

        System.out.println(obj);

    }

}

2.2 通过反射方式，获取私有构造方法，创建对象

        AccessibleObject 类是 Field、Method 和 Constructor 对象的父类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。

        对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，会执行访问检查。常用方法如下：

        public void setAccessible(boolean flag) throws SecurityException

        参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。参数值为 false 则指示反射的对象应该实施 Java 语言访问检查。

获取私有构造方法，步骤如下：

1. 获取到Class对象

2. 获取指定的构造方法

3. 暴力访问, 通过setAccessible(boolean flag)方法

4. 通过构造方法类Constructor中的方法，创建对象

public T newInstance(Object... initargs)

代码演示：

public class ConstructorDemo2 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        //1,获取到Class对象

        Class c = Class.forName("cn.Reflect.Person");//包名.类名

       

        //2,获取指定的构造方法

        //private Person(String name, int age)

        Constructor con = c.getDeclaredConstructor(String.class, int.class);

               

        //3,暴力反射

        con.setAccessible(true);//取消 Java 语言访问检查

       

        //4,通过构造方法类中的功能，创建对象

        Object obj = con.newInstance("小明", 23);

        System.out.println(obj);

       

    }

}

三、 通过反射获取成员变量并使用

      在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：

  1. 返回一个成员变量
    1. public Field getField(String name) 获取指定的 public修饰的变量
    2. public Field getDeclaredField(String name) 获取指定的任意变量
  2. 返回多个成员变量
    1. public Field[] getFields() 获取所有public 修饰的变量
    2. public Field[] getDeclaredFields() 获取所有的 变量 (包含私有)

获取成员变量的代码演示：

public class FieldDemo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {

        //获取Class对象

        Class c = Class.forName("cn.Reflect.Person");

       

        //获取成员变量

        //多个变量

        //Field[] fields = c.getFields();

        Field[] fields =  c.getDeclaredFields();

        for (Field field : fields) {

            System.out.println(field);

        }

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

        //一个变量

        //public int age;

        Field ageField = c.getField("age");

        System.out.println(ageField);

       

        //private String address

        Field addressField = c.getDeclaredField("address");

        System.out.println(addressField);

    }

}

3.1 通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作

获取成员变量，步骤如下：

1. 获取Class对象

2. 获取构造方法

3. 通过构造方法，创建对象

4. 获取指定的成员变量（私有成员变量，通过setAccessible(boolean flag)方法暴力访问）

5. 通过方法，给指定对象的指定成员变量赋值或者获取值

public void set(Object obj, Object value)

       在指定对象obj中，将此 Field 对象表示的成员变量设置为指定的新值

public Object get(Object obj)

       返回指定对象obj中，此 Field 对象表示的成员变量的值

代码演示：

public class FieldDemo2 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {

        //1,获取Class对象

        Class c = Class.forName("cn.Reflect.Person");

        //2，获取构造方法

        //public Person(String name)

        Constructor con = c.getConstructor(String.class);

        //3，通过构造方法，创建对象

        Object obj = con.newInstance("小明");

        //4，获取指定的成员变量

        //public String name;

        Field nameField = c.getField("name");

        //public int age;

        Field ageField = c.getField("age");

        //private String address;

        Field addressField = c.getDeclaredField("address");

        addressField.setAccessible(true); //取消 Java 语言访问检查

       

        //5，通过方法，给指定对象的指定成员变量赋值或者获取值

        System.out.println("name = "+ nameField.get(obj));

        System.out.println("age = "+ ageField.get(obj));

        System.out.println("address = "+ addressField.get(obj));

       

        //赋值

        ageField.set(obj, 23);

        addressField.set(obj, "凯利广场");

       

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

        System.out.println("name = "+ nameField.get(obj));

        System.out.println("age = "+ ageField.get(obj));

        System.out.println("address = "+ addressField.get(obj));

    }

}

四、 通过反射获取成员方法并使用

在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法：

返回获取一个方法：

       获取public 修饰的方法： public Method getMethod(String name, Class<?>... parameterTypes)               

       获取任意的方法，包含私有的：public Method getDeclaredMethod(String name, Class<?>... parameterTypes)

               

       参数1: name 要查找的方法名称； 参数2： parameterTypes 该方法的参数类型

返回获取多个方法：

       public Method[] getMethods() 获取本类与父类中所有public 修饰的方法

       public Method[] getDeclaredMethods() 获取本类中所有的方法(包含私有的)

    

获取成员方法的代码演示：

public class MethodDemo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {

        //获取Class对象

        Class c = Class.forName("cn.Reflect.Person");

       

        //获取多个方法

        //Method[] methods = c.getMethods();

        Method[] methods = c.getDeclaredMethods();

        for (Method method : methods) {

            System.out.println(method);

        }

       

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

        //获取一个方法：

        //public void method1()

        Method method = c.getMethod("method1", null);

        System.out.println(method);

        //public String method4(String name){

        method = c.getMethod("method4", String.class);

        System.out.println(method);

        //私有方法

        //private void method5()

        method = c.getDeclaredMethod("method5", null);

        System.out.println(method);

    }

}

                                                

4.1 通过反射，创建对象，调用指定的方法

获取成员方法，步骤如下：

1. 获取Class对象

2. 获取构造方法

3. 通过构造方法，创建对象

4. 获取指定的方法

5. 执行找到的方法

public Object invoke(Object obj,  Object... args)

执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。

代码演示：

public class MethodDemo2 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        //1， 获取Class对象

        Class c = Class.forName("cn.Reflect.Person");

        //2,获取构造方法

        //public Person(String name, int age, String address){

        Constructor con = c.getConstructor(String.class, int.class, String.class);

        //3，通过构造方法，创建对象

        Object obj = con.newInstance("小明", 23, "哈尔滨");

        //4，获取指定的方法

        //public void method1()  没有返回值没有参数的方法

        //Method m1 = c.getMethod("method1", null);

       

        //public String method4(String name)

        Method m4 = c.getMethod("method4", String.class);

       

        //5，执行找到的方法

        //m1.invoke(obj, null);

       

        Object result = m4.invoke(obj, "cn");

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

    }

}

4.2 通过反射，创建对象，调用指定的private 方法

获取私有成员方法，步骤如下：

1. 获取Class对象

2. 获取构造方法

3. 通过构造方法，创建对象

4. 获取指定的方法

5. 开启暴力访问

6. 执行找到的方法

public Object invoke(Object obj,  Object... args)

执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。

代码演示：

public class MethodDemo3 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        //1， 获取Class对象

        Class c = Class.forName("cn.Reflect.Person");

        //2,获取构造方法

        //public Person(String name, int age, String address){

        Constructor con = c.getConstructor(String.class, int.class, String.class);

        //3，通过构造方法，创建对象

        Object obj = con.newInstance("小明", 23, "哈尔滨");

        //4，获取指定的方法

        //private void method5(){

        Method m5 = c.getDeclaredMethod("method5", null);

        //5,开启暴力访问

        m5.setAccessible(true);

        //6，执行找到的方法

        m5.invoke(obj, null);

    }

}      

这条小鱼我在乎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java学习笔记-反射与注解-1.反射
CarSkyDragn的博客
09-14 270
反射 JAVA反射机制是在运行状态中， 对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意一个方法和属性； 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。 1.1 Class类 获取Class对象的三种方式 方式一: 通过Object类中的getObject()方法 Person p = new
反射相关的示例,调用字符串描述的方法(JAVA反射)
weixin_48352132的博客
08-11 394
整理了下以前学习时候的项目,找到一个有趣的反射示例,与大家分享下 实现效果,根据字符串动态拼接java类内容,使用反射调用其中方法 实现步骤 动态拼接类文件内容 通过文件操作生成xxx.java文件 编译java文件,生产.class文件 将.class类写如JVM中 获取类 通过反射调用方法 @Test public void test0() throws Exception { // 生产一个JAVA文件 String name = "Xkk";
java10
qq_36396143的博客
03-22 246
http://blog.csdn.net/csdnnews/article/details/79648526
通过 Java 反射执行字符串组成的类名方法名
Mrqiang9001
09-09 2297
文章目录1 摘要2 核心代码3 1 摘要 Java 的反射机制可以通过完整的类名路径来获取类、类的属性、类的方法，并且执行对应的方法。在某些项目中，有些类似动态的，需要执行其中的某些特定方法，这时就需要用到 Java 的反射机制来实现。本文将展示基本的 Java 反射操作方法，来实现执行由字符串组成的类名方法名 2 核心代码 ./src/main/java/com/ljq/demo/util/ReflectDemo.java package com.ljq.demo.util; import java.
C#中使用反射将字符串转换为类
l17768346260的博客
02-01 6241
在自己用unity做demo的过程中，想要从配置表中将UI界面的预制体加载到场景中，并且挂载对应的类，由于配置表中需要挂载的类是通过字符串配置的，因此想到了以反射的形式进行添加，做了以下尝试： public class TestReflection : MonoBehaviour { // Start is called before the first frame updat...
Day 24反射
12-22
Day 24 1. 反射 1.1 Java文件和.class文件的关系 Java文件 Java文件中包含代码的所有内容 .class文件 .java文件通过javac编译工具生成对应的.class字节码文件 包含 Class 完整的包名，类名 Field 成员变量...
Day43 Java反射（二）
最新发布
05-04
Day43 Java反射（二）
Day24 注解&反射.md
08-09
注解：注解的另一个称呼注释，是给程序看的 反射：在运行的时候动态的去获取类的相关信息（公有的和私有的 字段 构造方法 方法 注解）； 通过获取类的字节码文 件对象 再去获取相关的信息
day24_枚举_注解_反射.pdf
11-02
通过反射，我们可以动态地获取类的信息（如类名、方法名、字段名等）并进行操作，如创建对象、调用方法、访问字段等。 例如，使用反射创建一个类的对象： ```java Class<?> clazz = Class.forName(...
Java学习day034 反射（一）Class类、捕获异常、利用反射分析类的能力
12-21
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。在Java核心技术卷1中，反射被介绍为一种能够动态操纵代码的工具，尤其在JavaBeans和组件开发中广泛应用。通过反射，...
Java中的反射
m0_67683346的博客
09-03 4935
Java的反射机制
Java基础之—反射
如果我爱自己我就会日出而坐，日落而息
09-02 347
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件...
Python中的反射—通过字符串的形式操作对象
GMH的博客
01-31 567
如果抛出AttributeError异常，则会直接调用__getattr__方法，因为属性没有找到，__getattribute__方法中为了避免在该方法中无限递归，它的实现应该永远调用基类的同名方法以访问需要的任何属性。实例的所有的属性访问，第一个都会调用__getattribute__方法，它阻止了属性的查找，该方法应该返回值或者抛出一个AttributeError异常。来访问对象的属性，本质上就是利用反射的能力，但是上面的例子中，访问的方式不优雅，Python提供了内置的函数。第三参数为新的属性值。
Java 反射使用大全
朱豪凯的博客
06-10 8200
好多年前自己记的关于Java反射的笔记，这么些年下来，自己用到反射的时候就看这一份就够了。但是笔记以文件形式存放不方便，所以将其放到CSDN中，也希望能给更多小伙伴带来帮助。
Java反射机制详解
让优秀成为一种习惯！
06-22 2899
Java反射是指在运行时动态地获取和操作类的信息以及调用对象的方法和属性，而不需要在编译期间知道类名或者其成员变量和方法具体等的信息。通过Java反射机制，可以实现动态创建对象、调用对象的方法、修改对象的属性值等操作，这为程序的灵活性和扩展性提供了很大的便利。
Java-反射机制（超详解）
wy971744839的博客
06-19 2827
的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为 方法区中类数据的访问入口。类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器 中，它将维持加载（缓存）一段时间。只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。
Java反射（超详细！）
热门推荐
一只小菜鸡
10-02 12万+
1、反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。） 通过反射机制可以操作代码片段。（class文件。） 2、反射机制的相关类在哪个包下？ java.lang.reflect.*; 3、反射机制相关的重要的类有哪些？ 类 含义 java.lang.Class 代表整个字节码。代表一个类型，代表整个类。 java.lang.reflect.Method 代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Con
java利用反射动态调用方法，类似python的eval和exec函数
welcome to daijiguo's blog
08-19 1493
场景： 类C中存有方法A()和B()，String str存有方法的名字可能是A，也可能是B，要求能通过str的不同，调用相应名字的函数。 实现： 主要用到java反射机制，动态调用的方法： a.getClass().getMethod(str, new Class[]{}).invoke(a, new Object[]{}) 其中，a为类的对象，str为要被调用的方法名 1、a...
反射，通过类名（字符串）获取类
每天进步一点点
12-06 7602
一句话搞定的处理： private static readonly string path = "GCForum"; public static UIViewController GetVC(string vcname) { return (UIViewController)Assembly.Load (path).CreateInstance (path + "." + vcname);
Java枚举、注解、反射与单元测试详解
"该资源是关于Java编程的教程，涵盖了枚举、注解、反射以及单元测试和Lombok工具的使用。" 在Java编程中，枚举（Enumeration）是一种特殊的类，从Java 1.5版本开始引入，它提供了一种更安全、更规范的方式来表示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值