反射

package com.jp;

import org.junit.Test;

/*
 * 
 * 反射：在程序运行时，动态的创建一个对象，并且调用该对象里面的相关方法
 * 
 */
public class ClassDemo {
	
	@Test
	public void testClass() throws ClassNotFoundException{
		
		//常用
		//1.方式一  Class.forName("类的全限定名") 获取字节码文件(Person.class)
		Class clazz1 = Class.forName("com.jp.Person");//类的全限定名
		System.out.println(clazz1.hashCode());
		
		//2.方式二 通过对象.getClass() 获取字节码文件
//		Person p = new Person();
//		Class clazz2 = p.getClass();
//		System.out.println(clazz2.hashCode());
		
		//3.方式三 通过类名.class获取
		Class clazz3 = Person.class;
		System.out.println(clazz3.hashCode());
	}
	
	@Test
	public void testClass2(){
//		Person p1 = new Person();
//		Person p2 = new Person();
//		Person p3 = new Person();
		
//		Class class1 = p1.getClass();
//		System.out.println(class1.hashCode());
//		
//		Class class2 = p2.getClass();
//		System.out.println(class1.hashCode());
//		
//		Class class3 = p3.getClass();
//		System.out.println(class1.hashCode());
	}
	
}

package com.jp;

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

import org.junit.Test;

/*
 * 
 * 反射：在程序运行时，动态的创建一个对象，并且调用该对象里面的相关方法
 * 
 */
public class ClassDemo2 {
	
	@Test
	public void testObject() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
		//Person p = new Person();
		//Person p = new Person("张三",18);
		//1.获取字节码文件(Person.class)
		Class clazz = Class.forName("com.jp.Person");
		
		//2.如何创建一个对象
		Object clazz2 = clazz.newInstance();//调用空参构造函数
		Person p2 = (Person) clazz2;
		System.out.println(p2);
	}
	
	
	@Test
	public void testObject2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		
		//1.获取字节码文件
		Class clazz = Class.forName("com.jp.Person");
		
		//2.获取Constructor对象，通过这个对象来调用相关的构造函数
		Constructor c = clazz.getConstructor(String.class, int.class);
		
		Object obj = c.newInstance("张三", 18);//Person p = new Person("张三", 18);
		Person p = (Person) obj;
//		System.out.println(p.name);
	}
	
	@Test
	public void testObject3() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		
		//1.获取字节码文件
		Class clazz = Class.forName("com.jp.Person");
		
		//2.获取Constructor对象，通过这个对象来调用相关的构造函数
		Constructor c = clazz.getConstructor(null);
		
		Object obj = c.newInstance();//Person p = new Person();
		Person p = (Person) obj;
//		System.out.println(p.name);
	}
	
	/*
	 *	通过反射怎么来创建一个对象呢？
	 *
	 * 	1.Class.forName("类的全限定名")  获取字节码文件
	 * 
	 * 	2.通过字节码文件对象获取对应Constructor对象
	 * 
	 * 	3.通过Constructor对象的newInstance(..)方法来调用对应的构造函数
	 * 
	 * 	这样就创建出来了一个对象
	 */	
	
	
	@Test
	public void testConstructors() throws ClassNotFoundException{
		//1.获取字节码文件
		Class clazz = Class.forName("com.jp.Person");
		Constructor[] constructors = clazz.getConstructors();
		for(Constructor c : constructors){
			System.out.println(c.getName());
		}
	}
	
}

package com.jp;

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

import org.junit.Test;

public class FieldDemo {

	@Test
	public void testField()
			throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException,
			IllegalAccessException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {

		// 1.拿到字节码文件
		Class clazz = Class.forName("com.jp.Person");
		Field[] fields = clazz.getFields();// 获取所有的字段对象
		for (Field f : fields) {
			// System.out.println(f.getName());
		}

		Field nameField = clazz.getField("name");

		// Object obj = clazz.newInstance();//调用空的构造函数

		// 获取空的构造函数对象
		Constructor c = clazz.getConstructor(null);
		Object obj = c.newInstance(null);// Person p = new Person();

		Person p = (Person) obj;

		nameField.set(p, "张三");// p.name = "张三";

		Object object = nameField.get(p);// 返回指定字段的值 p.name
		System.out.println(object);
	}

	@Test
	public void testField2() throws ClassNotFoundException {
		// 1.拿到字节码文件
		Class clazz = Class.forName("com.jp.Person");
//		Field[] fields = clazz.getFields();// 获取所有被public所修饰的字段对象
//		for (Field f : fields) {
//			 System.out.println(f.getName());
//		}
		
		Field[] fields = clazz.getDeclaredFields();//能够获取所有权限所修饰的字段对象
		for(Field f: fields){
			System.out.println(f.getName());
		}
		
	}

}

package com.jp;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Test;

public class MethodDemo {
	
	@Test
	public void testMethod1() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
//		Person p = new Person();
//		p.playBasketball();
		
		//1.获取字节码文件对象
		Class<Person> clazz = (Class<Person>) Class.forName("com.jp.Person");
		
//		Method[] methods = clazz.getMethods();
//		for(Method m : methods){
//			System.out.println(m.getName());
//		}
		Method method = clazz.getMethod("playBasketball", null);
		Person p = clazz.newInstance();
		method.invoke(p, null);
	}
	
	@Test
	public void testMethod2() throws Exception{
		//1.获取字节码文件对象
		Class<Person> clazz = (Class<Person>) Class.forName("com.jp.Person");
		Method m = clazz.getDeclaredMethod("playBasketball", null);	
		Person p = clazz.newInstance();
		//设置成可以访问的权限
		m.setAccessible(true);
		m.invoke(p, null);
		
		
	}
}

package com.jp;

public class Person {
	private String name;
	private int age;
	
	
	public Person() {
		super();
	}

	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 Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	private void playBasketball(){
		System.out.println("打篮球...");
	}
	
	private void playFootball(){
		System.out.println(name + ":" + age + "岁会踢足球");
	}
}

package com.jp;

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

import org.junit.Test;

public class ReflectDemo {
	@SuppressWarnings("unchecked")
	@Test
	public void testReflect() throws Exception{
//		Person p = new Person();
//		p.setName("张三");
//		p.setAge(18);
//		p.playFootball();
		
		
		//1.获取字节码文件对象
		Class<Person> clazz = (Class<Person>) Class.forName("com.jp.Person");
		Constructor<Person> c = clazz.getConstructor(null);
		Person p = c.newInstance(null);//Person p = new Person();
		
		Method setNameMethod = clazz.getMethod("setName", String.class);
		setNameMethod.invoke(p, "张三");//p.setName("张三");
		
		
		Method setAgeMethod = clazz.getMethod("setAge", int.class);
		setAgeMethod.invoke(p, 18);//p.setAge(18);
		
		
		Method m = clazz.getDeclaredMethod("playFootball", null);
		m.setAccessible(true);
		m.invoke(p, null);//p.playFootball();
		
		
		/*
		 * 
		 * 只要你告诉我类的全限定名(包名+类名)
		 * 参数，方法名
		 * 我就可以创建对象，为对象的属性赋值，并且调用该对象相关的方法
		 * 
		 * 
		 * 
		 * 
		 */
	}
}