Java基础之反射技术相关知识总结

2024-04-02 19:04:59 311人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录一、反射概念二、反射应用场景三、反射更多细节一、反射概念 Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类

一、反射概念

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

二、反射应用场景

1.几乎所有的框架都会用到反射

2.程序解耦合使用

3.代码更加的优雅

三、反射更多细节

1.jdk中的位置: java.lang.reflect包下

在这里插入图片描述

2.获取字节码方式


// 通过类的全限定类名获取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
// 通过类直接获取
Class<Hero> clazzB = Hero.class;
// 通过实例化对象获取
Class<? extends Hero> clazzC = (new Hero()).getClass();
// 基本类型的包装类的type获取
Class<Byte> byteClazz = Byte.TYPE;
Class<Short> typeClazz = Short.TYPE;
Class<Integer> integerClazz = Integer.TYPE;
Class<Long> lonGClazz = Long.TYPE;
Class<Float> floatClazz = Float.TYPE;
Class<Double> doubleClazz = Double.TYPE;
Class<Character> characterClazz = Character.TYPE;
Class<Boolean> booleanClazz = Boolean.TYPE;

3.测试类Hero省略Setter和Getter以及toString方法其中包含无参构造和满参构造


package com.open_source.demo.domain;


public class Hero {
    
    private String type;
    
    private String name;
    
    private Double CE;

    
    public void attrbute(Hero hero) {
        System.out.println(hero.getType() + ": " + hero.getName() + "输出伤害： " + hero.getCE());
    }

    
    public void fighting() {
        System.out.println("稳住 我们能赢");
    }

    
    public void attack(String name) {
        System.out.println("准备向" + name + "发起进攻");
    }

    public Hero(String type, String name, Double CE) {        
        this.type = type;
        this.name = name;
        this.CE = CE;
    }

    public Hero() {
    }
}

4.获取类的成员

获取类的构造函数


import java.util.StringJoiner;


public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取所有构造函数字节码
        Constructor<?>[] declaredConstructors = clazzA.getDeclaredConstructors();
        // 打印构造函数修饰符以及参数类型
        for (int i = 0; i < declaredConstructors.length; i++) {
            // 美化输出
            StringJoiner sj = new StringJoiner(", ","[","]");
            System.out.print("构造函数修饰符：" + Modifier.toString(declaredConstructors[i].getModifiers()) + "  参数类型：");
            Class<?>[] parameterTypes = declaredConstructors[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                sj.add(parameterTypes[j].getName());
            }
            System.out.println(sj.toString());
        }
    }
}
// 打印内容  
构造函数修饰符：public  参数类型：[java.lang.String, java.lang.String, java.lang.Double] 
构造函数修饰符：public  参数类型：[]

获取指定构造函数


// 通过类的全限定类名获取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
// 获取满参构造
Constructor<?> allArgsConstructor = clazzA.getDeclaredConstructor(String.class, String.class, Double.class);
// 获取无参构造
Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();

调用构造函数


public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取满参构造
        Constructor<?> allArgsConstructor = clazzA.getDeclaredConstructor(String.class, String.class, Double.class);
        // 获取无参构造
        Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();
        // 如果修饰符为private需要使用暴力反射
        // noneArgConstructor.setAccessible(true);
        Hero hero = (Hero) noneArgConstructor.newInstance();
        hero.setType("射手");
        hero.setName("后裔");
        hero.setCE(1000.0);
        System.out.println(hero);
        Hero heroAll = (Hero) allArgsConstructor.newInstance("法师", "诸葛亮", 1000.1);
        heroAll.attrbute(heroAll);
    }
}
// 控制台输出
Hero{type='射手', name='后裔', CE=1000.0}
法师: 诸葛亮 输出伤害： 1000.1

获取成员方法


public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取无参构造
        Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();
        Hero hero = (Hero) noneArgConstructor.newInstance();
        // 获取所有成员方法
        Method[] declaredMethods = clazzA.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
            StringJoiner sj = new StringJoiner(",", "[", "]");
            System.out.print("方法名称：" + declaredMethods[i].getName() + " 方法参数: ");
            Class<?>[] parameterTypes = declaredMethods[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                sj.add(parameterTypes[j].getName());
            }
            System.out.println(sj.toString());
        }
    }
}
// 控制台输出
方法名称：attrbute 方法参数: [com.open_source.demo.domain.Hero]
方法名称：attack 方法参数: [java.lang.String]
set和get省略

