简单易懂: JAVA反射详解+实例

天亮有惊喜

已于 2024-02-13 23:07:11 修改

阅读量460

点赞数 3

分类专栏： Java学习 JAVA调试文章标签： java 开发语言反射

于 2022-03-09 09:57:41 首次发布

本文链接：https://blog.csdn.net/weixin_42571453/article/details/123368541

版权

Java学习同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

JAVA调试

5 篇文章 0 订阅

订阅专栏

2.2 通过反射，调用Class的三种方式

2.3 反射得到的Class 类获取成员变量、成员方法、接口、超类、构造方法等

2.3 完整测试代码

三、根据反射获取父类属性

一、反射详解

1.1 反射定义

Java反射就是在运行状态中，可以获取任意一个类的所有属性和方法（包括私有）并且调用它们；也可以改变它的属性（包括私有）。这也是Java被视为动态语言（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言）的一个关键特质。动态代理的实现，就依赖于反射！

1.2 反射优缺点

优点：可以代码更加灵活（毕竟可以获取任一个类的所有属性和方法），为各种框架提供开箱即用的功能提供了便利；
缺点：我们在运行时有了分析操作类的能力，这也增加了安全问题，比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时，而我们在运行时可以分析、修改类）。同时，反射的性能比较差（但对于框架而言，影响不大）。可以通过这个例程进行验证。

参考：Java Reflection: Why is it so slow?

package testprogram1;

class B {

}

public class reflectTestTime {

    public static long timeDiff(long old) {
        return System.currentTimeMillis() - old;
    }

    public static void main(String args[]) throws Exception {

        long numTrials = (long) Math.pow(10, 7);

        long millis;

        millis = System.currentTimeMillis();

        for (int i=0; i<numTrials; i++) {
            new B();
        }
        System.out.println("Normal instaniation took: "
                 + timeDiff(millis) + "ms");

        millis = System.currentTimeMillis();

        Class<B> c = B.class;

        for (int i=0; i<numTrials; i++) {
            c.newInstance();
        }

        System.out.println("Reflecting instantiation took:" 
              + timeDiff(millis) + "ms");

    }
}

输出结果：Normal instaniation took: 8ms
Reflecting instantiation took:54ms

1.3 反射作用

反射机制允许程序在运行时获取任意一个已知名称的class的内部信息（含private），包括其modifiers（修饰符）、fields（属性）、methods（方法）等，并可在运行时改变fields内容或调用methods。我们就可以灵活的编写代码，而不需在组件之间进行源代码的衔接，降低代码的耦合度。动态代理的实现，就依赖于反射！但反射不当会造成很大的资源消耗。

二、反射的具体实现

2.1 创建一个基本类Person

package com.ys.reflex;
public class Person {
    //私有属性
    private String name = "Tom";
    //公有属性
    public int age = 18;
    //构造方法
    public Person() {
    }
    //私有方法
    private void say(){
        System.out.println("private say()...");
    }
    //公有方法
    public void work(){
        System.out.println("public work()...");
    }
}

2.2 通过反射，调用Class的三种方式

（1）通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object类型的对象，而我不知道你具体是什么类，用这种方法；

（2）直接通过类名.class 的方式得到,该方法最为安全可靠，程序性能更高这说明任何一个类都有一个隐含的静态成员变量 class；

（3）通过 Class 对象的 forName() 静态方法来获取，用的最多，但可能抛出 ClassNotFoundException 异常

//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object类型的对象p1
    Person p1 = new Person();
//  而我不知道你具体是什么类，用这种方法
　　Class c1 = p1.getClass();

//2、直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
//  这说明任何一个类都有一个隐含的静态成员变量 class
　　Class c2 = Person.class;

//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
//   但可能抛出 ClassNotFoundException 异常
　　Class c3 = Class.forName("com.ys.reflex.Person");

需要注意的是：一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的 c1,c2,c3进行 equals 比较，发现都是true

2.3 反射得到的Class 类获取成员变量、成员方法、接口、超类、构造方法等

查阅 API 可以看到 Class 有很多方法：

getName()：获得类、方法、属性、构造器的完整名字。
　　getFields()：获得类的public类型的属性。
　　getDeclaredFields()：获得类的所有属性。包括private 声明的和继承类
　　getMethods()：获得类的public类型的方法。
　　getDeclaredMethods()：获得类的所有方法。包括private 声明的和继承类
　　getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
　　getConstructors()：获得类的public类型的构造方法。
　　getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
　　newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

2.3 完整测试代码

package testprogram1;

import java.lang.reflect.*;

