反射-框架设计的灵魂

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量82 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43664947/article/details/109784952
版权

框架：半成平软件，可以在框架的基础上进行开发，简化代码
反射：将类的各个组成部分封装为其它对象，这就是反射机制
在这里插入图片描述
优势：
1.可以在程序运行过程中，操作这些对象
2.可以解耦，提高程序的扩展性
获取class类对象的机制：
1.Class.forName(“全类名”)：将字节码文件加载进内存，返回class对象（多用于配置文件，将类名定义在配置文件中，读取文件，加载类）
2.类名.class：通过类名的属性class获取（多用于参数传递）
3.对象.getClass()：getClass（）方法在Object类中定义（多用于对象的获取字节码方式）

Person类：

package cn.itcat.day09Domain;

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

    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;
    }
}

ReflectDemo1类：

package cn.itcat.day09;

/*
 获取class类对象的机制：
1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象
2.类名.class：通过类名的属性class获取
3.对象.getClass()：getClass（）方法在Object类中定义
*/


import cn.itcat.day09Domain.Person;

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //1.Class.forName("全类名")
        Class cls1 = Class.forName("cn.itcat.day09Domain.Person");
        System.out.println(cls1);
        //类名.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);//结果相等
        System.out.println(cls1==cls3);//结果相等
    }
}

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

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

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

Constructor<?>[] getDeclaredConstructors()
Constructor[] getDeclaredConstructor(类<?>…parameterTypes)
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):暴力反射

package cn.itcat.day09;

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

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

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

Method[]   getDeclaredMethods()
Method     getDeclaredMethod(String name,类<?>....parameterTypes)
		**4.获取类名**
String getName()*/


import cn.itcat.day09Domain.Person;

import java.lang.reflect.Field;

public class ReflectorDemo2 {
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;
        /***1.获取成员变量们**
         Field[] getFields()    默认只能获取public成员对象
         Field getFields(String name)

         Field[] getDeclaredFields()
         Field getDeclaredField(String name)*/
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        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);



    }
}

Construct：构造方法
创建对象：
T newInstance(Object… initargs)
创建空参对象简化方法 T personClass.newInstance();

package cn.itcat.day09;

import cn.itcat.day09Domain.Person;

import java.lang.reflect.Constructor;

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;
        /*****2.获取构造方法们**
         Constructor<?>[] getConstructor()
         Constructor<T>[] getConstructor(类<?>...parameterTypes)

         Constructor<?>[] getDeclaredConstructor()
         Constructor<T>[] getDeclaredConstructor(类<?>...parameterTypes)*/
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);

        //创建对象
        Object person = constructor.newInstance("张三", 23);
        System.out.println(person);



    }

}

Method:方法对象
执行方法：Object invoke(Object obj,Object… args)

获取方法名称：String name

package cn.itcat.day09;

import cn.itcat.day09Domain.Person;

import java.lang.reflect.Method;

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        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,"饭");

        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {

            System.out.println(method);

            String name = method.getName();
            System.out.println(name);
        }

        //获取类型
        String className = personClass.getName();
        System.out.println(className);

    }
}

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

配置文件：

className=cn.itcat.day09Domain.Person
methodName=eat

Person类：

package cn.itcat.day09Domain;

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);
    }
}

反射实现（ReflectTest类）：