方法调用


// 获取attack字节码对象
Method attackMethod = clazzA.getDeclaredMethod("attack", String.class);
// 如果修饰符为private同样需要使用暴力反射
attackMethod.invoke(hero,"周瑜");
// 控制台输出
准备向周瑜发起进攻

获取所有的成员属性


public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取所有成员属性
        Field[] declaredFields = clazzA.getDeclaredFields();
        Stream.of(declaredFields).forEach(System.out::println);
    }
}
// 控制台输出
private java.lang.String com.open_source.demo.domain.Hero.type
private java.lang.String com.open_source.demo.domain.Hero.name
private java.lang.Double com.open_source.demo.domain.Hero.CE

获取父类的字节码


// 通过类的全限定类名获取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero").getSuperclass();

反射工具类


package com.open_source.demo.support;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFORMat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;


public class ReflectSupport {
    private ReflectSupport(){};

    
    public static synchronized String getStringValue(String fieldName,Object obj) throws  ReflectiveOperationException{
        Object objectValue = getValueByGetter(fieldName,obj);
        if (objectValue == null){
            return "";
        }
        String result = objectValue.toString();
        //如果类型为BigDecimal,去掉末尾的0
        if (objectValue instanceof BigDecimal){
            BigDecimal value = (BigDecimal) objectValue;
            value = value.stripTrailingZeros();
            result = value.toPlainString();
        }else if (objectValue instanceof Date){
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            result = sdf.format((Date)objectValue).replace(" 00:00:00", "");
        }

        return result.trim();
    }

    public static Object getValueByGetter (String fieldName,Object obj) throws ReflectiveOperationException {
        Method getter = getGetter(fieldName, obj.getClass());
        if (getter != null){
            return getter.invoke(obj);
        }

        return null;
    }


    public static Object setValueBySetter (String fieldName,Object obj) throws ReflectiveOperationException {
        Method setter = getSetter(fieldName, obj.getClass());
        if (setter == null){
            throw new ReflectiveOperationException("没有set方法");
        }

        return setter.invoke(obj);
    }

    
    public static Method getGetter(String fieldName,Class<?> cls){
        for (Method method : cls.getMethods()) {
            if (method.getName().equalsIgnoreCase("get".concat(fieldName)) && method.getParameterTypes().length == 0){
                return  method;
            }
        }
        return null;
    }

    
    public static Method getSetter(String fieldName,Class<?> cls){
        for (Method method : cls.getMethods()) {
            if (method.getName().equalsIgnoreCase("set".concat(fieldName)) && method.getParameterTypes().length == 0){
                return  method;
            }
        }
        return null;
    }

    
    public static synchronized Field getFieldByName(String fieldName,Class<?> cls){
        Field[] fields =cls.getDeclaredFields();
        for (Field field : fields){
            if (field.getName().equals(fieldName)){
                return field;
            }
        }

        if (cls.getSuperclass() != null){
            return getFieldByName(fieldName,cls.getSuperclass());
        }

        return null;
    }

    
    public static List<Field> listFields(Class<?> cls){
        Field[] fs = cls.getDeclaredFields();
        List<Field> fields = new ArrayList<>(Arrays.asList(fs));
        if (cls.getSuperclass() !=null){
            fields.addAll(listFields(cls.getSuperclass()));
        }
        return fields;
    }

    public static  boolean fieldExist(String fieldName,Class<?> cls){
        return getFieldByName(fieldName, cls) !=null;
    }
}

到此这篇关于Java基础之反射技术相关知识总结的文章就介绍到这了,更多相关Java反射技术内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java基础之反射技术相关知识总结

本文链接: https://www.lsjlt.com/news/126797.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java基础之反射技术相关知识总结

目录一、反射概念二、反射应用场景三、反射更多细节一、反射概念 Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类...

99+

2024-04-02
Java基础之并发相关知识总结

