反射机制

2018-07-04

概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

换句话说:

指的是可以于运行时加载,探知和使用编译期间完全未知的类.
反射（Reflection）是java被视为动态语言的一个关键特性;
反射机制指的是程序在运行时能够获取任何类的内部所有信息;
加载完类之后, 在堆内存中会产生一个Class类型的对象(一个类只有一个Class对象), 这个对象包含了完整的类的结构信息,而且这个Class对象就像一面镜子,透过这个镜子看到类的结构,所以被称之为:反射。
说白了反射就是把java类中的各种成分映射成一个个的Java对象

JVM类加载过程

反射与class对象息息相关。
Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

获取Class对象的三种方式

对象的getClass()方法

getClass(

1	Class class = (new Object()).getClass();

类的.class(最安全/性能最好)属性

.class

1	Class class = Object.class;

运用Class.forName(String className)动态加载类,className需要是类的全限定名(最常用)

Class.forName

1	Class class = Class.forName("com.object.Object");

创建对象

创建对象，利用newInstance()

创建对象

1 2	Class c = Class.forName("Employee"); //创建此Class 对象所表示的类的一个新实例 Object o = c.newInstance(); //调用了Employee的无参数构造方法.

以上的代码等同于

创建对象

1	Employee employee = new Employee(); //调用了Employee的无参数构造方法.

newInstance():

弱类型。低效率。只能调用无参构造，即默认的构造函数

抛出所有由被调用构造函数抛出的异常

要求被调用的构造函数是可见的，也即必须是public类型的。

new():

强类型。相对高效。能调用任何public构造。

创建对象，利用getConstructor() 和 getDeclaredConstructor()

创建对象

class Solution {

    private String str;
    private int num;

      public Solution() {

     }

      public Solution(String str, int num) {
         this.str = str;
         this.num = num;
    }

     public Solution(String str) {
         this.str = str;
     }

     public static void main(String[] args) throws Exception {

         Class[] classes = new Class[] { String.class, int.class };
         Solution solution = Solution.class.getConstructor(classes).newInstance("hello1", 10);
         System.out.println(solution.str); // hello1

         Solution solution2 = solution.getClass().getDeclaredConstructor(String.class).newInstance("hello2");
         System.out.println(solution2.str); // hello2

         Solution solution3 = (Solution) Class.forName("Solution").getConstructor().newInstance(); // 无参也可用getConstructor()
         System.out.println(solution3 instanceof Solution); // true
     }

 }

运行结果：

创建对象

1
2
3

hello1
hello2
true

getConstructor()和getDeclaredConstructor()区别

getDeclaredConstructor(Class<?>… parameterTypes)

这个方法会返回制定参数类型的所有构造器，包括public的和非public的，当然也包括private的。

getDeclaredConstructors()的返回结果就没有参数类型的过滤了。

getConstructor(Class<?>… parameterTypes)

这个方法返回的是上面那个方法返回结果的子集，只返回制定参数类型访问权限是public的构造器。

getConstructors()的返回结果同样也没有参数类型的过滤。

Class类

Class对象概述

Class其实就是类的类型
字符串类型就是String，整形类型就是Integer，String和Integer类型就是Class

常用的Class方法

方法名	释义
getName()	返回String形式的该类的名称
getClassLoader()	返回该Class对象对应的类的类加载器
getSuperClass()	返回某子类所对应的直接父类所对应的Class对象
getComponentType()	如果当前类表示一个数组，则返回表示该数组组件的 Class 对象，否则返回 null
getConstructor(Class[])	返回当前 Class 对象表示的类的指定的公有构造子对象
getConstructors()	返回当前 Class 对象表示的类的所有公有构造子对象数组
getDeclaredConstructor(Class[])	返回当前 Class 对象表示的类的指定已说明的一个构造子对象
getDeclaredConstructors()	返回当前 Class 对象表示的类的所有已说明的构造子对象数组
getDeclaredField(String)	返回当前 Class 对象表示的类或接口的指定已说明的一个域对象
getDeclaredFields()	返回当前 Class 对象表示的类或接口的所有已说明的域对象数组
getDeclaredMethod(String, Class[])	返回当前 Class 对象表示的类或接口的指定已说明的一个方法对象
getDeclaredMethods()	返回 Class 对象表示的类或接口的所有已说明的方法数组
getField(String)	返回当前 Class 对象表示的类或接口的指定的公有成员域对象
getFields()	返回当前 Class 对象表示的类或接口的所有可访问的公有域对象数组
getInterfaces()	返回当前对象表示的类或接口实现的接口
getMethod(String, Class[])	返回当前 Class 对象表示的类或接口的指定的公有成员方法对象
getMethods()	返回当前 Class 对象表示的类或接口的所有公有成员方法对象数组，包括已声明的和从父类继承的方法
getModifiers()	返回该类或接口的 Java 语言修改器代码
getResource(String)	按指定名查找资源
getResourceAsStream(String)	用给定名查找资源
getSigners()	获取类标记
isArray()	判定此Class对象所对应的是否是一个数组对象
isInstance(Object)	此方法是 Java 语言 instanceof 操作的动态等价方法
isInterface()	判定指定的 Class 对象是否表示一个接口类型
isPrimitive()	判定指定的 Class 对象是否表示一个 Java 的基类型
isAssignableFrom(Class)	判定 Class 对象表示的类或接口是否同参数指定的 Class 表示的类或接口相同，或是其父类
newInstance()	根据某个Class对象产生其对应类的实例，它调用的是此类的默认构造方法(没有默认无参构造器会报错)
toString()	将对象转换为字符串

Field类

Field对象概述

Java.lang.reflect.Field类，是用于表示类中、接口中属性对象的类。
可以操作类中私有，以及公有等全部属性和属性的信息。

Field对象常用方法

方法名	释义
getName()	获得属性名称
getType()	获得属性类型
get(Object obj)	获得obj对象中这个属性的值
set(Object obj,Object value)	向obj对象中这个属性赋值value
setAccessible()	启用/禁用访问控制权限

Method类

Method对象概述

java.lang.reflect.Method类，提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。
代表类中的一个方法的定义，一个Method由修饰符，返回值，方法名称，参数列表组合而成。

Method对象常用方法

方法名	释义
getName()	获得方法名
getModifiers()	获得修饰符
getReturnTypes()	返回值类型。返回class
getParameterTypes()	返回Class[]，参数类型的数组
invoke(Object obj,Object..args)	对带有指定参数的指定对象调用由此 Method 对象表示的底层方法

示例代码

通过一个对象获得完整的包名和类名

get

package Reflect;
 
/**
 * 通过一个对象获得完整的包名和类名
 * */
class Demo{
    //other codes...
}
 
class Hello{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
}

运行结果

end

1	Reflect.Demo

实例化Class类对象

实例化

package Reflect;
class Demo{
    //other codes...
}
 
class Hello{
    public static void main(String[] args) {
        Class<?> demo1=null;
        Class<?> demo2=null;
        Class<?> demo3=null;
        try{
            //一般尽量采用这种形式
            demo1=Class.forName("Reflect.Demo");
        }catch(Exception e){
            e.printStackTrace();
        }
        demo2=new Demo().getClass();
        demo3=Demo.class;
         
        System.out.println("类名称   "+demo1.getName());
        System.out.println("类名称   "+demo2.getName());
        System.out.println("类名称   "+demo3.getName());
         
    }
}

运行结果

end

类名称   Reflect.Demo

类名称   Reflect.Demo

类名称   Reflect.Demo

获取成员变量并调用

构造函数


package fanshe.field;
import java.lang.reflect.Field;

 
public class Student {
	public Student(){
		
	}
	//**********字段*************//
	public String name;
	protected int age;
	char sex;
	private String phoneNum;
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex
				+ ", phoneNum=" + phoneNum + "]";
	}
}
	
	

