21_反射

最新推荐文章于 2024-09-17 11:50:15 发布
最新推荐文章于 2024-09-17 11:50:15 发布
阅读量68 收藏
点赞数
分类专栏： JaveSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43407221/article/details/118271858
版权

文章目录

1 反射

1.2 反射（reflect）

1.2.1 静态加载

jvm根据程序的需要，把必要的类提前加载到jvm的静态区的过程叫静态加载。

静态加载过程中，可能会加载到未来不会使用的类（程序中调用的所有类，jvm默认开发者将来需要，提前加载到静态区）。静态加载工作在编译时。

package com.chenlan01.reflect1;

import java.util.Scanner;

/**
 * @Description 静态加载
 * @Author chenlan
 * @Date 2020/10/3 8:39
 */
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字:");
        int i = sc.nextInt();
        if (i == 1) {
            Apple apple = new Apple();
        } else {
            Banana banana = new Banana();
        }
    }
}

1.2.2 动态加载

程序在运行过程中，根据程序的逻辑需要，按需要加载需要的字节码的过程称为动态加载。

动态加载工作在运行时。

package com.chenlan02.reflect2;

import java.util.Scanner;

/**
 * @Description 动态加载
 * @Author chenlan
 * @Date 2020/10/3 9:07
 */
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字");
        int i = sc.nextInt();

        String className = "";
        if (i == 1) {
            className = "com.chenlan02.reflect2.Apple";
        } else {
            className = "com.chenlan02.reflect2.Banana";
        }
        Class<?> aClass = Class.forName(className);
        System.out.println(aClass);
    }
}

1.3 反射概念

在运行时（程序运行过程中），jvm动态加载字节码并读取字节码中声明的信息（属性、方法、构造方法、注解等）的过程就是反射。

1.3.1 Class类

Pet类是类类型，用Class表示，Pet的字节码文件就是Class的一个对象/实例。Pet的字节码在程序中用Pet.class表示

package com.chenlan02.reflect3;

/**
 * @Description class类
 * @Author chenlan
 * @Date 2020/10/3 9:53
 */
public class Test01 {
    public static void main(String[] args) {
        // 声明一个类类型的对象
        Class clz1 = Pet.class;
        System.out.println(clz1);

        // 声明一个确定的类类型
        Class<Pet> clz2 = Pet.class;
        System.out.println(clz2);

        // 声明一个不确定的类类型
        Class<?> clz3 = Pet.class;
        clz3 = Dog.class;
        System.out.println(clz3);

    }
}

字节码只装载一次，也就是字节码在静态区只存在一个对象

package com.chenlan02.reflect3;

/**
 * @Description 获取class对象
 * @Author chenlan
 * @Date 2020/10/3 10:12
 */
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取Class 对象的方式
        Class<Pet> clz1 = Pet.class;

        // 通过创建的类的对象的getclass方法
        Pet pet = new Pet();
        Class<? extends Pet> clz2 = pet.getClass();
        // true
        System.out.println(clz1 == clz2);

        // forName
        Class<?> clz3 = Class.forName("com.chenlan02.reflect3.Pet");
        // true
        System.out.println(clz1 == clz2);
        // true
        System.out.println(clz2 == clz3);
    }
}

1.3.2 字节码信息

package com.chenlan02.reflect3;

/**
 * @Description 获取对象信息
 * @Author chenlan
 * @Date 2020/10/3 10:26
 */
public class Test03 {
    public static void main(String[] args) {
        Class<Pet> clz1 = Pet.class;
        // 全路径：com.chenlan02.reflect3.Pet
        System.out.println(clz1.getName());
        // 类名: Pet
        System.out.println(clz1.getSimpleName());
        // 包名：com.chenlan02.reflect3
        System.out.println(clz1.getPackage().getName());

        // 获取父类: java.lang.Object
        Class<? super Pet> superclass = clz1.getSuperclass();
        System.out.println(superclass.getName());

    }
}

1.3.3 获取类的属性

package com.chenlan02.reflect3;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @Description 获取类的属性
 * @Author chenlan
 * @Date 2020/10/3 10:41
 */
public class Test04 {
    public static void main(String[] args) {
        Class<?> clz1 = Dog.class;
        // getDeclaredFields用于获取类本身声明的所有属性，不包括继承过来的父类属性
       /* Field[] fields =clz1.getDeclaredFields();
        for (Field field : fields) {
            System.out.print(Modifier.toString(field.getModifiers())+" ");
            System.out.print(field.getType().getSimpleName()+" ");
            System.out.println(field.getName());
        }*/
        // 用于获取类以及继承链上所有的公共属性
        Field[] fields = clz1.getFields();
        for (Field field : fields) {
            System.out.print(Modifier.toString(field.getModifiers()) + " ");
            System.out.print(field.getType().getSimpleName() + " ");
            System.out.println(field.getName());
        }
    }
}

