【反射】就是把java类中的各个成分映射成相应的java类

最新推荐文章于 2023-08-24 19:00:01 发布

闲着没事_玩玩JAVA

最新推荐文章于 2023-08-24 19:00:01 发布

阅读量2.1k

点赞数 1

分类专栏：闲着没事—玩玩Java

本文链接：https://blog.youkuaiyun.com/wanwanjava/article/details/21417083

版权

闲着没事—玩玩Java 专栏收录该内容

85 篇文章

订阅专栏

本文探讨了Java的反射机制，介绍了如何通过反射获取类的构造函数、方法和字段。内容包括利用`getConstructor()`、`getMethod()`和`getField()`进行操作，以及如何替换对象中String类型字段的特定字符。此外，还讲解了根据配置文件动态加载类并创建实例，以及探究反射在获取方法泛型参数方面的高级应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

要反射的类

package com.xiaozhi.reflect;

import java.io.InputStream;
import java.util.List;

public class Person {

	private String name;
	private int password;
	
	public Person() {
		System.out.println("无参构造函数");
	}

	
	public Person(String name) {
		this.name = name;
		System.out.println("一个参数的构造函数"+name);
	}


	public Person(String name, int password) {
		this.name = name;
		this.password = password;
		System.out.println("两个参数的构造函数"+name+":"+password);
	}
	
	private Person(List list){
		System.out.println("私有构造函数");
	}
	
	
	public void aa1(){
		System.out.println("aa1");
	}
	public void aa1(String name,int password){
		System.out.println("name= "+name+" password="+password);
	}
	public Class[] aa1(String name,int[] password){
		return new Class[]{String.class};
	}
	private void aa1(InputStream in){
		System.out.println(in);
	}
	public static void aa1(int num){
		System.out.println(num);
	}
	public static void main(String []args){
		System.out.println("main");
	}

}

反射构造函数

getConstructor（构造函数的参数）

package com.xiaozhi.reflect;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;


public class Test {

	public static void main(String[] args) throws Exception {
		//加载类的字节码的三种方法
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Class clazz=new Person().getClass();
//		Class clazz=Person.class;
		
		//无参的构造函数
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Constructor constructor=clazz.getConstructor(null);
//		Person person=(Person) constructor.newInstance(null);
		
		//一个参数的构造函数
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Constructor constructor=clazz.getConstructor(String.class);
//		Person person=(Person) constructor.newInstance("jingtianxiaozhi");
		
		//两个参数的构造函数
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Constructor constructor=clazz.getConstructor(String.class,int.class);
//		Person person=(Person) constructor.newInstance("jingtianxiaozhi",100);
		
		//私有的构造函数
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Constructor constructor=clazz.getDeclaredConstructor(List.class);
//		constructor.setAccessible(true);
//		Person person=(Person) constructor.newInstance(new ArrayList());
		
		//默认的
		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
		Person p=(Person) clazz.newInstance();
	}
	
}

反射方法

getMethod（方法名，方法参数。。。）

package com.xiaozhi.reflect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

public class Test2 {

	public static void main(String[] args) throws Exception {
		//无参的方法
		//public void aa1()
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Method method=clazz.getMethod("aa1",null);
//		Person person=new Person();
//		method.invoke(person,null);
		
		//有参数的方法
		//public void aa1(String name,int password)
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Method method=clazz.getMethod("aa1",String.class,int.class);
//		Person person=new Person();
//		method.invoke(person,"jingtianxiaozhi",22);
		
		//有返回值的方法
		//public Class[] aa1(String name,int[] password)
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Method method=clazz.getMethod("aa1",String.class,int[].class);
//		Person person=new Person();
//		Class cs[]=(Class[]) method.invoke(person,"jingtianxiaozhi",new int[]{1,2,3});
//		System.out.println(cs[0]);
		
		//private void aa1(InputStream in){
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Method method=clazz.getDeclaredMethod("aa1",InputStream.class);
//		method.setAccessible(true);
//		Person person=new Person();
//		method.invoke(person,new FileInputStream("c:\\jingtianxiaozhi.txt"));
		
		//静态方法
		//public static void aa1(int num){
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Method method=clazz.getMethod("aa1",int.class);
//		method.invoke(null,22);
		
		//main方法
		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
		Method method=clazz.getMethod("main", String[].class);
		method.invoke(null,new String[]{"13"});//Object...//拆开之后，main方法接受的参数是字符串
		method.invoke(null,new Object[]{new String[]{"13"}});//Object...//拆开之后，是一个字符串数组
		method.invoke(null,(Object)new String[]{"13"});
		
		
	}
}

反射字段

getField（字段名）

package com.xiaozhi.reflect;

import java.lang.reflect.Field;

public class Test {

	public static void main(String[] args) throws Exception {
		//获取公有字段类型字段值
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Field field=clazz.getField("name");
//		Class type=field.getType();
//		System.out.println(type);
//		Person person=new Person();
//		String value=(String)field.get(person);
//		System.out.println(value);
		
		//设置公有字段值
//		field.set(person,"xiaozhi");
//		System.out.println(field.get(person));
		
		//获取私有字段类型以及值
//		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
//		Field field=clazz.getDeclaredField("password");
//		field.setAccessible(true);
//		Class type=field.getType();
//		System.out.println(type);
//		Person person=new Person();
//		Integer value=(Integer)field.get(person);
//		System.out.println(value);
		
		
		//获取静态字段类型以及值
		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
		Field field=clazz.getField("age");
		Class type=field.getType();
		System.out.println(type);
		Integer value=(Integer)field.get(null);
		System.out.println(value);
	}
}

class Person{
	public String name="aaa";
	private int password=123;
	public static int age=22;
}

反射的应用举例：

将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的“a”换成“b”

package com.xiaozhi.reflect;

import java.lang.reflect.Field;

public class Test {

	public static void main(String[] args) throws Exception {
		Person person=new Person();
		Class clazz=Class.forName("com.xiaozhi.reflect.Person");
		Field[] fields=clazz.getFields();
		for(Field field:fields)
		{
			if(field.getType().equals(String.class))
			{
				String oldValue=(String)field.get(person);
				field.set(person,oldValue.replaceAll("a", "b"));
			}
		}
		System.out.println(person.name);
		System.out.println(person.password);
	}
}

class Person{
	public String name="aaa";
	public String password="abcdefg";
}

通过配置文件得到一个类的名字，Class.forName()加载该类，反射出构造方法，得到该类的实例对象。

package com.xiaozhi.frame;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.util.Collection;
import java.util.Properties;


public class Test {

	public static void main(String[] args) throws Exception {
		InputStream inputStream=new FileInputStream("config.properties");
		Properties properties=new Properties();
		properties.load(inputStream);
		inputStream.close();
		String className= (String) properties.get("className");
		
		Class clazz=Class.forName(className);
		Constructor constructor= clazz.getConstructor(null);
		Collection collection=(Collection)constructor.newInstance();
		
		collection.add(new String("a"));
		collection.add(new String("a"));
		collection.add(new String("a"));
		System.out.println(collection.size());
	}
}

反射的高级应用：得到方法的泛型参数类型的泛型参数

package com.xiaozhi.generic;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.Vector;

public class GenericTest {
	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.xiaozhi.generic.GenericTest");
		Method method = clazz.getMethod("applyVector", Vector.class);
		Type[] types = method.getGenericParameterTypes();
		ParameterizedType pType = (ParameterizedType)types[0];
		System.out.println(pType.getRawType());
		System.out.println(pType.getActualTypeArguments()[0]);
	}

	public static void applyVector(Vector<Date> v) {

	}
}