反射

最新推荐文章于 2022-04-07 15:21:41 发布
最新推荐文章于 2022-04-07 15:21:41 发布
阅读量359 收藏
点赞数 3
分类专栏： Java JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43554997/article/details/99244335
版权
Java 同时被 2 个专栏收录
27 篇文章 1 订阅
订阅专栏
JavaWeb
16 篇文章 0 订阅
订阅专栏

* 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
    * 反射：将类的各个组成部分封装为其他对象，这就是反射机制
        * 好处：
            1. 可以在程序运行过程中，操作这些对象。
            2. 可以解耦，提高程序的可扩展性。


    * 获取Class对象的方式：
        1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
            * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        2. 类名.class：通过类名的属性class获取
            * 多用于参数的传递
        3. 对象.getClass()：getClass()方法在Object类中定义着。
            * 多用于对象的获取字节码的方式

        * 结论：
            同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。


    * Class对象功能：
        * 获取功能：
            1. 获取成员变量们
                * Field[] getFields() ：获取所有public修饰的成员变量
                * Field getField(String name)   获取指定名称的 public修饰的成员变量

                * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
                * Field getDeclaredField(String name)  
            2. 获取构造方法们
                * Constructor<?>[] getConstructors()  
                * Constructor<T> getConstructor(类<?>... parameterTypes)  

                * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
                * Constructor<?>[] getDeclaredConstructors()  
            3. 获取成员方法们：
                * Method[] getMethods()  
                * Method getMethod(String name, 类<?>... parameterTypes)  

                * Method[] getDeclaredMethods()  
                * Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

            4. 获取全类名    
                * String getName()  


    * Field：成员变量
        * 操作：
            1. 设置值
                * void set(Object obj, Object value)  
            2. 获取值
                * get(Object obj) 

            3. 忽略访问权限修饰符的安全检查
                * setAccessible(true):暴力反射

    * Constructor:构造方法
        * 创建对象：
            * T newInstance(Object... initargs)  

            * 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法


    * Method：方法对象
        * 执行方法：
            * Object invoke(Object obj, Object... args)  

        * 获取方法名称：
            * String getName:获取方法名


    * 案例：
        * 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
            * 实现：
                1. 配置文件
                2. 反射
            * 步骤：
                1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
                2. 在程序中加载读取配置文件
                3. 使用反射技术来加载类文件进内存
                4. 创建对象
                5. 执行方法

 

 在包cn.zh.domain下创建Person.java文件

package cn.zh.domain;

public class Person {
    private String name;
    private int age;

    public String a;
    protected String b;
    String c;
    private String d;


    public Person() {
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }


    public void eat(){
        System.out.println("eat...");
    }

    public void eat(String food){
        System.out.println("eat..."+food);
    }
}

 在包cn.zh.domain下创建Student.java文件

package cn.zh.domain;

public class Student {


    public void study(){
        System.out.println("studying...");
    }
}

 在包cn.zh.reflect下创建ReflectDemo1.java文件

package cn.zh.reflect;

import cn.zh.domain.Person;
import cn.zh.domain.Student;


public class ReflectDemo1 {


    /**
     获取Class对象的方式：
     1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
     2. 类名.class：通过类名的属性class获取
     3. 对象.getClass()：getClass()方法在Object类中定义着。
     */
    public static void main(String[] args) throws Exception {

        //1.Class.forName("全类名")
        Class cls1 = Class.forName("cn.zh.domain.Person");
        System.out.println(cls1);
        //2.类名.class
        Class cls2 = Person.class;
        System.out.println(cls2);
        //3.对象.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

        //== 比较三个对象
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true


        Class c = Student.class;
        System.out.println(c == cls1);//false
    }
}

 

 

在包cn.zh.reflect下创建ReflectDemo2.java文件

package cn.zh.reflect;

import cn.zh.domain.Person;

import java.lang.reflect.Field;

public class ReflectDemo2 {

    /**
     Class对象功能：
         * 获取功能：
         1. 获取成员变量们
             * Field[] getFields()
             * Field getField(String name)

             * Field[] getDeclaredFields()
             * Field getDeclaredField(String name)
         2. 获取构造方法们
             * Constructor<?>[] getConstructors()
             * Constructor<T> getConstructor(类<?>... parameterTypes)

             * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
             * Constructor<?>[] getDeclaredConstructors()
         3. 获取成员方法们：
             * Method[] getMethods()
             * Method getMethod(String name, 类<?>... parameterTypes)

             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

         4. 获取类名
             * String getName()



     */

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

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
             1. 获取成员变量们
                 * Field[] getFields()
                 * Field getField(String name)

                 * Field[] getDeclaredFields()
                 * Field getDeclaredField(String name)

         */
        //1.Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("------------");
        //2.Field getField(String name)
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);

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

        //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);

    }


}

在包cn.zh.reflect下创建ReflectDemo3.java文件 

package cn.zh.reflect;

import cn.zh.domain.Person;

import java.lang.reflect.Constructor;

public class ReflectDemo3 {