/*
 * 获取成员变量并调用：
 * 
 * 1.批量的
 * 		1).Field[] getFields():获取所有的"公有字段"
 * 		2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
 * 2.获取单个的：
 * 		1).public Field getField(String fieldName):获取某个"公有的"字段；
 * 		2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
 * 
 * 	 设置字段的值：
 * 		Field --> public void set(Object obj,Object value):
 * 					参数说明：
 * 					1.obj:要设置的字段所在的对象；
 * 					2.value:要为字段设置的值；
 * 
 */
public class Fields {
 
		public static void main(String[] args) throws Exception {
			//1.获取Class对象
			Class stuClass = Class.forName("fanshe.field.Student");
			//2.获取字段
			System.out.println("************获取所有公有的字段********************");
			Field[] fieldArray = stuClass.getFields();
			for(Field f : fieldArray){
				System.out.println(f);
			}
			System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
			fieldArray = stuClass.getDeclaredFields();
			for(Field f : fieldArray){
				System.out.println(f);
			}
			System.out.println("*************获取公有字段**并调用***********************************");
			Field f = stuClass.getField("name");
			System.out.println(f);
			//获取一个对象
			Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
			//为字段设置值
			f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
			//验证
			Student stu = (Student)obj;
			System.out.println("验证姓名：" + stu.name);
			
			
			System.out.println("**************获取私有字段****并调用********************************");
			f = stuClass.getDeclaredField("phoneNum");
			System.out.println(f);
			f.setAccessible(true);//暴力反射，解除私有限定
			f.set(obj, "18888889999");
			System.out.println("验证电话：" + stu);
			
		}
	}

