反射机制

最新推荐文章于 2025-04-07 21:39:52 发布

原创最新推荐文章于 2025-04-07 21:39:52 发布 · 161 阅读

0 ·

CC 4.0 BY-SA版权

方便类专栏收录该内容

24 篇文章

订阅专栏

本文深入讲解Java反射机制，包括如何动态获取类信息、构造对象、调用方法等核心功能，探讨面向接口编程下反射的应用场景。

/*
*
* 对于一个普通的方法（public 非static），我们如何去调用该方法
*
* 例如我们现在要调用人类的say方法
*
* （1）直接调用方法
* 在平时开发的时候，一般我们都是使用如下的方式，创建该类型对象，由对象来调用方法
* Person p = new Person();
* p.say();
*
*
* （2）间接调用方法
* 使用反射机制调用方法
* 先创建出来一个该类型的反射类型对象（Class c），由该反射类型对象取得方法类型的对象（Method method）
* 通过method对象调用invoke方法来执行
*
*
*/
测试代码

import java.lang.reflect.Method;

public class Test1 {
public static void main(String[] args) throws Exception {
	Class c = Class.forName("com.rdz.test.Person");
		
		//通过反射类型对象c，来取得say方法的Method类型的对象
		
		/*
		 * 该方法提供了两个参数
		 * 参数1：指定方法的名字
		 * 参数2~n：方法中的参数的反射类型对象
		 * 		  如果方法没有参数，则不写这一项
		 */
		
		//mothod对象表示的就是say方法
		Method method = c.getMethod("say");
		
		//执行say方法，以使用method对象的形式
		/*
		 * 
		 * 参数1：表示调用一个普通（public 非static）的方法，需要提供一个调用该方法的对象
		 * 参数2：表示为该方法传递的实参
		 * 		如果方法没有参数，则不写这项内容
		 * 
		 * 返回值类型Object：
		 * 		如果我们的方法，没有返回值，则不需要接收Object返回值
		 * 		如果硬加上返回值，接收的返回的内容是null
		 */
		
		Object p = new Person();
		Object result = method.invoke(p);
	
		//System.out.println(result);
		
		/*
		 * 
		 * 我们为什么要以反射的形式间接的调用方法呢？？？
		 * 
		 * 因为我们未来都是面向接口编程，对于对象的创建，其实都是以多态的形式来创建接口对象
		 * 
		 */
	
	}
	

}

实体类人类：

public class Person {
	
	public void say(){
		
		System.out.println("人说话");
		
	}
	
	public String add(int i,int j,String rel){
		
		return rel+(i+j);
		
	}
	
}

java
1.JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；


对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
Java反射机制主要提供了： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
java程序中的各个java类属于同一类事物，描述这类事物的java类名就是class.对比提问：众多的人用一个什么类表示？众多的java类用什么类表示？人-->Personjava类--->class 对比提问：Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，class类代表java类，它的各个实例对象又分别是什么呢？对应各个类在内存中的字节码，例如：Person类的字节码，ArrayList类的字节码，等等。

2.每个java程序执行前都必须经过编译、加载、连接、初始化。


加载是指将编译后的java类文件（也就是.class文件）中的二进制字节码读入内存，并将其放在运行时方法区，然后在堆区创建java.lang.class对象，封装类在方法区的数据结构。一个类被类加载器加载到内存中,占用一片存储空间,这个空间里面的内容就是类的字节码,不同的类的字节码是不同的,这一个个的空间可分别用一个个的对象来表示,java中有一个Class类用于代表某一个类的字节码。
反射机制获取类,获取类的字节码的三种方法：
1 .Class clazz=Class.forName("cn.itcast.reflect.Person");
2.Class clazz=new Person().getClass();
3.Class clazz=Person.class;
一、通过 class属性：类名.class
二、通过 对象 的getClass方法：实例对象.getClass()
三、通过forName静态方法：Class.forName("全路径类名")  得到字节码，若类在内存，则直接返回，若虚拟机中没有此类，则用内加载器加载，并对类初始化。

3.获取类的构造方法