    /**
     Class对象功能：
     * 获取功能：
     1. 获取成员变量们
     * Field[] getFields()
     * Field getField(String name)

     * Field[] getDeclaredFields()
     * Field getDeclaredField(String name)
     2. 获取构造方法们
     * Constructor<?>[] getConstructors()
     * Constructor<T> getConstructor(类<?>... parameterTypes)

     * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
     * Constructor<?>[] getDeclaredConstructors()
     3. 获取成员方法们：
     * Method[] getMethods()
     * Method getMethod(String name, 类<?>... parameterTypes)

     * Method[] getDeclaredMethods()
     * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

     4. 获取类名
     * String getName()
     */

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

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
            2. 获取构造方法们
                 * Constructor<?>[] getConstructors()
                 * Constructor<T> getConstructor(类<?>... parameterTypes)

                 * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
                 * Constructor<?>[] getDeclaredConstructors()
         */
        
        //Constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //创建对象
        Object person = constructor.newInstance("小明", 23);
        System.out.println(person);

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


        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //创建对象
        Object person1 = constructor1.newInstance();
        System.out.println(person1);

        Object o = personClass.newInstance();
        System.out.println(o);
        
        //constructor1.setAccessible(true);
    }


}

 

在包cn.zh.reflect下创建ReflectDemo4.java文件

package cn.zh.reflect;

import cn.zh.domain.Person;

import java.lang.reflect.Method;

public class ReflectDemo4 {

    /**
     Class对象功能：
     * 获取功能：
     1. 获取成员变量们
     * Field[] getFields()
     * Field getField(String name)

     * Field[] getDeclaredFields()
     * Field getDeclaredField(String name)
     2. 获取构造方法们
     * Constructor<?>[] getConstructors()
     * Constructor<T> getConstructor(类<?>... parameterTypes)

     * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
     * Constructor<?>[] getDeclaredConstructors()
     3. 获取成员方法们：
     * Method[] getMethods()
     * Method getMethod(String name, 类<?>... parameterTypes)

     * Method[] getDeclaredMethods()
     * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

     4. 获取类名
     * String getName()
     */

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

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
          3. 获取成员方法们：
             * Method[] getMethods()
             * Method getMethod(String name, 类<?>... parameterTypes)

             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类<?>... parameterTypes)
         */
        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method.invoke(p);
        
        Method eat_method2 = personClass.getMethod("eat", String.class);
        //执行方法
        eat_method2.invoke(p,"饭");

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

        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            String name = method.getName();
            System.out.println(name);
            //method.setAccessible(true);
        }

        //获取类名
        String className = personClass.getName();
        System.out.println(className);//cn.itcast.domain.Person

    }


}

 

 在src目录下创建pro.properties配置文件

className=cn.zh.domain.Student
methodName=study

 

 在包cn.zh.reflect下创建ReflectTest.java文件

package cn.zh.reflect;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 框架类
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //可以创建任意类的对象，可以执行任意方法

        /*
            前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
         */
      /*  Person p = new Person();
        p.eat();*/
/*
        Student stu = new Student();
        stu.sleep();*/

        //1.加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");


        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);


    }
}

 

 通过修改配置文件就可以调用不同的方法，不需要修改源文件了。

