JAVA反射机制案例解析

最新推荐文章于 2023-09-29 10:11:51 发布
最新推荐文章于 2023-09-29 10:11:51 发布
阅读量528 收藏
点赞数
分类专栏： java 文章标签： java 反射机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snda452258253/article/details/72775364
版权

建议在阅读本文之前，先理解Java反射机制的原理，再结合案例进行理解。
反射代码案例
【案例1】通过一个对象获得完整的包名和类名

package 反射Reflect;

class Demo{
    //other codes...
}

class Hello{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName()); //通过一个对象获得完整的类名（包含包名）
    }
}

【运行结果】：反射Reflect.Demo

【案例2】实例化Class类对象的方法

package 反射Reflect;

class Demo {
    // other codes...
}

class Hello {
    public static void main(String[] args) {
        Class<?> demo1 = null; //此时对象是哪个类尚不清楚
        Class<?> demo2 = null;
        Class<?> demo3 = null;
        //demo1=Class.forName(demo1.getClass().getName()); //报错，类尚未实例化
        try {
            //实例化方法1，一般尽量采用这种形式
            demo1=Class.forName("反射Reflect.Demo"); //需要异常捕获
        } catch (ClassNotFoundException e) {//或Exception e
            e.printStackTrace();
        }
        //实例化方法2、3
        demo2=new Demo().getClass();
        demo3=Demo.class;

        System.out.println("类名称 :"+demo1.getName());
        System.out.println("类名称 :"+demo2.getName());
        System.out.println("类名称 :"+demo3.getName());
    }
}

【运行结果】：
类名称 :反射Reflect.Demo
类名称 :反射Reflect.Demo
类名称 :反射Reflect.Demo

【案例3】通过Class类实例化其他类的对象

package 反射Reflect;

class Person {

    private String name;
    private int 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;
    }

    public String toString() {
        return "[" + this.name + "  " + this.age + "]";
    }

    public Person(String name, int age) { //当只有一个有参构造函数，会报错java.lang.InstantiationException
        this.age = age;
        this.name = name;
    }

    public Person(){ } //自己定义一个无参的构造函数，很重要
}

// 通过Class类实例化任意类的对象
class Hello {
    public static void main(String[] args) {
        // Class<?> demo = Person.class;//获得Class类实例
        Class<?> demo = null;
        try {
            demo = Class.forName("反射Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        Person per = null;
        try {
            per = (Person) demo.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        per.setName("Rollen");
        per.setAge(20);
        System.out.println(per);
    }
}

【运行结果】：
[Rollen 20]
如果了解Java虚拟机，应该知道，一个对象在new之前，堆里是不会分配内存的。因此这个UserInfo的实例是通过Class的实例得到的。
注意：如注释中所言，如果把无参构造函数取消，只有一个有参构造函数，代码运行会报异常，所以，显式声明空的构造函数有时候也是一种很好的习惯。当你要使用反射时，一定不要忘记无参构造。

【案例4】通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）

package 反射Reflect;

import java.lang.reflect.Constructor;

class Person{
    private String name;
    private int age;

    public Person() {

    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        this.age=age;
    }
    public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }

}

class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("反射Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per0=null;
        Person per1=null;
        Person per2=null;
        Person per3=null;
      //取得全部的构造函数
//      Constructor<?> cons[]=demo.getConstructors();//每次得到的构造方法数组的顺序是随机的，无法得知构造方法的顺序，应具体去得到相应的构造方法
//      for(int i=0;i<cons.length;i++){
//        //System.out.println(cons[i].getClass().getMethods());
  System.out.println(cons[i]);//输出构造方法
//      }
        try{
            //取得无参数的构造函数
            Constructor<?> cons0=demo.getDeclaredConstructor();
            //取得有参数的构造函数
            Constructor<?> cons1=demo.getDeclaredConstructor(String.class);
            Constructor<?> cons2=demo.getDeclaredConstructor(int.class);
            Constructor<?> cons3=demo.getDeclaredConstructor(String.class,int.class);
            per0=(Person)cons0.newInstance();
            per1=(Person)cons1.newInstance("Rollen");
            per2=(Person)cons2.newInstance(20);
            per3=(Person)cons3.newInstance("Rollen",20);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(per0);
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
    }
}

【运行结果】：
[null 0]
[Rollen 0]
[null 20]
[Rollen 20]

【案例5】 返回一个类实现的接口：

package 反射Reflect;

import java.lang.reflect.Constructor;

interface China{
    public static final String name="Rollen";
    public static  int age=20;
    public void sayChina();
    public void sayHello(String name, int age);
}

class Person implements China{
    private String name;
    private int age;

    public Person() {

    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        this.age=age;
    }
    public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }
    public void sayChina() {
        System.out.println("hello ,china");
    }

    public void sayHello(String name, int age) {
        System.out.println(name+"  "+age);
    }

}

class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("反射Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
      //保存所有的接口
        Class<?> intes[]=demo.getInterfaces();
        for (int i = 0; i < intes.length; i++) {
            System.out.println("实现的接口  :"+intes[i].getName());
        }
    }
}

