Java反射基础与实践

本文和大家聊聊Java反射。

什么是Java反射(Reflection)?

在程序运行的过程中，能够动态的检索类相关的数据结构信息(包含构造器、字段、方法)，并能对其进行操控的技术。

Java反射能做什么？

  1. 获取类的构造器
  2. 获取类的属性(成员变量)
  3. 获取类的方法
  4. 调用类的构造器
  5. 调用类的方法
  6. 读取或修改类的属性值

Java反射有哪些应用场景？

咱们最常见的，开发人员在IDE(IDEA)中想调用类中某个方法或属性时，在类对象后面一按“.”，IDE就会自动列出它的属性或方法，这里就用到了反射。

一些通用框架中也使用反射，以下以Spring为例：

package com.hys;
/**
* JavaBean
*/
public class HelloWorld {
   private String message;
   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

<?xml version="1.0" encoding="UTF-8"?>
<!-- Beans.xml JavaBean 的配置文件 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="helloWorld" class="com.hys.HelloWorld">
       <property name="message" value="Hello World!"/>
   </bean>

</beans>

package com.hys;
/**
* 主应用
*/
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
   }
}

执行结果：
Your Message : Hello World!

上面的例子可以看出，Spring框架在Beans.xml中检索到id是“helloWorld”的<bean>，通过<bean>的class属性加载com.hys.HelloWorld类，然后通过反射将<property>的value的内容赋值给com.hys.HelloWorld类的message属性。

下面咱们通过一个一个的小例子，来掌握Java反射如何使用

显示类所有的方法(包含方法的所信息)

package com.hys;

import java.lang.reflect.Method;

public class Main {

    public String method1(String s){

        return s;
    }

    private int method2(Object p, int x) throws NullPointerException {
        if (p == null)
            throw new NullPointerException();
        return x;
    }

    public static void main(String[] args) {

        try {
            Class cls = Class.forName("com.hys.Main");//

            Method methlist[] = cls.getDeclaredMethods();//获得所有方法(包含private)
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                System.out.println("name = " + m.getName());//获取方法名
                System.out.println("decl class = " + m.getDeclaringClass());// 获取声明方法的类

                Class pvec[] = m.getParameterTypes();//获取方法的参数类型数组
                for (int j = 0; j < pvec.length; j++) {
                    System.out.println("param #" + j + " " + pvec[j]);
                }

                Class evec[] = m.getExceptionTypes();//获取方法抛出的异常类型数组
                for (int j = 0; j < evec.length; j++) {
                    System.out.println("exc #" + j + " " + evec[j]);
                }

                System.out.println("return type = " +  m.getReturnType());//获取方法返回值类型
            }
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

执行结果：

name = main
decl class = class com.hys.Main
param #0 class [Ljava.lang.String;
return type = void
name = method2
decl class = class com.hys.Main
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
name = method1
decl class = class com.hys.Main
param #0 class java.lang.String
return type = class java.lang.String

显示类的所有构建器信息

package com.hys;

import java.lang.reflect.Constructor;

public class Main {

    public Main() {
    }

    protected Main(int i, double d) {

    }

    public static void main(String[] args) {

        try {
            Class cls = Class.forName("com.hys.Main");

            Constructor ctorlist[] = cls.getDeclaredConstructors();//获取所有构造器(包含private)
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name = " + ct.getName()); //获取构造器名称
                System.out.println("decl class = " +  ct.getDeclaringClass());//获取声明构造器的类

                Class pvec[] = ct.getParameterTypes();//获取构造器参数的类型列表
                for (int j = 0; j < pvec.length; j++) {
                    System.out.println("param #" + j + " " + pvec[j]);
                }
            }
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

执行结果：

name = com.hys.Main
decl class = class com.hys.Main
name = com.hys.Main
decl class = class com.hys.Main
param #0 int
param #1 double

显示类的所有字段信息

package com.hys;

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

public class Main {

    private double d;
    public static final int i = 37;
    String s = "testing";

    public static void main(String[] args) {

        try {
            Class cls = Class.forName("com.hys.Main");

            Field fieldlist[] = cls.getDeclaredFields();//获取类的所有字段(包含private)
            for (int i= 0; i < fieldlist.length; i++) {
                Field fld = fieldlist[i];
                System.out.println("name = " + fld.getName());//获取属性名
                System.out.println("type = " + fld.getType());//获取属性类型

                int mod = fld.getModifiers();//获取属性修饰符
                System.out.println("modifiers = " + Modifier.toString(mod));
            }
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

执行结果：

name = d
type = double
modifiers = private
name = i
type = int
modifiers = public static final
name = s
type = class java.lang.String
modifiers =

调用类的方法

package com.hys;

import java.lang.reflect.Method;

public class Main {

    public int add(int a, int b)
    {
        return a + b;
    }

    public static void main(String[] args) {

        try {
            Class cls = Class.forName("com.hys.Main");
            Object instanceObj = cls.newInstance();//创建类对象实例

            Class partypes[] = new Class[2];//为方法创建参数类型数组(add(int,int))
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method addMethod = cls.getMethod("add", partypes);// 通过方法名称，获取方法对象

            Object arglist[] = new Object[2];//为方法创建参数值数组
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retObj = addMethod.invoke(instanceObj, arglist);// 调用add方法
            Integer retVal = (Integer)retObj;
            System.out.println(retVal.intValue());
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

执行结果：

84

修改类的属性值

package com.hys;

import java.lang.reflect.Field;

public class Main {

    public double d;

    public static void main(String[] args) {

        try {
            Class cls = Class.forName("com.hys.Main");
            Object instanceObj = cls.newInstance();

            Field fieldDouble = cls.getField("d");//获得类的属性对象
            System.out.println("d = " + ((Main)instanceObj).d);
            fieldDouble.setDouble(instanceObj, 12.34);//修改类的属性值
            System.out.println("d = " + ((Main)instanceObj).d);
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

执行结果：

d = 0.0
d = 12.34

我是青岚之峰，如果读完后感觉有所收获，欢迎点赞加关注

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,805评论 18赞 399
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 135,115评论 19赞 139
  • 想吃那家好吃的火锅粉
    在B站种草了火锅粉，听说火锅粉苕粉和宽粉不是同一种东西求好心人给我科普。 这是在成都吃到的火锅粉，真，的，好，辣，...
    火星民政局阅读 444评论 0赞 0
  • 去旧迎新 岁末有感
    叹 时光如梭，白驹过隙。时近岁末，投身求学数载，今年所感尤甚，其详如下： 一来 是社会日新月异之变化，二来 是...
    焉哉乎也2017阅读 533评论 1赞 6
  • 乡愁
    北雁南飞鸣寒江 秋风几许添惆怅 举杯对月深更晚 长夜借酒醉客乡
    让岁月沉醉阅读 239评论 0赞 0