public class reflectTest {

	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
		// TODO Auto-generated method stub
		//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
		//  类型的对象，而我不知道你具体是什么类，用这种方法
		Person p1 = new Person();
		Class c1 = p1.getClass();

		//2、直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
		//  这说明任何一个类都有一个隐含的静态成员变量 class
		Class c2 = Person.class;

		//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
		//   但可能抛出 ClassNotFoundException 异常
		Class c3 = Class.forName("testprogram1.Person");
	
	
	
		//获得类完整的名字
		String className = c2.getName();
		System.out.println(className);//输出com.ys.reflex.Person

		//获得类的public类型的属性。
		Field[] fields = c2.getFields();
		for(Field field : fields){
			System.out.println(field.getName());//age
		}

		//获得类的所有属性。包括私有的
		Field [] allFields = c2.getDeclaredFields();
		for(Field field : allFields){
			System.out.println(field.getName());//name    age
		}
		
		//获得类的public类型的方法。这里包括 Object 类的一些方法
		Method [] methods = c2.getMethods();
		for(Method method : methods){
		    System.out.println(method.getName());//work waid equls toString hashCode等
		}
	
		//获得类的所有方法。
		Method [] allMethods = c2.getDeclaredMethods();
		for(Method method : allMethods){
		    System.out.println(method.getName());//work say
		}

		//获得指定的属性
		Field f1 = c2.getField("age");
		System.out.println(f1);
		//获得指定的私有属性
		Field f2 = c2.getDeclaredField("name");
		//启用和禁用访问安全检查的开关，值为 true，则表示反射的对象在使用时应该取消 java 语言的访问检查；反之不取消
		f2.setAccessible(true);
		System.out.println(f2);
	
		//创建这个类的一个对象
		Object p2 =  c2.newInstance();
		//将 p2 对象的  f2 属性赋值为 Bob，f2 属性即为 私有属性 name
		f2.set(p2,"Bob");
		//使用反射机制可以打破封装性，导致了java对象的属性不安全。
		System.out.println(f2.get(p2)); //Bob
	
		//获取构造方法
		Constructor [] constructors = c2.getConstructors();
		for(Constructor constructor : constructors){
		    System.out.println(constructor.toString());//public com.ys.reflex.Person()
		}
	}
	
}
class Person {
    //私有属性
    private String name = "Tom";
    //公有属性
    public int age = 18;
    //构造方法
    public Person() {
    }
    public Person(String[] wife) {
    	System.out.print("My wife's name is:"+"wife");
    }
    //私有方法
    private void say(){
        System.out.println("private say()...");
    }
    //公有方法
    public void work(){
        System.out.println("public work()...");
    }
}

三、根据反射获取父类属性

定义父类和子类，通过执行下列代码，我们获得了父类的私有属性值，这里要注意的是直接通过反射获取子类的对象是不能得到父类的属性值的，必须根据反射获得的子类 Class 对象再调用 getSuperclass() 方法获取父类对象，然后再通过父类对象去获取父类的属性值。

package testprogram1;

import java.lang.reflect.*;

import testprogram1.reflectTestExtend.Test;

class Parent {
    public String publicField = "parent_publicField";
    protected String protectField = "parent_protectField";
    String defaultField = "parent_defaultField";
    private String privateField = "parent_privateField";

}
class Son extends Parent {
	
}
public class reflectTestExtend {

    public @interface Test {

	}
	@Test
    public static void main(String args[]) throws Exception{
        Class c1 = Class.forName("testprogram1.Son");
        //获取父类私有属性值
        System.out.println(getFieldValue(c1.newInstance(),"privateField"));
    }

    public static Field getDeclaredField(Object obj,String fieldName) {
        Field field = null;
        Class c = obj.getClass();
        for(; c != Object.class ; c = c.getSuperclass()){
            try {
                field = c.getDeclaredField(fieldName);
                field.setAccessible(true);
                return field;
            }catch (Exception e){
                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
                //如果这里的异常打印或者往外抛，则就不会执行c = c.getSuperclass(),最后就不会进入到父类中了
            }
        }
        return null;
    }
    public static Object getFieldValue(Object object,String fieldName) throws Exception{
        Field field = getDeclaredField(object,fieldName);
        
        return field.get(object);
    }
}

码文不易，谢谢你的点赞 ^_^

天亮有惊喜

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
简单易懂: JAVA反射详解+实例

一、反射详解1.1反射定义 Java反射就是在运行状态中，可以获取任意一个类的所有属性和方法（包括私有）并且调用它们；也可以改变它的属性（包括私有）。这也是Java被视为动态语言（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言）的一个关键特质。动态代理的实现，就依赖于反射！1.2反射优缺点优点：可以代码更加灵活...
复制链接

扫一扫