目录一、Java并发是什么？二、怎么做？三、分工四、同步五、互斥六、总结一、Java并发是什么？用学术定义来说就是并发：同一时间段，多个任务都在执行 (单位时间内不一定同时执行...

99+

2024-04-02
Java基础之引用相关知识总结

目录一、引用的定义二、问题三、引用的分类四、应用场景五、源码六、总结一、引用的定义在JDK 1.2以前，Java中的引用定义很传统：如果reference类型的数据存储的数值代表的...

99+

2024-04-02
Java基础之线程锁相关知识总结

一、 synchronized关键字 1.对象锁 a.当使用对象锁的时候，注意要是相同的对象，并且当有线程正在访问对象锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)。 ...

99+

2024-04-02
Python基础之模块相关知识总结

目录一、什么是模块二、导入模块三、name=‘main'四、搜索路径一、什么是模块容器 -> 数据的封装函数 -> 语句的封装类 ->...

99+

2024-04-02
Java基础学习之运算符相关知识总结

1.算术运算符 +表示加法运算符 -表示减法运算符 *表示乘法运算符 /表示除法运算符 %表示取模/取余运算符 package com...

99+

2024-04-02
Python基础之变量的相关知识总结

变量全都是引用跟其他编程语言不同，Python的变量不是盒子，不会存储数据，它们只是引用，就像标签一样，贴在对象上面。比如： >>> a = [1, 2, ...

99+

2024-04-02
java基础之String知识总结

目录一、概念二、特点三、三种构造方式：四、字符串常量池一、概念 String代表字符串，java语言中所有双引号的字符串都是String的对象，不管是否是new出来的对象。二、特点...

99+

2024-04-02
Python基础之数据类型相关知识总结

1、字符串（1）概念字符串英文名string，简称str。字符串就是由一个个字符连接起来的组合, 你平时所见的字母、数字、汉字、符号都是字符。字符串可以用...

99+

2024-04-02
Python基础之循环语句相关知识总结

目录一、循环语句介绍二、循环语句的分类三、循环控制语句四、while循环五、break和continue六、for循环七、pass语句的使用一、循环语句介绍 1.循环语句...

99+

2024-04-02
【Java-15】反射知识总结

01_类的加载类的加载过程类的加载时机类的加载当程序在运行后，第一次使用某个类的时候，会将此类的class文件读取到内存，并将此类的所有信息存储到一个Class对象中说明：Class对象是指java.lang.Class类...

99+

2023-08-16

java
Java泛型机制与反射原理相关知识总结

一、泛型的概念 1.1 基础案例泛型在Java中的应用非常广泛，最常见则是在集合容器中，先看下基础用法： public class Generic01 { public...

99+

2024-04-02
Java基础知识总结之继承

目录一、继承的基本概念二、继承的好处和弊端三、继承中变量访问的特点四、super关键字五、继承中构造方法的访问特点六、继承中成员方法的访问特点七、方法重写八、包九、修饰符十、stat...

99+

2024-04-02
Java基础之位运算知识总结

目录一、位运算的分类与展现效果二、原理三、边界值测试一、位运算的分类与展现效果 java位运算可以分为左移和右移，其中右移还有无符号右移。 java只对整型位移，可...

99+

2024-04-02
java基础之泛型知识点总结

目录一、什么是泛型？为什么要使用泛型？二、泛型的特性是什么？三、泛型的使用方式四、Java中的泛型通配符一、什么是泛型？为什么要使用泛型？泛型，即“参数化...

99+

2024-04-02
JAVA基础知识点总结

文章目录前言一、JAVA简介二、基础语法面向对象StringIntegerObject异常IO序列化Java 泛型注解反射前言一、JAVA简介 Java 是一门面向对象的编程语言。语言特点：面向对象，平台无关性，支持多...

99+

2023-08-18

java jvm 开发语言
Java基础之Math和Random类知识总结

java的Math类 java中的java.lang.Math类可以直接使用，不需要导包，在JDK的API 中看到Math类被final修饰着，那么说明了这个Math类不能被继承,...

99+

2024-04-02
Java数据结构之链表相关知识总结

一、链表 1.1 概述链表是真正动态的数据结构，最简单的动态数据结构，基本用于辅助组成其他数据结构。数据存储在“节点”（Node）中优点：真正的动态，不需要处理固定容量的问题...

99+

2024-04-02
新手了解java 反射基础知识

目录一、反射概述二、常用api三、创建Class对象的四种方式总结一、反射概述 Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection...

99+

2024-04-02
Spring5学习之基础知识总结

目录1.概述2.入门Demo3.源码1.概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、 Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部...

99+

2024-04-02