package cn.itcat.day09;

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

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

        //前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意方法
        //加载配置文件
        //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);



    }
}
weixin_43664947
关注
专栏目录
反射---框架设计的灵魂
yanmo_01的博客
12-20 328
一、什么是反射？ ①框架：就是一种半成品！好处：提高我们的开发效率，是我们的代码更加简洁 ②反射：允许时把类中成员抽取为其他类的过程叫做反射 二、获取反射类Class的方法 ①通过类的全路径字符串来获取 Class.forName("全路径") 例子：spring框架<bean id="" class="类的全路径">----可以获取类对象---Class----------类对象 ②通过类名来获取 类名.class 例子：mybatis框架 session.getMa..
反射——框架设计的灵魂
zezea的博客
01-15 134
反射——框架设计的灵魂 * 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码 * 反射：将类的各个组成部分封装为其他对象，这就是反射机制 * 好处： 1. 可以在程序运行过程中，操作这些对象。 2. 可以解耦，提高程序的可扩展性。 我们编写的java代码在计算机中会经历三个阶段： 当我们完成一个类的编写，点击运行时，Java代码经历了如下几个过程： 1.编译器会把“类名.j...
java反射--框架设计的灵魂
热门推荐
big_white_py的博客
08-19 1万+
反射 定义 通俗的讲，将类的各个组成部分封装为其他对象，这就是反射机制 作用 1. 可以在程序运行过程中，操作这些对象。 2. 可以解耦，提高程序的可扩展性。 原理 先来了解下java代码在计算机中运行的几个阶段： 对应上面的三个阶段，获取Class对象的方式有下面三种： 1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象 * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类 2. 类名.class：通过类名的属性class获取 * 多用于参数的传
反射-----框架设计的灵魂
weixin_47560260的博客
09-23 119
反射：将类的各个组成部分封装为其他对象。 三阶段：源代码阶段、class类对象阶段、运行时阶段 好处：在程序运行中操作类对象 可以解耦，提高扩展性 获取Class对象的方法： 1.Class.forName("全类名")，将字节码文件加载进内存，返回Class对象 多用于配置文件，将类名定义在配置文件中。读取文件，加载类 2.类名.class:通过类名的属性class获取字节码文件方式 多用于参数传递 3.对象.getclass ...
(2)反射-框架设计的灵魂
zhujianghan的博客
09-18 90
反射--Java框架设计的灵魂
Gopuwe的博客
01-31 196
一、概述 在学习完JAVASE阶段的高级框架例如Spring、Mybatis等等，总会去思考这些框架是如何工作的，其中的底层原理是什么？但是要了解这些高级框架的设计原理，首先Java基础得扎实，Java基础阶段的反射、注解、动态代理与设计模式构成了一些高级框架的基础。其实在基础篇的学习中，我已经反复的学习过反射，但是仅仅是当时学习时使用到，到后面的学习中就没有在使用过反射，因此重新写一遍反射的相关知识 List<Integer> list = new ArrayList<>();
java反射-框架灵魂
qq_45384482的博客
05-24 536
文章目录什么是反射？反射的意义，为什么要学习反射？ 什么是反射？          官方的话来说就是：反射java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法。 反射的意义，为什么要学习反射？ 反射是框架设计的基石 反射可以绕过编译 在运行时判定任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判定任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。 能
Java反射机制-框架设计的灵魂
qq_33891573的博客
09-13 364
框架  既然反射机制是框架设计的灵魂,那我们就先简单说一下什么是框架:是一个半成品软件,框架中的代码已经是软件的一部分,但因为是半成品所以不能独立运行,我们可以在框架的基础上进行软件开发;利用框架开发软件可以做到简化编码的作用.  反射机制是框架设计的灵魂;其实我们在使用框架的时候,不会使用反射也没有关系,因为框架都为我们写好了;假如你要开发一套框架需要用到深入理解掌握反射机制  但是!我们理解掌...
反射：框架设计的灵魂
m0_63932157的博客
08-07 150
Java反射
java 反射机制基础（框架设计的灵魂）
01-21
反射:框架设计的灵魂 反射：将类的各个组成部分封装为其他对象，这就是反射机制。了解反射先需要了解java代码的历经阶段和Class类。 java代码的经历阶段和Class类: 原创文章 76获赞 75访问量 8194 关注 私信 ...
不了解java反射机制，怎么看懂框架
12-21
### 二、反射——框架设计的灵魂 1. **什么是反射** 反射是Java提供的一种能力，让程序在运行时可以动态获取类的信息（如类名、属性、方法等）并进行操作。通过反射，开发者可以在不知道具体类的情况下，调用类的...
谈谈反射----框架设计的灵魂
数字成都
04-08 167
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 229
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 465
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 556
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 564
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 812
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1290
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值