Java反射基本概述及使用方法

反射概述：
        反射机制就是在运行状态中，对任意一个类，都能够知道这个类的所有属性及
    方法；对任意一个对象，都能调用任意的方法或属性。这种动态获取信息及动态调
    用对象方法的功能称作Java语言的反射机制。
就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

获取class文件的三种方式
1.通过Object类的getClass()方法
Person p = new Person(); Class c1 = p.getClass(); 
2.数据类型的静态属性class
Class c2 = Person.class;
3.Class类中的静态方法
public static Class forName(String className )
Class c3 = Class.forName("day27_ReflectDemo1.Person");//抛异常
注意：c1==c2==c3;//true,因为是字节码对象，都是Person类的Class文件对象。
开发：使用第三种
因为第三种需要的是字符串，字符串更改方便，只需在配置文件中修改。

通过字节码文件对象使用成员变量，构造方法，成员方法
成员变量： Field
 public Field[] getFields();获取所有公共成员变量
 public Field[] getDeclaredFields(); 获取所有成员变量
 public Field getField(String name); 获取单个成员变量
 私有： public void setAccessible(boolean flag)

构造方法： Constructor
 public Constructor[] getConstructor();获取所有公共构造方法
 public Constructor[] getDeclaredConstructor(); 获取所有构造方法
 public Constructor<T> getConstructor(Class<T>... parameterType);获取单个构造方法
私有构造： Constructor con3 = c.getDeclaredConstructor(String.class);

成员方法：Method
 public Method[] getMethod();获取自己和父类的所有公共方法
 public Method[] getDeclaredMethod(); 获取自己所有方法
 public Method getMethod(String name,Class<?>... parameterTypes);获取单个方法

    私有方法： getMethod con3 = c.getDeclaredgetMethod(String.class);

代码举例：

    定义一个Person类，用来当做反射的类

package day27_ReflectDemo1;

public class Person {
	private String name;
	int age;
	public String address;
	
	public Person() {}
	
	private Person(String name) {
		this.name = name;
	}
	
	Person(String name,int age){
		this.name=name;
		this.age=age;
	}

	public Person(String name, int age, String address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}
	
	public void show() {
		System.out.println("show");
	}
	
	public void method(String s) {
		System.out.println("method"+s);
	}
	
	public String getString(String s,int i) {
		return s+"---"+i;
	}
	
	private void function() {
		System.out.println("function");
	}

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

    反射使用构造方法

package day27_ReflectDemo2;

import java.lang.reflect.Constructor;
//反射使用构造方法
public class ReflectDemo {
	public static void main(String[] args) throws Exception{
		Class c = Class.forName("day27_ReflectDemo1.Person");
		//无参构造	 public Person()
		Constructor con1 = c.getConstructor();
		//使用Constructor对象表示的构造方法创建新的实例
		//相当于 Person p = new Person();
		Object obj1 = con1.newInstance();
		System.out.println(obj1);
		
		//带参构造	 public Person(String name, int age, String address)
		Constructor con2 = c.getConstructor(String.class,int.class,String.class);
		//使用Constructor对象表示的构造方法创建新的实例,并用指定初始化值初始化对象
		//相当于 Person p = new Person("Mike",22,"USA");
		Object obj2 = con2.newInstance("Mike",22,"USA");
		System.out.println(obj2);
		
		//私有构造	 private Person(String name)
		//NoSuchMethodException,这个方法只能访问公共构造方法
		//Constructor con3 = c.getConstructor(String.class);
		Constructor con3 = c.getDeclaredConstructor(String.class);
		//IllegalAccessException 非法访问异常,因为是私有的
		//暴力访问，public void setAccessible(boolean flag)
		con3.setAccessible(true); //值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
		Object obj3 = con3.newInstance("Demon");
		System.out.println(obj3); 

	}
}

    反射使用成员变量

package day27_ReflectDemo3;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
//反射使用成员变量
public class ReflectDemo {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		//创建Person类的字节码对象，无参构造创建新实例。
		Class c = Class.forName("day27_ReflectDemo1.Person");
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		System.out.println(obj);
		
		//获取所有公共成员变量
		//Field[] fields1 = c.getFields();
		//获取所有成员变量
		//Field[] fields2 = c.getDeclaredFields();
		
		//获取address并对其赋值 public 
		Field addressField = c.getField("address");
		//public void set(Object obj,Object value);
		//给obj对象的addressField字节码字段赋值value
		addressField.set(obj, "China");
		System.out.println(obj);
		
		//获取name并对其赋值 private
		//Field ageField = c.getField("name"); NoSuchFieldException
		Field nameField = c.getDeclaredField("name");
		//IllegalAccessException
		nameField.setAccessible(true);
		nameField.set(obj, "Ace");
		System.out.println(obj);
		
		//获取age并对其赋值 default
		Field ageField = c.getDeclaredField("age");
		ageField.setAccessible(true);
		ageField.set(obj, 20);
		System.out.println(obj);
	}

}

    反射使用成员方法

package day27_ReflectDemo4;

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

//反射使用成员方法
public class ReflectDemo {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		Class c = Class.forName("day27_ReflectDemo1.Person");
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		
		//获取所有自己和父类公有方法
//		Method[] methods1 = c.getMethods();
		//获取所有自己的方法
//		Method[] methods2 = c.getDeclaredMethods();
//		for(Method m : methods2) {
//			System.out.println(m);
//		}
		
		//调用Person中show方法 public void show()
		//public Method getMethod(String name,Class<?>... parameterTypes) 方法名，参数类型的class。
		Method show = c.getMethod("show");
		//public Object invoke(Object obj,Object... args) 对象，
		show.invoke(obj);
		
		//调用Person中method方法 public void method(String s)
		System.out.println("----------------");
		Method method = c.getMethod("method", String.class);
		method.invoke(obj, "hello"); 
		
		//调用Person中getString方法 public String getString(String name,int age)
		System.out.println("----------------");
		Method getString = c.getMethod("getString", String.class,int.class);
		//有返回值类型
		//Object objString = getString.invoke(obj, "hello",100); 
		String str = (String)getString.invoke(obj, "hello",100); 
		System.out.println(str);
		
		//调用Person中function方法 private void function()
		System.out.println("----------------");
		Method function = c.getDeclaredMethod("function");
		function.setAccessible(true);
		function.invoke(obj);
	}

}