1.3.4 获取类的方法

package com.chenlan02.reflect3;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @Description 获取类的方法
 * @Author chenlan
 * @Date 2020/10/6 9:19
 */
public class Test05 {
    public static void main(String[] args) {

        Class<?> clz = Dog.class;
        // getDeclaredMethods()获取类本身声明的所有方法
        Method[] methods = clz.getDeclaredMethods();
        for (Method method : methods) {
            // System.out.println(method);
            System.out.print(Modifier.toString(method.getModifiers()) + " ");
            System.out.print(method.getReturnType().getSimpleName() + " ");
            System.out.print(method.getName());

            // 获取方法参数(形参数据类型)
            System.out.print("(");
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class<?> type : parameterTypes) {
                System.out.print(type.getSimpleName() + ",");
            }
            System.out.println(")");
        }

        //  获取该类以及其继承链上所有的公共方法

        Method[] clzMethods = clz.getMethods();
        for (Method clzMethod : clzMethods) {
            System.out.println(clzMethod);
        }
    }
}

getDeclaredMethods()执行结果:

20201006095018916

getMethods()执行结果:

20201006095211406

需求:获取一个类指定的方法

package com.chenlan02.reflect3;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Description 需求:获取一个类指定的方法
 * @Author chenlan
 * @Date 2020/10/6 9:53
 */
