反射学习代码

测试类一

 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);
    	}