运行结果

end


************获取所有公有的字段********************
public java.lang.String day7_02_反射.fanshe.field.Student.name
************获取所有的字段(包括私有、受保护、默认的)********************
public java.lang.String day7_02_反射.fanshe.field.Student.name
protected int day7_02_反射.fanshe.field.Student.age
char day7_02_反射.fanshe.field.Student.sex
private java.lang.String day7_02_反射.fanshe.field.Student.phoneNum
*************获取公有字段**并调用***********************************
public java.lang.String day7_02_反射.fanshe.field.Student.name
验证姓名：刘德华
**************获取私有字段****并调用********************************
private java.lang.String day7_02_反射.fanshe.field.Student.phoneNum
验证电话：Student [name=刘德华, age=0, sex= , phoneNum=18888889999]

通过Class调用其他类中的构造函数

构造函数

package Reflect;
 
import java.lang.reflect.Constructor;
 
class Person{
     
    public Person() {
         
    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        this.age=age;
    }
    public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }
    private String name;
    private int age;
}
 
class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per1=null;
        Person per2=null;
        Person per3=null;
        Person per4=null;
        //取得全部的构造函数
        Constructor<?> cons[]=demo.getConstructors();
        try{
            per1=(Person)cons[0].newInstance();
            per2=(Person)cons[1].newInstance("Rollen");
            per3=(Person)cons[2].newInstance(20);
            per4=(Person)cons[3].newInstance("Rollen",20);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);
    }
}

运行结果

end

[null  0]

[Rollen  0]

[null  20]

[Rollen  20]

返回一个类实现的接口

接口

package Reflect;
 
interface China{
    public static final String name="Rollen";
    public static  int age=20;
    public void sayChina();
    public void sayHello(String name, int age);
}
 
class Person implements China{
    public Person() {
         
    }
    public Person(String sex){
        this.sex=sex;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public void sayChina(){
        System.out.println("hello ,china");
    }
    @Override
    public void sayHello(String name, int age){
        System.out.println(name+"  "+age);
    }
    private String sex;
}
 
class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        //保存所有的接口
        Class<?> intes[]=demo.getInterfaces();
        for (int i = 0; i < intes.length; i++) {
            System.out.println("实现的接口   "+intes[i].getName());
        }
    }
}

运行结果

end

1	实现的接口 Reflect.China

取得其他类中的父类

父类

package Reflect;

interface China{
     //同上
}
 
class Person implements China{
     //同上
}
class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        //取得父类
        Class<?> temp=demo.getSuperclass();
        System.out.println("继承的父类为：   "+temp.getName());
    }
}

运行结果

end

1	继承的父类为： java.lang.Object

获得其他类中的全部构造函数

全部构造函数

package Reflect;
import java.lang.reflect.*;

interface China{
     //同上
}
 
class Person implements China{
     //同上
}
class Hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Constructor<?>cons[]=demo.getConstructors();
        for (int i = 0; i < cons.length; i++) {
            Class<?> p[]=cons[i].getParameterTypes();
            System.out.print("构造方法：  ");
            int mo=cons[i].getModifiers();
            System.out.print(Modifier.toString(mo)+" ");
            System.out.print(cons[i].getName());
            System.out.print("(");
            for(int j=0;j<p.length;++j){
                System.out.print(p[j].getName()+" arg"+i);
                if(j<p.length-1){
                    System.out.print(",");
                }
            }
            System.out.println("){}");
        }
    }
}

运行结果

end

1
2
3

构造方法：  public Reflect.Person(){}

构造方法：  public Reflect.Person(java.lang.String arg1){}

调用其他类中的方法

方法

package Reflect;

interface China{
     //同上
}
 