public class Test06 {
    public static void main(String[] args) {
        Class<?> clz = Dog.class;
        try {
            Method setName = clz.getMethod("setName", String.class);
            Dog dog = new Dog();
            setName.invoke(dog, "拉拉");
            System.out.println(dog.toString());
            
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

需求:声明一个String类型的集合，并把数值123添加到集合中。

package com.chenlan02.reflect3;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * @Description 需求:声明一个String类型的集合，并把数值123添加到集合中。
 * @Author chenlan
 * @Date 2020/10/6 10:19
 */
public class Test07 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("chen");
        /*list.add(123);*/
        
        Class<ArrayList> clz = ArrayList.class;
        try {
            int a = 123;
            Method add = clz.getMethod("add", Object.class);
            // 自动装箱
            add.invoke(list, a);
            // add.invoke(list,Integer.valueOf(a));
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        
        System.out.println(list);
    }
}

1.3.5 获取类的构造方法

package com.chenlan02.reflect3;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @Description 获取类的构造方法
 * @Author chenlan
 * @Date 2020/10/6 10:31
 */
public class Test08 {
    public static void main(String[] args) {
        Class<?> clz = Dog.class;
        Constructor<?>[] constructors = clz.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }

        try {
            // 构造一个类指定的构造方法
            Constructor<?> constructor = clz.getConstructor(int.class, String.class, String.class);
            // 通过构造方法构造对象
            Object dog = constructor.newInstance(55, "str", "str");
            System.out.println(dog);
        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

1.3.6 Class的newInstance

package com.chenlan03.reflect4_newInstance;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * @Description TODO
 * @Author chenlan
 * @Date 2020/10/6 10:45
 */
public class Test01 {
    public static void main(String[] args) {
        Class<Dog> clz = Dog.class;
        Dog dog;
        try {
            dog = clz.newInstance();
            System.out.println(dog);
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}

1.4 反射应用

package com.chenlan04.reflect5;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;

/**
 * @Description 反射的应用
 * @Author chenlan
 * @Date 2020/10/6 10:56
 */
public class BaseDao {
    
    /**
	 * 	oracle 读取字段的值读到java中后，数据类型发生变化，对应关系
	 *  sql type  		=> java type
	 *  varchar2  		=> String
	 *  number(x)		=> BigDecimal
	 *  date			=> Timestamp(java.util.Date的子类)
	 *  null			=> java的null值
	 *  number(x,y)		=> BigDecimal
	 */
    
    // 传入Class以及where子句
    public ArrayList findAll(String whereCondition, Object[] params, Class<?> clz) {

        Connection conn = DBUtils.getConnection();
        String sql = "select * from " + clz.getSimpleName() + " " + whereCondition;
        System.out.println(sql);
        PreparedStatement ps;
        ResultSet rs = null;
        ResultSetMetaData rsmd = null;
        ArrayList list = new ArrayList();
        try {
            ps = conn.prepareStatement(sql);
            // 绑定参数
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
            rs = ps.executeQuery();
            rsmd = rs.getMetaData();
            while (rs.next()) {
                // 根据Class创建对象
                Object obj = clz.newInstance();
                for (int i = 0; i < rsmd.getColumnCount(); i++) {
                    // 获取第i+1列的列名
                    String colName = rsmd.getColumnName(i + 1);
                    // 获取第i+1列的值
                    // 数据库中Number类型的值读到程序中类型为BigDecimal
                    Object colVal = rs.getObject(i + 1);

                    // 构建对象的设置器方法
                    Field field = clz.getDeclaredField(colName.toLowerCase());
                    String methodName = "set" + colName.substring(0, 1) + colName.toLowerCase().substring(1);
                    Method method = clz.getMethod(methodName, field.getType());

                    if (field.getType().getSimpleName().equals("Integer")) {
                        Integer value;
                        if (colVal == null) {
                            value = 0;
                        } else {
                            // 将BigDecilmal类型的值转换为Integer
                            value = ((BigDecimal) colVal).intValue();
                        }
                        method.invoke(obj, value);
                    } else if (field.getType().getSimpleName().equals("Double")) {
                        Double value;
                        if (colVal == null) {
                            value = 0.0;
                        } else {
                            // 将BigDecilmal类型的值转换为Double
                            value = ((BigDecimal) colVal).doubleValue();
                        }
                        method.invoke(obj, value);
                    } else if (field.getType().getSimpleName().equals("Float")) {
                        Float value;
                        if (colVal == null) {
                            value = 0.0f;
                        } else {
                            // 将BigDecilmal类型的值转换为Float
                            value = ((BigDecimal) colVal).floatValue();
                        }
                        method.invoke(obj, value);

                    } else {
                        method.invoke(obj, colVal);
                    }
                }
                list.add(obj);

            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
        return list;
    }

    public Boolean insert(String condition, Object[] params, Class<?> clz) throws SQLException {
        Connection conn = DBUtils.getConnection();
        String sql = "insert into " + clz.getSimpleName() + "(empno,ename,job,mgr) " + condition;
        System.out.println(sql);
        PreparedStatement ps = conn.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i + 1, params[i]);
        }
        int i = -1;
        try {
            i = ps.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

        if (i > 0) {
            return true;
        } else {
            return false;
        }
    }

    public Boolean update(String condition, Object[] params, Class<?> clz) {
        Connection conn = DBUtils.getConnection();
        String sql = "update " + clz.getSimpleName() + " set " + condition;
        System.out.println(sql);
        PreparedStatement ps = null;
        int j = -1;
        try {
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
            j = ps.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

        if (j > 0) {
            return true;
        } else {
            return false;
        }
    }

    public Boolean delete(String condition, Object[] params, Class<?> clz) {
        Connection conn = DBUtils.getConnection();
        String sql = "delete from " + clz.getSimpleName() + " " + condition;
        System.out.println(sql);

        PreparedStatement ps = null;
        int j = -1;
        try {
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
            j = ps.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

        if (j > 0) {
            return true;
        } else {
            return false;
        }
    }
}


package com.chenlan04.reflect5;

import java.sql.SQLException;
import java.util.ArrayList;

/**
 * @Description TODO
 * @Author chenlan
 * @Date 2020/10/6 11:13
 */
public class Test01 {
    public static void main(String[] args) throws SQLException {
        BaseDao dao = new BaseDao();
        
        // Object [] params = {10};
        /*ArrayList list = dao.findAll("", new Object[]{}, DEPT.class);
        for (Object o : list) {
            System.out.println(o);
        }*/

        // 查询emp表
        ArrayList list = dao.findAll("", new Object[]{}, EMP.class);
        for (Object o : list) {
            System.out.println(o);
        }

        // 添加数据
        Boolean aBoolean = dao.insert("values(?,?,?,?)", new Object[]{2000, "cai10", "singer", 7839}, EMP.class);
        System.out.println("添加数据:" + aBoolean);

        // 更新数据
        Boolean bBoolean = dao.update("ename = ? where empno = ?", new Object[]{"cai10", 2000}, EMP.class);
        System.out.println("更新数据：" + bBoolean);

        // 删除数据
        Boolean cBoolean = dao.delete("where empno = ?", new Object[]{2000}, EMP.class);
        System.out.println("删除数据:" + cBoolean);
    }
}
Mr.chen000
关注
专栏目录
java 反射 static final_反射修改 static final 变量
weixin_39789525的博客
02-16 805
一、测试结论static final 修饰的基本类型和String类型不能通过反射修改;二、测试案例@Testpublic void test01() throws Exception {setFinalStatic(Constant.class.getDeclaredField("i1"), 11);System.out.println(Constant.i1);setFinalStatic(C...
java反射无法获取_java反射
weixin_39859052的博客
02-16 701
java反射反射之中包含了一个「反」字，所以想要解释反射就必须先从「正」开始解释。一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。Apple apple = new Apple(); //直接初始化，「正射」apple.setPrice(4);上面这样子进行类对象的初始化，我们可以理解为「正」。而反射则是一开始并不知道我要...
反射全解
热门推荐
少说，多做。
10-31 2万+
反射的概念 反射的引入： Object obj = new Student(); 若程序运行时接收到外部传入的一个对象，该对象的编译类型是Object，但程序又需要调用该对象运行类型的方法： 1.若编译和运行类型都知道，使用 instanceof判断后，强转。 2.编译时根本无法预知该对象属于什么类，程序只能依靠运行时信息来发现对象的真实信息，这时就必须使用反射了。 3.要是想得到对象...
java反射获取字段的顺序6_反射之获取字段
weixin_32467421的博客
02-24 903
1 public classDemo12{23 /*4 对任意一个Object实例，只要我们获取了它的Class,就可以获取它的一切信息5 Class类提供了以下几个方法来获取字段67 Field getField(name):根据字段名获取某个public的field(包括父类)8 Field getDeclaredField(name):根据字段名获取当前类的某个field(不包括父类...
透过率和反射率的关系_反射率与透射率.PPT
weixin_30405507的博客
01-17 8408
反射率与透射率讨论： 1、增反膜：n1 ＞ n2 ，无论 n1d 为何值，镀膜后的反射率都比未镀膜时提高或不变。 λ/4 膜层，反射率达到极大。 正入射时单层薄膜的反射率与膜厚的关系 λ/2 膜层，反射率达到极小。此极小值即等于未镀膜时基板的反射率。 n1 与n2 的差别越大，增反效果越好。 2、减反膜：n1 ＜ n2 ，无论 n1d 为何值，镀膜后的反射率都...
java 防止反射_解决反射型XSS漏洞攻击
weixin_29777019的博客
02-25 3197
对于程序员来说安全防御，无非从两个方面考虑，要么前端要么后台。一、首先从前端考虑过滤一些非法字符。前端的主控js中，在 输入框标签中，找到点击发送按钮后，追加到聊天panel前 进行过滤input输入内容1 // 过滤xss反射型漏洞2 filterinputtxt: function (html) {3 html = html.repl...
java反射 枚举_java反射之获取枚举对象
weixin_39627455的博客
02-12 991
项目中导入大量枚举对象，用来定义常量。随着带来一个问题，就是每个枚举类都需要通过key来获取对应枚举的需求。1 public enumExamType {2 CRAFT(1, "草稿"),3 PASSING(2, "待审核");4 private intvalue;5 privateString typeName;67 ExamType(intvalue, ...
java 反射父类_java通过反射调用父类中的方法
weixin_39632698的博客
02-12 2219
下面是工具类package com.ninemax.utils;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Modifier;import java.lang.ref...
java 反射 getdeclaredfield_java反射机制中的getDeclaredField()
weixin_28761455的博客
02-28 3683
反射机制详解 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 一、java的特点 1、反射机制：所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。如下为ge...
java反射 获取set方法吗_Java反射基本玩法
weixin_42134054的博客
02-16 922
三个主要的反射类Class反射对象描述类语义结构，可以从Class对象中获取构造函数、成员变量、方法类等元素的反射对象，并以编程的方式通过这些反射对象对目标类对象进行操作。这些反射对象类在java.reflect包中定义，下面是最主要的三个反射类：Constructor：类的构造函数反射类，通过Class#getConstructors()方法可以获得类的所有构造函数反射对象数组。在JDK5.0中...
tdc-gp21.zip_finder_gp21_tdc gp21_tdc-gp21
09-25
【标题】"tdc-gp21.zip_finder_gp21_tdc gp21_tdc-gp21" 提供的信息表明，这是一个与激光测距仪（Laser Range Finder，简称LRF）相关的软件或代码包，其中“gp21”可能是设备型号，“tdc”可能是指时间数字转换器...
LP21.rar_LP21_光纤_光纤模式
07-14
光在光纤中传播时，由于全反射现象，会在核心和包层之间反复反射，形成多种传播模式。LP模式是描述这种传播方式的标准模型，其中LP01是最基本的单模模式，而LP21则是多模模式之一，它有两阶横向模式。 描述中提到的...
Java-网络
2301_81543552的博客
09-14 699
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 610
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 284
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1142
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 698
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
Gradle
xiaocaij_icai的博客
09-15 192
");
Java8的Optional简介
最新发布
duke_ding2的博客
09-17 523
Java8的Optional简介
Python反射机制详解：getattr、setattr与exec的运用
"这篇文章主要介绍了Python的反射机制，包括反射的概念、Python中支持反射的函数，如getattr()、setattr()、delattr()、exec()、eval()和__import__，并详细探讨了eval()和exec()的使用方法和限制。" Python反射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值