反射

package com.xcliang.learn.code;

public class Learn {
	private String name;
	public int age;
	private boolean flag;
	
	public Learn() {
		System.out.println("无参构造");
	}
	
	public Learn(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	@Override
	public String toString() {
		return "Learn [name=" + name + ", age=" + age + "]";
	}

	
	private void use1(String s,int age) {
		System.out.println("私有方法测试"+s+age);
	}
	void use2() {
		System.out.println("默认权限方法测试");
	}
	
	protected void use3() {
		System.out.println("受保护的方法测试");
	}
	public void use4(String s) {
		System.out.println("公开方法测试"+s);
	}
}

package com.xcliang.learn.code;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {
	public static void main(String[] args) {

		//一个项目中一个类会加载几次？--当一个类被加载后会在内容中生成一个Class对象
		//反射--是用已经加载到内存中的类作为模板创建
		
		
		
		// 如何获得某一个类在内存中的Class对象模板？
		// 第一种获得类模版的方式：
		 try {
		 Class<?> c = Class.forName("src/com/xcliang/learn/code/Learn.java");//作为模板的类的路径
		 } catch (ClassNotFoundException e) {
		 e.printStackTrace();
		 }

		// 第二种获得类模版的方式：
		 Learn learn = new Learn();
		 Class<?> cl = learn.getClass();

		// 第三种获得类模版的方式：
		 Class<?> c1a = Learn.class;

		 
		 
		 
		// 使用Class模板创建该类对象
		//第一种方法
		 Class<Learn> class3= Learn.class;//获取Class对象类模板
		 try {
		 Learn learn3 = class3.newInstance();//根据Class模板创建Learn1的对象
		 System.out.println("根据类模板创建对象"+learn3);
		 } catch (InstantiationException | IllegalAccessException e) {
		 // TODO Auto-generated catch block
		 e.printStackTrace();
		 }

		//第二种方法---使用类模版得到无参构造器来创建对象
		 Class<Learn> class2 = Learn.class;
		 try {
		 Constructor<Learn> con = class2.getConstructor();//获取该类模版中的无参构造器
		 //是根据哪个构造器创建的呢？---是由c.getConstructor()中的参数决定的
		 //注意：con.newInstance()其参数应该和c.getConstructor()参数对应
		 Learn learn2 = con.newInstance();//con通过newInstance()创建一个Learn的对象--调用了构造器
		 System.out.println("根据无参构造器创建对象"+learn2);
		 } catch (Exception e) {
		 // TODO Auto-generated catch block
		 e.printStackTrace();
		 }
		 
		//第三种方法---使用类模版得到有参构造器来创建对象
		 Class<Learn> class1 = Learn.class;//获取Class对象
		 try {
		 //获取该类模版中的指定参数Class对象的有参构造器
		 Constructor<Learn> con = class1.getConstructor(String.class,int.class);
		 //上面表明是根据第一个为String类型，第二个为int类型的有参构造器创建对象
		 Learn learn1 = con.newInstance("张三",18);
		 System.out.println("根据有参构造器创建对象"+learn1);
		 } catch (Exception e) {
		 // TODO Auto-generated catch block
		 e.printStackTrace();
		 }
		 

		 
		 
		// 通过反射操作方法
		 Class<Learn> class4 = Learn.class;//获取Class对象
		 Method[] methods = class4.getMethods();//得到所有的方法--得到公共的方法（包括父类的）
		 for (Method method : methods) {
		 System.out.println(method);
		 }

		 Class<Learn> class5 = Learn.class;
		 Method[] methods2 = class5.getDeclaredMethods();// 得到方法--得到本类中声明的方法（重写的）
		 for (Method method : methods2) {
		 System.out.println(method);
		 }

		 Class<Learn> class6 = Learn.class;//获取Class对象
		 try {
		 Learn lea = class6.newInstance();//创建一个对象
		 Method m = class6.getDeclaredMethod("use4", String.class);//通过反射掉用方法--调用公共方法
		 m.invoke(lea,"小明");
		 } catch (Exception e) {
		 e.printStackTrace();
		 }

		Class<Learn> class7 = Learn.class;// 获取Class对象
		try {
			Learn lea1 = class7.newInstance();// 创建一个对象
			Method m = class7.getDeclaredMethod("use1", new Class[] { String.class, int.class });
			m.setAccessible(true);//通过反射掉用方法--将访问权限解除,调用有访问权限要求的方法,private等
			m.invoke(lea1, new Object[] { "小明", 18 });
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
		
		
		//获得属性
		Class<Learn> c = Learn.class;// 获取Class对象
		try {
			Field f = c.getDeclaredField("name");
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}

		//得到私有属性，并修改值
		Learn l = new Learn("小明", 18);
		Class<?> c1 = l.getClass();
		try {
			Field f = c1.getDeclaredField("name");
			f.setAccessible(true);
			f.set(l, "小刚");
//			System.out.println(l);
		} catch (Exception e) {
			e.printStackTrace();
		} 
		
	}
}