3.获取类的构造方法Constructor，public 用getConstructors()。私有的用getDeclaredConstructors(),且要setAccessible(true);
获取指定参数的构造函数getConstructor(Class<?>... parameterTypes);
得到某个类所有的构造方法 ：例子：Constructor[] constructor=Class.forName("java.lang.String").getConstructors(); 
得到某一个构造方法：例子：Constructor constructor=Class.forName("java.lang.String").getConstructor(StringBuffer.class);
newInstance()创建实例对象：Class.forName("java.lang.String").newInstance();
例String str2=(String) constructor1.newInstance(new StringBuffer("abc"));
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象
 该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象
注意：直接通过反射出来 的类，不能过反射出的构造函数，再调用newInstance（），也可创建无参的构造函数，即：Class.forName("java.lang.String").newInstance();

4.获取属性

4.获取属性：所有属性和指定属性（这里有个Modifier和getModeifiers()没搞明白）
获取所有属性类的getFields()方法：例A：Field[ ] fields=实例对象.getClass().getFields();
例B：Field[ ] fields=Class.forName("全路径类名").getFields()
getField()方法不能获取私有类型和getDeclaredField()方法可获取所有，用getDeclaredField()方法，设setAccessible(true);
获取特定的属性/变量的getField()方法
例A：Field field=实例对象.getClass().getFields(filed名);
例B：Field field=Class.forName("全路径类名").getField(filed名)；
5. .getDeclaredMethod(name, parameterTypes)或getMethod(name, parameterTypes)，然后用方法.invoke(obj, args)返回值。

6.反射加配置文件


例：InputStream ips=new FileInputStream("config.properties"); //InputStream 
ips=ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/config.properties"); 
//InputStream ips=ReflectTest2.class.getResourceAsStream("config.proprties");//相对路径 
InputStream ips=ReflectTest2.class.getResourceAsStream("/cn/itcast/config.proprties");//绝对路经

7.反射实例


public class Person {
    Class clazz=Class.forName("cn.itcast.reflect.Person");
    Person p=new Person();
  A.  //不带参数的构造函数 
public void person(){
System.out.println("persion");
}
       通过反射 获取并创建 
        Constructor constructor1=clazz.getConstructor(null);
        Person person=(Person) constructor1.newInstance(null);

B.//带参数的构造函数
public void person(String name,int age){
System.out.println("persion name age");
}
      通过反射 获取并创建 
         Constructor constructor1=clazz.getConstructor(string.class,int.class);//形式参数
        Person person=(Person) constructor1.newInstance("hhb",20);//实际参数
 
    C //不带参数的方法   （先通过指定名称，形式参数获取方法-----》再通过指定对象、实际参数，作用于此方法上）
public void aa1(){
System.out.println("aa1");
}
        通过反射 获取并创建 
    Method method=clazz.getMethod("aa1", null);//aa1指方法名，null指方法对应的形式参数
method.invoke(p, null);//p指要作用的对象，null指实际参数
D.//带参数的方法
public void aa1(String name,int age){
System.out.println(name+"**"+age);
}
    通过反射 获取并创建 
    Method method=clazz.getMethod("aa1",String.class,int[].class);
    Class[] c1=(Class[]) method.invoke(p,"hhb", new int[]{1,2,3});
E //private 权限的方法
    private void aa1(InputStream in){
System.out.println(in);
}
     通过反射 获取并创建     
Method method=clazz.getDeclaredMethod("aa1",InputStream.class);
method.setAccessible(true);
method.invoke(p, new FileInputStream("c:\\a.txt")); 
 }

F 静态方法
public static void aa1(int num){
System.out.println(num);
}
通过反射 获取并创建 
    Method method=clazz.getMethod("aa1",int.class);
method.invoke(null,123); //静态不需要对象
g 主函数的反射
    public static void main(String[] args){
}
    通过反射 获取并创建 
    Method method=clazz.getMethod("main",String[ ].class);
method.invoke(null,); //静态不需要对象,为兼容JDK1.4参数要封装
        也可将参数new Object[ ]{new String[ ]{"aa","bb'}}用强制类型转换(Object)new String[ ]{"aa","bb'}
    H 获取字段field（先找相应字段-----》再获取指定对象上的字段值）
        Field field=clazz.getField("name");//参数为字段名字
//获取字段值
Object value=field.get(p);//参数为对象名
//获取字段类型
Class type=field.getType();
if(type.equals(String.class)){
String svalue=(String)value;
System.out.println("name="+svalue);
}
    I 设置字段值：field.set(p, "hhb")
8.加载类，获取类的字节码三种方法