5-7 反射获取字节码的三种方式，反射获取构造方法并且创建对象,通过反射获取成员变量对象

反射获取字节码的三种方式

Class: 对Class文件的一种描述

反射:
1.通过Class获取字节码文件对象，使用字节码文件对象来获取类的一些描述信息
2.成员变量 Field
3.成员方法 Method
4.构造方法 Constructor

Java文件 -编译-> 字节码文件 -运行-> JVM执行Class文件(类加载)

类加载
当我们执行java.exe命令,这个字节码文件会被加载到内存当中，同时还会为这个字节码文件创建一 个Class的实例
加载 连接 初始化

类加载器:
	根类加载器
	扩展类加载器..

Student.class ReflectDemo01.class

获取字节码文件对象的方式有三种

	1.Object的getClass方法
	
	2.通过数据类型的静态属性 class属性
		如果形参需要我们传入Class类型，那么我们可以考虑使用方式二
		public void show(Class c){}
		show(int.class)
	3.Class类中一个静态方法
	
		static Class<?> forName(String className) 
		方式三的好处: 因为传入的是一个字符串，而这个字符串可以通过配置文件配置
		满足了设计原则: 开闭原则  对扩展开放,对修改关闭
		配置文件: xml文件, properties文件

public class ReflectDemo01 {
	public static void main(String[] args) throws ClassNotFoundException, FileNotFoundException, IOException {
		Student s1 = new Student();
		Student s2 = new Student();
		Class<?> c1 = s1.getClass();
		Class<?> c2 = s2.getClass();
		
		System.out.println(s1 == s2);
		System.out.println(c1 == c2);
		
		Class<?> c3 = Student.class;
		System.out.println(c1 == c3);
		
		Properties pro = new Properties();
		pro.load(new FileReader("prop.txt"));
		String value = pro.getProperty("ClassName");
		System.out.println(value);
		Class<?> c4 = Class.forName(value);
		System.out.println(c1 == c4);
		
	}
}

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

	public Student(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;
	}

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

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}

反射获取构造方法并且创建对象

通过反射获取构造方法并且创建对象

•  通过反射获取字节码文件对象
  

•  通过字节码文件对象获取构造方法对象  Constructor
  

•  	Constructor<?>[] getConstructors() // 获取公有修饰的构造方法对象
  

•  	Constructor<?>[] getDeclaredConstructors() // 获取所有的构造方法对象
  

•  	Constructor<T> getConstructor(Class<?>... parameterTypes) 
  

•  	Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
  

public class ReflectDemo01 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
		Class<?> c = Class.forName("com.sxt.reflectdemo2.Student");
		Constructor<?>[] constructors = c.getConstructors();
		for (Constructor<?> constructor : constructors) {
			System.out.println(constructor);
		}
		System.out.println("----------------------------------");
		Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();
		for (Constructor<?> constructor : declaredConstructors) {
			System.out.println(constructor);
		}
		System.out.println("----------------------------------");
		// 获取所有的构造方法在开发中有意义? 没有什么实际意义，所以我们来获取单个构造方法
		// 获取无参构造方法
//		c.getConstructor(Class<?>... parameterTypes  Class  class)
		Constructor<?> constructor = c.getConstructor();
		System.out.println(constructor);
		Constructor<?> constructor2 = c.getConstructor(String.class,int.class);
		System.out.println(constructor2);
		// 获取私有构造方法
		// java.lang.NoSuchMethodException
//		Constructor<?> constructor3 = c.getConstructor(String.class); 
//		System.out.println(constructor3);
		Constructor<?> constructor3 = c.getDeclaredConstructor(String.class);
		System.out.println(constructor3);
	}
}


/*
 * 通过反射获取构造方法对象并且创建对象
 * 
 * 反射之前的做法:
 * 	Student s = new Student();
 * 
 * 反射之后:
 * 		1.获取字节码文件对象
 * 		2.通过字节码文件对象获取构造方法对象 
 * 		3.通过构造方法对象创建对象 
 * 				 T newInstance(Object... initargs) 
 */
public class ReflectDemo02 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
			InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException,
			FileNotFoundException, IOException {
		Properties prop = new Properties();
		prop.load(new FileReader("prop.txt"));
		String value = prop.getProperty("ClassName");
		Class<?> c = Class.forName(value);
		Constructor<?> con = c.getConstructor();

		Object obj = con.newInstance();
		System.out.println(obj);

		Student student = (Student) obj;
		System.out.println(student.getName());

		// 我想要调用带全参数的怎么办
		Constructor<?> constructor = c.getConstructor(String.class, int.class);
		Object obj2 = constructor.newInstance("隔壁老王", 50);
		System.out.println(obj2);

		// 我想获取私有构造方法并且造对象
		// java.lang.NoSuchMethodException:
		// Constructor<?> constructor2 = c.getConstructor(String.class);
		Constructor<?> constructor2 = c.getDeclaredConstructor(String.class);
		// java.lang.IllegalAccessException
		// 暴力访问
		constructor2.setAccessible(true);
		Object obj3 = constructor2.newInstance("隔壁老李");
		System.out.println(obj3);
	}
}

通过反射获取成员变量对象

通过反射获取成员变量对象

• Field
• Field[] getFields() 获取公有修饰的成员变量对象
• Field[] getDeclaredFields() 获取所有成员变量对象
• Field getField(String name) 获取指定的公共成员变量对象
• Field getDeclaredField(String name) 获取指定任意成员变量对象
• Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。

public class ReflectDemo01 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
		Class<?> c = Class.forName("com.sxt.reflectdemo3.Student");
		
		Field[] fields = c.getFields();
		for (Field field : fields) {
			System.out.println(field);
		}
		
		System.out.println("---------------");
		Field[] declaredFields = c.getDeclaredFields();
		for (Field field : declaredFields) {
			System.out.println(field);
		}
		
		System.out.println("---------------");
		// declaredFields
		Field field = c.getField("address");
		System.out.println(field);
		System.out.println("---------------");
		Field field2 = c.getDeclaredField("name");
		System.out.println(field2);
		
	}
}


public class ReflectDemo02 {
	public static void main(String[] args) throws Exception {
		Class<?> c = Class.forName("com.sxt.reflectdemo3.Student");
		// 给sex属性赋值，值为女
		Field sexFiled = c.getDeclaredField("sex");
		System.out.println(sexFiled);
		// 反射之前 Student s = new Student(); s.sex = "女";
		// 反射之后
		Constructor<?> con = c.getDeclaredConstructor();
		Object obj = con.newInstance();
		//  Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。 
		sexFiled.set(obj, "女");
		System.out.println(obj);
		
		Field nameField = c.getDeclaredField("name");
		nameField.setAccessible(true);
		nameField.set(obj, "隔壁老张");
		System.out.println(obj);
		System.out.println(nameField.get(obj));
	}
}