Java基础之反射

什么是反射：

        反射就是通过获取class字节码文件对象或者Class的类对象，获取该字节码文件对象中的成员变量，构造方法和成员方法；

        反射中的类：
                Field：简称成员变量；
                        Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限（反射的字段可能是一个类（静态）字段或实例字段）；
                Constructor：简称构造方法；
                        提供关于类的单个构造方法的信息以及对它的访问权限；
                Method：简称成员方法；
                         提供类或接口上单独某个方法（以及如何访问该方法）的信息；

        三种方式来获取这个class字节码文件对象：
                1> Object中的getClass() ；
                2> 任何数据类型的静态属性class；
                3> Class类中的方法：forName("类路径")；

        举例：

public class ReflectDemo {
	
	public static void main(String[] args) throws ClassNotFoundException {
		
		//方式1:
		//如何获取class字节码文件对象
		//创建Person对象
		Person p1 = new Person() ;
		Class c1 = p1.getClass() ;  //获取class字节码文件对象 
		
		Person p2 = new Person();
		Class c2 = p2.getClass() ;
		System.out.println(p1==p2);//false
		System.out.println(c1==c2);//true
		
		System.out.println("------------------");
		
		//方式2:
		//数据类型的静态属性class
		Class c3 = Person.class ;
		System.out.println(c3==c2);
		
		//方式3:
		//开发中常用使用第三种方式
		//参数:类路径:包名.类名
		Class c4 = Class.forName("org.westos_01.Person") ;
		System.out.println(c4==c2);
		
	}
}

        通过字节码文件对象获取构造方法并使用：
        举例：

public class ReflectDemo {
	
	public static void main(String[] args) throws Exception {
		
		//1)先获取Person类的字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ;
		
		//2)//public Constructor[] getConstructors()
		//Class 对象所表示的类的所有公共构造方法
		Constructor[] cons = c.getConstructors() ;
		for(Constructor con : cons) {
			System.out.println(con);
		}
		
		System.out.println("-----------------------------------");
		
		//public Constructor[] getDeclaredConstructors():获取当前字节码文件对象中的所有的构造方法
		Constructor[] cons1 = c.getDeclaredConstructors() ;
		for(Constructor con : cons1) {
			System.out.println(con);
		}
		
		System.out.println("-----------------------------");
		
		//如何获取单个的构造方法
		//public Constructor getConstructor(Class<?>... parameterTypes)
		//如果是无参的,不用写;如果是有参的,getContStructor方法中的参数是当前参数类型的静态属性class
		Constructor con = c.getConstructor() ;  //获取无参构造
		System.out.println(con);
		//public org.westos_01.Person()
		
		System.out.println("----------------------------");
		
		//获取当前构造的对象
		//public T newInstance(Object... initargs):initrgs:实际参数
		//表示用当前的构造方法来创建该构造方法声明类的新实例，并用指定的初始化参数初始化该实例
		Object obj = con.newInstance();
		System.out.println(obj);	//Person [name=null, age=0, address=null]


	}
}

        通过反射获取构造方法并使用：
        举例：

public class ReflectDemo2 {
	
	public static void main(String[] args) throws Exception {
		
		//1)获取Person类的字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ;
		
		//2)获取单个构造方法(公共的,带三个参数的)
		//public Constructor<T> getConstructor(Class<?>... parameterTypes)
		Constructor con = c.getConstructor(String.class,int.class,String.class) ;
		System.out.println(con);
		System.out.println("----------------------");
		
		//3)创建构造方法表示的该类的实例对象
		Object obj = con.newInstance("高圆圆",27,"户县") ;
		System.out.println(obj);
		//Person [name=高圆圆, age=27, address=户县]
		
	}
}

        通过反射为有参构造的初始化：
        举例：

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
		//获取字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ; 
		
		//现在获取的那个构造方法是私有的,如果不取消java语言访问检查,那么将报错
		//public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
		Constructor con = c.getDeclaredConstructor(String.class) ;
		System.out.println(con);  //输出这个私有的方法;
		
		//创建该类的实例,通过con对象创建
		//public void setAccessible(boolean flag)
		//值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查
		con.setAccessible(true);
		Object obj = con.newInstance("高圆圆") ;
		System.out.println(obj);
		//Person [name=高圆圆, age=0, address=null]
	}
}

        通过反射获取成员变量，并使用：
        举例：

public class ReflectDemo {