class Person implements China{
     //同上
}
class Hello {
    public static void main(String[] args) {
        Class<?> demo = null;
        try {
            demo = Class.forName("Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            //调用Person类中的sayChina方法
            Method method=demo.getMethod("sayChina");
            method.invoke(demo.newInstance());
            //调用Person的sayHello方法
            method=demo.getMethod("sayHello", String.class,int.class);
            method.invoke(demo.newInstance(),"Rollen",20);
             
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果

end

1
2
3

hello ,china

Rollen  20

调用其他类的set和get方法

set和get方法

package Reflect;

interface China{
     //同上
}
 
class Person implements China{
     //同上
}

class Hello {
    public static void main(String[] args) {
        Class<?> demo = null;
        Object obj=null;
        try {
            demo = Class.forName("Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
         obj=demo.newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        setter(obj,"Sex","男",String.class);
        getter(obj,"Sex");
    }
 
    /**
     * @param obj
     *            操作的对象
     * @param att
     *            操作的属性
     * */
    public static void getter(Object obj, String att) {
        try {
            Method method = obj.getClass().getMethod("get" + att);
            System.out.println(method.invoke(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @param obj
     *            操作的对象
     * @param att
     *            操作的属性
     * @param value
     *            设置的值
     * @param type
     *            参数的属性
     * */
    public static void setter(Object obj, String att, Object value,
            Class<?> type) {
        try {
            Method method = obj.getClass().getMethod("set" + att, type);
            method.invoke(obj, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}// end class

运行结果

end

男

通过反射取得并修改数组的信息

修改

import java.lang.reflect.*;
class Hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5};
        Class<?>demo=temp.getClass().getComponentType();
        System.out.println("数组类型： "+demo.getName());
        System.out.println("数组长度  "+Array.getLength(temp));
        System.out.println("数组的第一个元素: "+Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改之后数组第一个元素为： "+Array.get(temp, 0));
    }
}

运行结果

end

数组类型： int

数组长度  5

数组的第一个元素: 1

修改之后数组第一个元素为： 100

通过反射修改数组大小

修改

class Hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5,6,7,8,9};
        int[] newTemp=(int[])arrayInc(temp,15);
        print(newTemp);
        System.out.println("=====================");
        String[] atr={"a","b","c"};
        String[] str1=(String[])arrayInc(atr,8);
        print(str1);
    }
     
    /**
     * 修改数组大小
     * */
    public static Object arrayInc(Object obj,int len){
        Class<?>arr=obj.getClass().getComponentType();
        Object newArr=Array.newInstance(arr, len);
        int co=Array.getLength(obj);
        System.arraycopy(obj, 0, newArr, 0, co);
        return newArr;
    }
    /**
     * 打印
     * */
    public static void print(Object obj){
        Class<?>c=obj.getClass();
        if(!c.isArray()){
            return;
        }
        System.out.println("数组长度为： "+Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i)+" ");
        }
    }
}

运行结果

end

数组长度为： 15

1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================

数组长度为： 8

a b c null null null null null

反射main方法

main

package fanshe.main;
import java.lang.reflect.Method;

public class Student {
 
	public static void main(String[] args) {
		System.out.println("main方法执行了。。。");
	}
}

public class Main {
	
	public static void main(String[] args) {
		try {
			//1、获取Student对象的字节码
			Class clazz = Class.forName("fanshe.main.Student");
			
			//2、获取main方法
			 Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
			//3、调用main方法
			// methodMain.invoke(null, new String[]{"a","b","c"});
			 //第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
			 //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
			 methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
			// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
	}
}

运行结果

end

1	main方法执行了。。。

通过反射运行配置文件内容

配置文件（pro.txt）

配置文件

1 2	className = cn.fanshe.Student methodName = show

配置


import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;

public class Student {
	public void show(){
		System.out.println("is show()");
	}
}

/*
 * 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改
 * 我们只需要将新类发送给客户端，并修改配置文件即可
 */
public class Demo {
	public static void main(String[] args) throws Exception {
		//通过反射获取Class对象
		Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
		//2获取show()方法
		Method m = stuClass.getMethod(getValue("methodName"));//show
		//3.调用show()方法
		m.invoke(stuClass.getConstructor().newInstance());
		
	}
	
	//此方法接收一个key，在配置文件中获取相应的value
	public static String getValue(String key) throws IOException{
		Properties pro = new Properties();//获取配置文件的对象
		FileReader in = new FileReader("pro.txt");//获取输入流
		pro.load(in);//将流加载到配置文件对象中
		in.close();
		return pro.getProperty(key);//返回根据key获取的value值
	}
}

运行结果

end

is show()

通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的

越过泛型检查



import java.lang.reflect.Method;
import java.util.ArrayList;
 
/*
 * 通过反射越过泛型检查
 * 
 * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
 */
public class Demo {
	public static void main(String[] args) throws Exception{
		ArrayList<String> strList = new ArrayList<>();
		strList.add("aaa");
		strList.add("bbb");
		
	//	strList.add(100);
		//获取ArrayList的Class对象，反向的调用add()方法，添加数据
		Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
		//获取add()方法
		Method m = listClass.getMethod("add", Object.class);
		//调用add()方法
		m.invoke(strList, 100);
		
		//遍历集合
		for(Object obj : strList){
			System.out.println(obj);
		}
	}
}

运行结果

end

1
2
3

aaa
bbb
100

注

参考资料：CSDN（点我进入）
                    博客园（点我进入）
                    百度百科（点我进入）
                    被遗忘的博客（点我进入）
                    三十三行伪代码（点我进入）

| 总阅读量