欲游山河
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt 使用QMetaObject实现反射机制代码demo
07-29
Qt 使用QMetaObject实现反射机制代码demo
java反射机制历史_java反射原来是这么玩的（反射一开，谁都不爱）
weixin_29263201的博客
02-27 296
反射的发展历史1996年01月23日，jdk 1.0版本发布，代号为Oak(橡树)。这个代号为Oak(橡树)的版本，在发布后的第二年，1997年02月19日，发布jdk 1.1版本，这次版本发布中引入了反射机制。关于反射机制，由于年代久远，能搜索到对于反射机制的记载少之又少，能找到最为久远的是一篇题为《Using Java Reflection》的文章，发表于 1998年1月，文中提到：反射是一个...
Java反射机制
04-07 142
文章目录 一、简介 二、反射举例 三、意义与特点 一、简介 反射这一概念最早由编程开发人员Smith在1982年提出，主要指应用程序访问、检测、修改自身状态与行为的能力。这一概念的提出立刻吸引了编程界的极大关注，各种研究工作随之展开，随之而来引发编程革命，出现了多种支持反射机制的面向对象语言。 在计算机科学领域，反射是指一类能够自我描述和自控制的应用。在Java编程语言中，反射是一种强有力的工具，是面向抽象编程一种实现方式，它能使代码语句更加灵活，极大提高代码的运行时.
Java反射
董广明的博客
05-11 431
类中类 1. 反射介绍 反射这一概念最早由编程开发人员Smith在1982年提出，主要指应用程序访问、检测、修改自身状态与行为的能力。这一概念的提出立刻吸引了编程界的极大关注，各种研究工作随之展开，随之而来引发编程革命，出现了多种支持反射机制的面向对象语言。 在计算机科学领域，反射是指一类能够自我描述和自控制的应用。在Java编程语言中，反射是一种强有力的工具，是面向抽象编程一种实现方式，它能使代码语句更加灵活，极大提高代码的运行时装配能力。 2. 反射在java中的体现...
java反射机制历史_java的反射机制浅谈（转）
weixin_42526087的博客
02-27 91
一、java的反射机制浅谈1.何谓反射机制根据网文，java中的反射机制可以如此定义：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。2.反射机制如何实现谈到反射机制，最诱人的莫过于“动态”二字了。接触过C语言的童鞋们都知道，C语言中也有个和“动...
java反射机制（一，引入和基本介绍）
weixin_42603009的博客
03-10 211
method.invoke()方法,用来执行某个的对象的目标方法
Java常用的反射方法
09-24
反射获取Class类对象的三种方法 2.1 通过全类名的方式获取 2.2 类名.class 2.3 实例对象.getClass() 2.4 总结 3. 反射获取属性变量 3.1 获取所有public修饰符的成员变量 3.2 获取指定字段并赋值 3.3 获取...
谈谈Java中的反射机制
12-20
正所谓，无反射，不框架，框架的灵魂就是反射。 另外，我们在eclipse或者IDEA中编辑Java代码时，它们是怎么知道我们的对象有哪些方法，输入一个点就能给提示呢？ 带着问题我们来谈谈反射。 概念 反射：是将一个类的...
Java反射的简单使用
12-22
先来一些不太实用的解释：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java...
java中反射机制
匆匆那些年
07-05 1017
什么是Java反射(Reflection)? 程序在运行时(不是编译时)能够自我检查，并且能够对内部成员进行操作。例如它允许一个java类获取他所有的变量和方法。利用java中反射机制可以通过Reflection API获取该类的内部信息，如superclass、interfaces、modifiers(修饰public、private等)、以及field和methods，并且运行中能够修改fi
Java 反射（Reflection）死磕，一文全懂
架构师尼恩
09-18 517
疯狂创客圈：如果说Java是一个武林，这里的聚集一群武痴， 打磨着九阳神功和独孤九剑，欢迎围观 QQ群链接：疯狂创客圈QQ群 什么是反射？ 在Java 编程时，习惯的方式是通过Class类型，创建对象。 比如，创建一个宠物狗对象的代码为: Pet pet=new Dog(); 如果反过来：已知一个对象，如何知道其Class类型信息呢？ 这就要用到反射。 反射的基础 在没有加载到内...
浅谈java反射机制-------反射机制的由来(8.26更新)
Gavin
08-25 243
java反射机制问题提出代码实现代码实现----多态代码实现----反射创建对象的方式：类中有无参构造-----类中没有无参构造------getDeclaredConstructor()与getConstructor()的区别 问题提出 一个公司要开发本公司APP,某程序员在支付功能处给出了两种解决方案----- 第一种--------- 利用多态来完成 第二种-------- 是利用反射机制完成 代码实现 代码实现----多态 class AlipayM implements WoerMa{
Java的反射机制和内省机制？及区别？(扩展-class类、简介Java发展史)
墓亦龍的博客
05-16 519
1、JAVA反射机制在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。---&gt;程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出...
java反射回顾<一>
光与热的博客
11-22 260
1.反射获取包名和类名People people=new People(); System.out.println(people.getClass().getName());运行结果类名称->com.java.reflect.People 类名称->com.java.reflect.People 类名称->com.java.reflect.People2.所有对象是class的实例private s
反射机制处理历程
footprint01的博客
09-10 153
package com.mipo; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ReflectTester { /** * 该方法实现对Customer对象的拷贝操作 * * @param object * @return ...
JAVA 反射篇 看这一篇就够了
kingtok的博客
02-22 455
JAVA〖八〗反射一. 反射：框架设计的灵魂1. JAVA代码在计算机中经历的三个阶段二. 获取Class对象的方式：三. Class对功能：获取功能1. 获取成员变量们2. 获取构造方法们3. 获取成员方法们：4. 获取全类名四. 写一个反射的案例五. 总结制作不易,转载请标注~~~ 一. 反射：框架设计的灵魂 1. JAVA代码在计算机中经历的三个阶段 框架：半成品软件。可以在框架的基础上进...
java反射什么时候出现的_Java反射的作用
weixin_30741527的博客
02-25 511
Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。那么什么是Java的反射呢？ 大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。Java的反...
java反射最佳实践_Java 反射最佳实践
weixin_34998865的博客
02-13 155
来源：@天之界线2010，github.com/tianzhijiexian/Android-Best-Practices/blob/master/2015.9/reflect/reflect.md概要：最简单优雅的使用反射本文的例子都可以在示例代码中看到并下载，如果喜欢请star，如果觉得有纰漏请提交issue，如果你有更好的点子可以提交pull request。本文的示例代码主要是基于jOOR...
protobuf 反射
最新发布
09-30
ProtoBuf反射是指通过反射机制来获取并修改ProtoBuf消息的元信息。ProtoBuf中的反射原理主要涉及以下几个方面： 1. 反射机制的背景：ProtoBuf使用反射机制来实现动态操作消息，即在不知道消息结构的情况下仍然能够...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值