	public static void main(String[] args) throws Exception {
		
		//获取Person类的字节码文件对象
		Class c = Class.forName("org.westos_01.Person");
		
		//获取当前字节码文件对象中的所有的公共的成员变量
		//public Field[] getDeclaredFields():获当前字节码文件对象中所有的字段
		//public Field[] getFields():返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段
		Field[] fields = c.getFields() ;//共有的成员变量;
		for(Field field:fields) {
			System.out.println(field);
		}
		
		System.out.println("-----------------------------");
		
		Field[] fields1 = c.getDeclaredFields();  //全部成员变量;
		for(Field field:fields1) {
			System.out.println(field);
		}
		
		System.out.println("-----------------------------");
		
		/**
		 * 之前要给Person类中的address赋值
		 * Person p =new Person() ;
		 * p.address= "北京" ;
		 */
		//获取构造方法(Constructor)对象
		Constructor con = c.getConstructor() ;
		Object obj = con.newInstance() ;
		System.out.println(obj);
		
		System.out.println("-----------------------------");
		
		//获取Field类对象
		//public Field getField(String name):获取的是公共的字段
		//参数name:表示当前字段的名称
		Field addressField = c.getField("address") ;
		
		//public void set(Object obj,Object value)
		//参数1:表示给哪个对象设置当前字段的值
		//参数2:表示给当前获取的哪个Field对象的字段设置一个新的值
		addressField.set(obj, "北京");
		System.out.println(obj);
		
		System.out.println("-------------------------");
		
		//给name字段赋值
		//java.lang.NoSuchFieldException: name
		//name是私有的,必须指定方法获取
		//public Field getDeclaredField(String name):指定的字段
		Field nameField = c.getDeclaredField("name") ;
		//Field nameField1 = c.getField("name") ;  //这里会有问题,"name"为私有变量,所以这里只能用getDeclareField()方法;
		//因为是私有,应该取消Java语言访问检查
		nameField.setAccessible(true);
		nameField.set(obj, "高圆圆");
		System.out.println(obj);
		
		System.out.println("---------------------------");
		
		//因为age没有使用public修饰,所以不能使用getField()方法;
		Field ageField = c.getDeclaredField("age") ;
		ageField.setAccessible(true);
		ageField.set(obj,27);
		System.out.println(obj);
		

	}
}

        通过反射获取成员方法并使用：
        举例：

public class MethodReflectDemo {

	public static void main(String[] args)throws Exception {
		
		//通过反射获取Pereson字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ;
		
		//获取当前字节码文件对象中的所有的公共的成员方法(包括父类中的)
		//public Method[] getMethods():获取共有的成员方法
		//public Method[] getDeclaredMethods():所有的成员方法
		//Method[] methods = c.getMethods() ;//返回共有的方法的数组
		Method[] methods = c.getDeclaredMethods() ;//返回所有方法的数组
		for(Method method:methods) {
			System.out.println(method);
		}
		
		System.out.println("---------------------");
		
		/***
		 * 之前调用Person类中的show()
		 * Person p = new Person() ;
		 * p.show() ;
		 */
		//获取Constructor对象
		Constructor con = c.getConstructor() ;
		Object obj = con.newInstance() ;
		
		//获取单个的成员方法,Method,并调用show方法
		//public Method getMethod(String name, Class... parameterTypes)
		//返回一个Method对象
		//参数1:表示方法名
		//参数2:表示当前方法的参数数据类型的静态class属性
		Method m1 = c.getMethod("show") ;
		//obj.m1() ;
		
		//public Object invoke(Object obj, Object... args)
		//对带有指定参数的指定对象调用由此 Method 对象表示的底层方法
		//参数1:指定的哪个对象上调用底层invoke(),
		//参数2:表示的调用那个方法所传递的实际参数
		m1.invoke(obj) ; //在obj对象上调用m1对象所表示的成员方法
		
		System.out.println("--------------------");
		
		/**
		 * public void method(String s) {
				System.out.println("method"+s);
			}
		 */
		Method m2 = c.getMethod("method",String.class) ;
		
		//调用底层方法
		m2.invoke(obj, "hello") ;
		
		System.out.println("-----------------------");
		
		/**
		 * public String getString(String s,int i) {
					return s+i ;
				}
		 */
		Method m3 = c.getMethod("getString",String.class,int.class) ;
		//调用Method类中的invoke()方法,调用底层哪个字节码文件对象的对应的成员方法
		Object objgetString = m3.invoke(obj, "javaweb",100) ;
		System.out.println(objgetString);
		
		System.out.println("---------------------------");
		
		/**
		 * //私有的
			private void function() {
				System.out.println("function Preson");
				}		
		 */
		//调用私有的成员方法
		//public Method getDeclaredMethod(String name , Class<?>... parameterTypes)
		Method m4= c.getDeclaredMethod("function") ;
		
		//取消Java语言访问检查
		m4.setAccessible(true);
		//调用obj 对象中的底层的function()方法
		m4.invoke(obj) ;
	}
}

        综合练习：

package org.westos_test1;

import java.lang.reflect.Method;
import java.util.ArrayList;

//我给你ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢?
public class ArrayListDemo {
	
	public static void main(String[] args) throws Exception{
		
		ArrayList<Integer>  array = new ArrayList<Integer>() ;
		
		//给集合中添加元素
		array.add(100) ;
		//array.add("hello") ;
		
		//可以通过Class获取arrray对象所在的字节码文件对象
		Class c = array.getClass() ;
		
		//可以通过字节码文件对象可以调用底层的add() 
		//先通过Class类的对象获取Method对象
		//公共的有参成员方法:add(Object obj)
		Method m = c.getMethod("add",Object.class) ;
		
		//通过调用array对象中的底层的哪个invoke
		//public Object invoke(Object obj, Object... args)
		//obj - 从中调用底层方法的对象
		//args - 用于方法调用的参数 
		m.invoke(array,"hello") ;
		m.invoke(array,"world") ;
		m.invoke(array,"java") ;
		
		System.out.println(array);
	}
}