JAVA反射机制实操（二）

题目1：利用反射API检查对象的内部结构

public class Demo01 {

	public static void main(String[] args) {
		/**
		 * 利用反射API检查对象的内部结构 
		 */
		test("abc"); 
		//test(123); 
		//test(new ArrayList<>()); 
		
	}
	
	public static void test(Object obj){
		//obj 的具体类型是什么？
		//如何在方法中检查对象的具体类型？
		//利用反射API可以“动态”检查对象的类型
		//Object类上定义了getClass，用于检查
		//软件执行期间对象的具体类型！
		Class cls = obj.getClass();
		System.out.println(cls); 
		
		//进一步动态检查类型的内部结构：
		//1. 检查类型声明的全部成员变量
		// Declared 声明的 Field：字段，成员变量
		// getDeclaredFields方法的功能是检查cls
		// 代表的类型中全部的字段（成员变量）
		Field[] fields=cls.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field); 
		}
		
		//2. 检查类中声明的方法(Method)
		// getDeclaredMethods 动态获取当前类型中声明的
		// 方法信息，不包含继承的方法
		// getMethods() 获取当前类和从父类中继承的方法
		Method[] methods=cls.getDeclaredMethods();
		for (Method method : methods) {
			System.out.println(method);
		}
		 
	
	}
}

结果：
可以看到单单String类型所涉及到的字段、方法是非常多的了。

题目2：利用反射执行一个类中全部以test为开头的方法

/**
 * 实现一个工具，自动执行标注了@Test的方法 
 */
public class DemoAll {

	@Test
	public void demo01(){
		List<String> list=new ArrayList<>();
		list.add("Tom");
		list.add("Jerry");
		list.add("熊大");
		System.out.println(list); 
	}

	@Test
	public void demo02(){
		List<String> list=new LinkedList<>();
		list.add("Tom");
		list.add("Jerry");
		list.add("熊大");
		System.out.println(list); 
	}

	@Test
	public void abc(){
		System.out.println("Hello  World!"); 
	}
	
	@Test 
	public void str01(){
		String str = "anc123";
		String s = str.toUpperCase();
		System.out.println(s); 
	}
	
}

public class Demo04 {

	public static void main(String[] args) 
		throws Exception{
		/**
		 * 利用反射执行一个类中全部以test为开头的方法
		 */
		// 1. 动态获取类名
		Scanner in = new Scanner(System.in);
		System.out.print("输入类名：");
		String className = in.nextLine();
		// 2. 根据类名动态加载类到方法区
		Class cls = Class.forName(className);
		System.out.println(cls); 
		// 3. 动态创建对象
		Object obj = cls.newInstance();
		System.out.println(obj); 
		// 4. 动态查找全部方法
		Method[] methods=cls.getDeclaredMethods();
		// 5. 遍历全部方法，找到以test为开头的方法
		for(Method method:methods){
			//获取方法的名称 method.getName();
			String name=method.getName();
			System.out.println(name); 
			//6. 检查方法名是否以test为开头
			if(name.startsWith("test")){
				// 7. 执行找到的方法
				method.invoke(obj);
			}
		}
	}
}

结果：
题目3：利用反射执行有参数的方法

public class Foo {
	int a = 5;
	
	public void test() {
		System.out.println("test()");
	}
	
	private void demo() {
		System.out.println("demo()");
	}
	
	public int demo(int n, String s){
		System.out.println("demo(int, String)");
		return n+s.length();
	}
	public int test(int n, String s){
		System.out.println("test(int, String)");
		return n+s.length();
	}
	public double test(double n, String s){
		System.out.println("test(double,String)"); 
		return n+s.length();
	}
}

public class Demo05 {

	public static void main(String[] args)
		throws Exception{
		/**
		 * 利用反射执行有参数的方法
		 * 
		 */
		Scanner in = new Scanner(System.in);
		System.out.print("输入类名：");
		String className = in.nextLine();
		System.out.print("输入方法名：");
		String methodName = in.nextLine();
		//1. 动态加载类
		Class cls = Class.forName(className);
		//2. 动态创建对象
		Object obj = cls.newInstance();
		//3. 查找有参数的方法, 第一个参数是整数，
		//  第二个参数类型是String，如果找不到就抛异常
		Method method = cls.getDeclaredMethod(
				methodName, int.class, String.class);
		System.out.println(method);
		//4. 动态获取参数
		System.out.print("输入参数1：");
		String p1 = in.nextLine();
		System.out.print("输入参数2：");
		String p2 = in.nextLine();
		int n = Integer.parseInt(p1);
		//5. 动态执行方法
		Object val = method.invoke(obj, n, p2);
		System.out.println(val);
	}

}

嘻嘻，那今天的练习就这样结束啦~