【运行结果】：
实现的接口 :反射Reflect.China

【案例6】：取得其他类中的父类
以下几个例子中用得到之前的Person类，但只改动Hello中的方法，故此都省略Person代码。

class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("反射Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        //取得父类
        Class<?> temp=demo.getSuperclass();
        System.out.println("继承的父类为：   "+temp.getName());
    }
}

【运行结果】：
继承的父类为： java.lang.Object

之前案例4中获取的构造方法，输出是不包含修饰符的，下面我们来获取修饰符：
【案例7】：取得包含修饰符的构造方法

package 反射Reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

【运行结果】：
构造方法： public 反射Reflect.Person(java.lang.String arg0,int arg0){}
构造方法： public 反射Reflect.Person(int arg1){}
构造方法： public 反射Reflect.Person(java.lang.String arg2){}
构造方法： public 反射Reflect.Person(){}

【案例8】：取得包含修饰符的类及父类的所有public方法

class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("反射Reflect.Person");
            System.out.println("类名："+demo);
        }catch (Exception e) {
            e.printStackTrace();
        }
        Method method[]=demo.getMethods();//取得当前类和父类中public类型的所有方法
        for(int i=0;i<method.length;++i){
            Class<?> returnType=method[i].getReturnType(); //获得方法 返回值类型
            Class<?> para[]=method[i].getParameterTypes(); //获得方法 参数类型 如果底层构造函数没有参数，则返回长度为0的数组。
            int temp=method[i].getModifiers(); //权限修饰符 作为整数
            System.out.print(Modifier.toString(temp)+" "); //Modifier类解码这个修饰符
            System.out.print(returnType.getName()+"  ");
            System.out.print(method[i].getName()+" "); //方法名
            System.out.print("(");
            for(int j=0;j<para.length;++j){
                System.out.print(para[j].getName()+" "+"arg"+j);
                if(j<para.length-1){
                    System.out.print(",");
                }
            }
            Class<?> exce[]=method[i].getExceptionTypes(); //得到 由该对象所表示的方法抛出的异常类型,如果方法在抛出子句中声明没有异常，那么返回一个长度为0的数组。
            if(exce.length>0){
                System.out.print(") throws ");
                for(int k=0;k<exce.length;++k){
                    System.out.print(exce[k].getName()+" ");
                    if(k<exce.length-1){//多个参数用,分隔
                        System.out.print(",");
                    }
                }
            }else{
                System.out.print("){}");
            }
            System.out.println();
        }
    }
}

【运行结果】：
类名：class 反射Reflect.Person
public java.lang.String toString (){}
public java.lang.String getName (){}
public int getAge (){}
public final native void wait (long arg0) throws java.lang.InterruptedException
public final void wait (long arg0,int arg1) throws java.lang.InterruptedException
public final void wait () throws java.lang.InterruptedException
public native int hashCode (){}
public final native java.lang.Class getClass (){}
public boolean equals (java.lang.Object arg0){}
public final native void notify (){}
public final native void notifyAll (){}

