反射学习代码

测试类一

public class Stu {
	public String name ;
	protected String sex;
	private int age;
	
	public static String school ="hqyj";
	//final变量必须赋值
	public static final String address="科华北路99号";
	//无返回有参方法
	public void study(String subject) {
		System.out.println("正在学习"+subject);
	}
	/*方法重载和什么相关？仅仅和参数列表相关
	 * 	1.参数数量
	 * 	2.参数类型
	 *	3.参数顺序
	 */
	//有返回有参方法--protected
	protected int add(int a,int b) {
		return a+b;
	}
	//无返回有参方法
	public void add(String a,String b) {
		System.out.println(a+b);
	}
	//无返回无参方法--private
	private void sleep(String friend) {
		System.out.println("想和"+friend+"睡觉");
	}
	public void eat() {
		System.out.println("今天中午吃什么");
	}
	public Stu() {
		super();
	}
	public Stu(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Stu [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public static String getSchool() {
		return school;
	}
	public static void setSchool(String school) {
		Stu.school = school;
	}
	public static String getAddress() {
		return address;
	}
}

测试类二

public class Stu2 extends Stu{
//用来测试继承的性质
}

反射的学习

package com.fs.testReflectDemo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;

import com.fs.po.Stu;
public class TestReflectDemo {
	
	
	public static void  main(String [] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException, NoSuch

MethodException, IllegalArgumentException, InvocationTargetException {
		Class<Stu> stuClass = getStuClass();
		
		showFields(stuClass);
		showStuConstrcutor(stuClass);
	}

/* * 第一部分、获得类类型 * */

	public static Class<Stu> getStuClass() throws ClassNotFoundException{
		//3种获得类类型的方法
		/* 1. 类名.class
		 * 2. 对象名.getClass()
		 * 3. Class.forName("类全名")
		 * **/
		/*1. 类名.class*/
		Class<Stu> stuClass1 = Stu.class;
		/*2. 对象名.getClass()*/
		Stu stu = new Stu();
		Class<Stu> stuClass2 = (Class<Stu>) stu.getClass();
		/*3. Class.forName("类全名")*/
		Class<Stu> stuClass3 =(Class<Stu>) Class.forName("com.fs.po.Stu");
		
		return stuClass1;/* return stuClass2;return stuClass3; */
	}

/* * 第二部分、获得成员变量、通过反射给成员变量赋值 * */

	public static void showFields(Class<? extends Stu> StuClass) throws NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
		//获得所有的类，包括继承的
		
		// getFields()拿的是所有的public修饰成员变量
		// 包括从父类继承下来的
		Field [] myFields =StuClass.getDeclaredFields();
		showFieldInfo( myFields);
		
		// getDeclaredFields()拿自己这个类所有的成员变量, 
		// 不管修饰符，但是不能拿到从父类那里继承下来的
		Field [] myFields2 =StuClass.getFields();
		showFieldInfo( myFields2);
		
		// 拿到指定的成员变量
		Field name = StuClass.getDeclaredField("name");
		Field age = StuClass.getDeclaredField("age");
		//通过反射给成员变量赋值， /* 普通赋值格式： 对象.属性=xxx */
		
		//反射创建对象
		Stu stu = StuClass.newInstance();
		/**
		 * 反射给成员变量赋值
		 * 方法调用者：field
		 * 方法名：set
		 * 参数一：要赋值的对象
		 * 参数二：赋给field的值
		 */
		name.set(stu, "刘老师");
		// 让私有属性能被访问
		// 如果不加下面这一句，权限不够，会抛异常IllegalAccessException
		age.setAccessible(true);
		
		// 如果参数类型不一致，会抛异常IllegalArgumentException 如：age.set(stu, "fsdf");
		age.set(stu, 33);
		
		System.out.println(stu);
		
	}
	//打印方法
	private static void showFieldInfo(Field[] fields) {
		for (Field field : fields) {
			// 修饰符
			int modefiers = field.getModifiers();
			// 成员变量类型
			String type = field.getType().toString();
			// 成员变量名称
			String name = field.getName();
			System.out.println("修饰符"+modefiers + "  类型	" + type + "	名称	 " + name);
		}
		System.out.println("-----------------------------------------");
	}

/第三部分 构造法方法的获取，参数的传递/

public static void showStuConstrcutor(Class<Stu> stuClass) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
	// getDeclaredConstructors();拿自己这个类所有的构造方法, 
	// 不管修饰符，但是不能拿到从父类那里继承下来的
	Constructor<Stu>[] constructors1 = (Constructor<Stu>[]) stuClass.getDeclaredConstructors();
	
	// getConstructors();拿的是所有的public修饰成员变量
	// 包括从父类继承下来的
	Constructor<Stu>[] constructors2 = (Constructor<Stu>[]) stuClass.getConstructors();
	
	for (Constructor<Stu> constructor : constructors1) {
		// 修饰符
		int modifiers = constructor.getModifiers();
		// 构造方法名称
		String name = constructor.getName();
		// 构造方法参数获取
		Parameter[]  parameters = constructor.getParameters();
		/* String ：不可更改
		 * StringBuilder ：可以更改，线程安全
		 * StingBuffer ： 可以更改，线程不安全
		 * */
		//组装字符串
		StringBuilder sb = new StringBuilder(modifiers+" "+ name+"(");
		for (Parameter parameter : parameters) {
			String type = parameter.getType().toString();
			String pName = parameter.getName();
			//组装字符串
			sb.append(type +" " + pName+ ", ");
		}
		//组装字符串
		int end = sb.lastIndexOf(", ");
		if(end!=-1) {
			sb = new StringBuilder(sb.substring(0, end));
		}
		sb.append(")");
		System.out.println(sb);
	}
	// 拿到指定构造方法
	Constructor<Stu> constructor = stuClass.getDeclaredConstructor();
	Constructor<Stu> constructor2 = stuClass.getDeclaredConstructor(String.class, String.class, int.class);
	// 通过构造方法创建对象
	Stu stu = constructor.newInstance();
	Stu stu2 = constructor2.newInstance("魏鸿麒", "男", 18);
	System.out.println(stu);
	System.out.println(stu2);

}

}

练习:通过反射绕过泛型检测

private static void listDemo() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		List<String> strList = new ArrayList<>();
		List<Integer> intList = new ArrayList<>();
		strList.add("Hello");
		// 泛型检测，发生在编译时
		// strList.add(2);
		
		// 拿到类类型
		Class<List<String>> strListClass = (Class<List<String>>) strList.getClass();
		Class<List<Integer>> intListClass = (Class<List<Integer>>) intList.getClass();
		// 编译过后是去泛型的
		System.out.println(strListClass.equals(intListClass));
		// 拿到指定方法
		Method add = strListClass.getDeclaredMethod("add", Object.class);
		// 反射调用方法
		add.invoke(strList, "world");
		add.invoke(strList, 2);
		add.invoke(strList, new Stu());
		System.out.println(strList);
	}