反射中用到的方法,不需要看API,直接复制就可以直接用!!!!

反射中基本使用的方法下面的代码块都有,注释已经写好了,需要的直接复制就可以直接用了,省的查API麻烦

下面有封装好的一个类,以及反射的几种方式,以及常用的一些方法,一般这些就足够用了,注释写的很完整

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * 测试反射的功能
 * 测试java.lang.reflect
 */
import java.util.Map;

import javax.annotation.Resource;

@Resource
@SuppressWarnings("unchecked")
public class ReflectTest {
    
    
	public int i;
	private double d;
	static String s;
	protected Map<Integer, String> map;
	public List<String> list = new ArrayList<String>();

	public ReflectTest() {
    
    
		this.i = 10;
		this.d = 20.0;
		this.s = "hello";
		System.out.println("调用无参构造器");
	}

	private ReflectTest(String s) {
    
    
		this.s = s;
		System.out.println("这是一个String类型的构造器");
	}

	public double getD() {
    
    
		return d;
	}

	public void show() {
    
    
		System.out.println("这是一个空can的方法");
	}

	private String show(String s) {
    
    
		System.out.println(this.s);
		System.out.println("这是一个String参数的方法");
		return s;
	}

	class Inner1 {
    
    

	}

	private class Inner2 {
    
    

	}

	public static void main(String[] args) throws Exception {
    
    
		// 使用三种方式获得ReflectTest的镜像对象
		// 1.com.briup.day16.ReflectTest 权限类名 类名后面选择copy all ....
		Class<?> clazz1 = Class.forName("com.briup.day16.ReflectTest");
		/*//2.ReflectTest
		Class<ReflectTest> clazz2 = ReflectTest.class;
		//3.只知道对象的名字
		ReflectTest rt = new ReflectTest();
		Class<?> clazz3 = rt.getClass();
		System.out.println(clazz1);
		System.out.println(clazz2);
		System.out.println(clazz3);*/

		System.out.println("=====属性=====");
		// Field[] fs = clazz1.getFields();//获取所有的public属性
		Field[] fs = clazz1.getDeclaredFields();
		// System.out.println(fs.length);
		for (Field field : fs) {
    
    
			System.out.println(field.getName());
			System.out.println(field.getType());
			System.out.println(field.getModifiers());
			System.out.println(field);
			System.out.println("==========");

		}

		System.out.println("=====方法=====");
		// Method[] ms = clazz1.getMethods(); //输出自己的public方法还有父类的所有方法
		Method[] ms = clazz1.getDeclaredMethods(); // 获得本类的所有方法
		for (Method method : ms) {
    
    
			System.out.println(method);
		}

		System.out.println("=====构造器=====");
		// Constructor<?>[] cs = clazz1.getConstructors();
		Constructor<?>[] cs = clazz1.getDeclaredConstructors();
		for (Constructor<?> constructor : cs) {
    
    
			System.out.println(constructor);
		}

		System.out.println("=====内部类=====");
		Class<?>[] inners = clazz1.getDeclaredClasses();
		for (Class<?> class1 : inners) {
    
    
			System.out.println(class1.getName());
		}

		// 小小的需求
		// 获取第一个内部类的外部类名称
		Class<?> innerOne = inners[0];
		String className = innerOne.getName();
		// 注意一下内部类的全限类名方式
		Class<?> innerOO = Class.forName("com.briup.day16.ReflectTest$Inner1");

		// 通过内部类来获得外部类的Class实例
		Class<?> outClass = innerOne.getDeclaringClass();
		System.out.println(outClass.getName());

		System.out.println("=====注解=====");
		// 可以获得类上的一些注解
		Annotation[] as = clazz1.getDeclaredAnnotations();
		for (Annotation annotation : as) {
    
    
			System.out.println(annotation);
		}

		System.out.println("=====构造器创建对象=====");

		// 反射主要是在程序的运行阶段动态的修改信息

		// 使用反射来创建对象
		// 1.使用默认的构造器
		// 2.使用指定的构造器
		// ReflectTest rt = new ReflectTest();
		// 用反射产生的新实例是Object的实例
		Object obj = clazz1.newInstance();
		ReflectTest rt1 = null;
		if (obj instanceof ReflectTest) {
    
    
			rt1 = (ReflectTest) obj;
		}
		// rt1.show();
		// System.out.println(rt1.show("String"));

		// 2.使用指定的构造器
		// 首先要获得所指定的构造器
		Constructor<?> c1 = clazz1.getDeclaredConstructor(String.class);// ,Integer.class4
		// 第二种获得方式
		// Constructor<?> c1 = clazz1.getConstructor(Class.forName("java.lang.String"));

		// 使用指定的构造器进行对象的创建
		ReflectTest rt2 = (ReflectTest) c1.newInstance("hello world");

		System.out.println("=====反射调用方法=====");
		// 调用之前获得方法
		Method m1 = clazz1.getDeclaredMethod("show", null);
		Method m2 = clazz1.getDeclaredMethod("show", String.class);
		// 使用对象去调用 invoke
		m1.invoke(rt2, null); // rt2.show()
		m2.invoke(rt2, "tom"); // tr2.show("tom")
		// 假设运行时期给泛型添加不同的数据类型
		// Method m3 = clazz1.getDeclaredMethod("add", Object.class);

		System.out.println("=====属性值的访问=====");
		// 先获得想要修改的属性
		// System.out.println(rt2.s);
		Field f1 = clazz1.getDeclaredField("s");
		// System.out.println(f1.getType());
		f1.set(rt2, "hello toms");
		System.out.println(rt2.s);

		System.out.println("=========================以上的部分要掌握,下面的作为拓展======================");

		System.out.println("=====访问泛型=====");
		// 先要获得泛型类型的属性对象
		Field f2 = clazz1.getDeclaredField("map");
		// System.out.println(f2.getType().getTypeName());
		// System.out.println(f2.getGenericType());
		Type gf = f2.getGenericType();
		if (gf instanceof ParameterizedType) {
    
    
			ParameterizedType pt = (ParameterizedType) gf;
			System.out.println("原始类型:  " + pt.getRawType().getTypeName());
			// 获取泛型的类型参数
			Type[] ata = pt.getActualTypeArguments();
			for (int i = 0; i < ata.length; i++) {
    
    
				System.out.println("第" + (i + 1) + "个参数类型为: " + ata[i].getTypeName());
			}

		}
		System.out.println("======数组======");
		// 使用反射来动态创建数字和访问数组对象 Array
		Object o = Array.newInstance(String.class, 10);
		// 数组中添加元素
		Array.set(o, 0, "hello");
		Array.set(o, 1, "world");
		Array.set(o, 2, "tom");
		// 获得元素
		System.out.println(Array.get(o, 2));
		// 获得数组的长度
		System.out.println(Array.getLength(o));

		System.out.println("======其他功能======");
		System.out.println(clazz1.getPackage());
		System.out.println(clazz1.getSuperclass());
		System.out.println(Arrays.toString(clazz1.getInterfaces()));

	}
}

老规矩有什么,有什么bug或者不懂的可以私聊我哦qq:1638580498