【案例9】调用其他类的set和get方法

package 反射Reflect;

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

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

    public Person() {

    }

    public Person(String name) {
        this.name = name;
    }

    public Person(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String toString() {
        return "[" + this.name + "  " + this.age + "]";
    }

}



class Hello { //调用其他类的set和get方法
    /**
     * @param obj 操作的对象
     * @param att 操作的属性
     * */
    public static void getter(Object obj, String att) {
        try {
            Method method = obj.getClass().getMethod("get" + att); //这里method是得到obj类的getSex方法
            System.out.println(method.invoke(obj));//调用包装在当前Method对象中的方法 ,接收参数和返回类型都必须是对象
//          System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @param obj 操作的对象
     * @param att 操作的属性
     * @param value 设置的值
     * @param type 参数的属性
     * */
    public static void setter(Object obj, String att, Object value,
            Class<?> type) {
        try {
            Method method = obj.getClass().getMethod("set" + att, type);//这里method是得到obj类的setSex方法 ,后为参数类型
            method.invoke(obj, value);//调用包装在当前Method对象中的方法 ,接收参数和返回类型都必须是对象
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Class<?> demo = null;
        Object obj = null;
        try {
            demo = Class.forName("反射Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            obj = demo.newInstance(); //obj实例化为demo所获得的类的对象
        } catch (Exception e) {
            e.printStackTrace();
        }
        setter(obj, "Sex", "男", String.class);
        getter(obj, "Sex"); 
    }


}// end class

【运行结果】：
男

反射中的其他用法类似，最主要先获取类Class对象，具体方法具体讨论即可。

案例转自：（以上代码本人都是实测过的，这篇文章中代码有一些问题）
http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html#!comments

丿东曦既驾丶
关注
专栏目录
java反射耗时测试案例解析
08-25
Java 反射耗时测试案例解析 Java 反射机制是 Java 语言中的一种强大功能，它允许开发者在运行时动态地访问和修改类、对象、字段和方法。然而，Java 反射机制也存在一些性能问题，特别是在高频率调用时。以下是 Java...
java反射实操案例
zhan_qian的博客
10-09 1628
一、反射介绍： 二、常用反射操作: 1、获取类对应的字节码对象（后缀为.class）： （1）类对象.getClass() （2）类名.class （3）Class.forname("类的路径") 2、获取了类的Class对象后，可通过该字节码对象获取该类的多种信息 （1）测试用的学生类： （2）得到类属性的方法： （3）得到类方法的方法： （4）通过获取字节码，进而创建对象： （5）通过字节码对象获取包名、类名：
反射（一）
zuo_fan的博客
12-28 243
1.什么是反射？ 反射java语言中的一种机制，通过这种机制可以动态的实例化对象、 读写属性、调用方法 2. 类类 所有狗 狗类 Dog 狗对象 旺财 所有猫 猫类 Cat 猫对象 肥波 所有类 类类 java.lang.Class 类对象 特定类（实例） java.lang.Class java...
【Java】反射机制
qq_61635026的博客
07-10 1053
Java的反射机制（Reflection）是Java编程语言的一项重要功能，它允许程序在运行过程中获取类的信息并操作对象或类。反射机制提供了一套获取类的成员变量、方法、构造函数等信息的能力，而不需要在编译时明确知道这些信息。
【Java基础】Java 反射知识及实战
fumeidonga的博客
04-29 1055
Java 反射（Reflection）是指在运行时动态地获取类的信息、调用方法、获取属性等，从而实现运行时的类型检查、动态代码生成、设置和操作类的信息等功能。（动态获取的信息以及动态调用对象）。有两个特点：1、对于任意一个类，都能够知道这个类的所有属性和方法；2、对于任意一个对象，都能够调用它的任意一个方法和属性；通俗的说，反射就是把java类中的各种成分映射成一个个的Java对象。一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
Java反射详解+实战案例
LYQ
07-21 4334
Java反射机制是在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。“反射之所以被称为框架的灵魂”，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力，这种能力也就是我们常说的动态性，利用这种性质可以使编写的程序更灵活更通用。反射机制可以用来：官方文档：https://docs.oracle.com/javase/tutorial/reflect/index.ht
Java反射机制经典案例
09-15
Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、字段和方法等对象。这种能力使得Java代码能够具备动态性，可以在不知道具体类名的情况下实例化对象，调用方法，访问字段，以及...
JAVA反射机制
08-31
JAVA反射机制是JAVA编程语言中的一个核心特性，它允许运行中的程序动态地获取类的信息并操作类的对象。在JAVA中，反射机制提供了强大的能力，包括在运行时创建对象、访问私有成员、调用未知方法以及实现元编程等功能...
举例解析Java的反射机制
03-01
本篇将深入解析Java反射机制，并通过具体的代码示例进行讲解。 1. java.lang.Class类： 每个Java类都有一个对应的Class对象，它包含了该类的所有信息。我们可以通过`Class.forName()`方法或对象的`getClass()`方法...
Java反射（原理剖析与使用）
我认不到你的博客
05-01 3027
1、Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。 2、Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。
Java反射
pan_yuyuan的博客
12-08 259
1，什么是反射？　　 　　Java的反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意方法和属性;并且能改变它的属性而这也是Java的被视为动态（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python和红宝石是动态语言，C ++，Java和...
关于Java反射的详解及实战案例
Java技术攻略的博客
04-21 844
需求如下：我现在引入了一个第三方 jar 包，里面有一个 MyBatis-Plus 查询构造器，其中构造 LIKE条件查询的条件是当前端传过来的参数带有逗号时，拼接为LIKE查询条件。关键代码：标识在对象的某个成员属性上​​复制代码标识在Controller层上，以此来判断那些请求是需要被切入的。​​复制代码一个非常简单的Javabean@Data​​​​​复制代码Controller 类@Slf4j​​复制代码。
深入Java的反射机制：性能、安全性与应用案例
最新发布
m0_57781768的博客
09-29 234
Java反射是Java提供的一种能力，允许程序在运行时检查和修改对象的内部状态。简单地说，它允许你在编码时并不知道具体的类或方法名，但在运行时可以动态地加载、探查和调用类和方法。
Java 反射详解及示例代码
weixin_43854959的博客
07-13 1365
反射（Reflection）是Java中一种强大的机制，允许我们在运行时检查和操作类、接口、字段和方法。借助反射，我们可以动态地创建对象、调用方法，以及读取和修改属性值。
JAVA
沉心听雨
03-25 570
http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html反射机制详解 java反射详解 本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。 下面开始正文。 【案例1】通过一个对象获得完整的包名和类名
java反射机制的例子_Java 反射机制的应用实例
weixin_29958373的博客
02-12 332
Java 反射机制的应用实例前言：反射是java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。下面介绍俩个在实际运用中反射的应用：场景一：DTO的数据封装在大多数软件架构中有一层DTO层，用于提供于与前端...
JAVA反射及其实例
苍天在上
04-14 688
这一篇并不想过多的介绍Java中关于反射的概念，我想即便是对于Java的初学者而言也并不感到陌生，该篇将一如既往的为您提供大量的可执行示例代码和丰富的注释信息，尽可能覆盖Java反射的各个技术环节，从更多的视角为您剖析反射的机制和应用场景，以及它在效率方面的不尽如人意之处。     1.    类属性反射：     每一个Java对象都会包含一个描述其属性(metadata)信息的类对象，该对
深入解析Java反射机制：原理、应用与案例
Java反射机制是Java语言提供的一种强大的特性，它允许程序在运行时动态地获取和操作类的信息，包括类的属性、方法、构造函数等。这一机制对于动态编程、元编程、框架设计以及远程方法调用等场景有着广泛的应用。 第...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值