详谈--Java反射

1　什么是反射

让我们从Class类开始了解反射！

**1.

每个加载到方法区中的class文件都对应一个Class类的对象，你可以把Class类的对象理解为硬盘上的class文件的对应体。

在加载class文件时:会找变量 ,会去找方法等执行,找变量,找方法执行是有反射完成的.

一,

  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

二,Class类

2.1

阅读API的Class类得知，Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的

2.2

获取Class对象的三种方式:

方式一: 通过Object类中的getObject()方法

Person p = new Person();
Class c = p.getClass();

方式二: 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。

Class c2 = Person.class;

方式三: 通过Class类中的方法（将包含类名的全路径作为字符串传递给Class类中的静态方法forName() ,   即可）。

Class c3 = Class.forName("Person");
Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名

>>注意：第三种和前两种的区别

前两种你必须明确Person类型.

后面是指定这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了

代码演示:

/*
 * 获取.class字节码文件对象的方式
 * 		1：通过Object类中的getObject()方法
 * 		2: 通过 类名.class 获取到字节码文件对象
 * 		3: 反射中的方法,
 * 			public static Class<?> forName(String className) throws ClassNotFoundException
 * 			返回与带有给定字符串名的类或接口相关联的 Class 对象 
 */
public class ReflectDemo {
	public static void main(String[] args) throws ClassNotFoundException {
		// 1： 通过Object类中的getObject()方法
		// Person p1 = new Person();
		// Class c1 = p1.getClass();
		// System.out.println("c1 = "+ c1);

		// 2: 通过 类名.class 获取到字节码文件对象
		// Class c2 = Person.class;
		// System.out.println("c2 = "+ c2);

		// 3: 反射中的方法
		Class c3 = Class.forName("cn.itcast_01_Reflect.Person");// 包名.类名
		System.out.println("c3 = " + c3);
	}
}

Person类
package cn.itcast_01_Reflect;
public class Person {
	//成员变量
	public String name;
	public int age;
	private String address;

	//构造方法
	public Person() {
		System.out.println("空参数构造方法");
	}
	
	public Person(String name) {
		this.name = name;
		System.out.println("带有String的构造方法");
	}
	//私有的构造方法
	private Person(String name, int age){
		this.name = name;
		this.age = age;
		System.out.println("带有String，int的构造方法");
	}
	
	public Person(String name, int age, String address){
		this.name = name;
		this.age = age;
		this.address = address;
		System.out.println("带有String, int, String的构造方法");
	}
	
	//成员方法
	//没有返回值没有参数的方法
	public void method1(){
		System.out.println("没有返回值没有参数的方法");
	}
	//没有返回值，有参数的方法
	public void method2(String name){
		System.out.println("没有返回值，有参数的方法 name= "+ name);
	}
	//有返回值，没有参数
	public int method3(){
		System.out.println("有返回值，没有参数的方法");
		return 123;
	}
	//有返回值，有参数的方法
	public String method4(String name){
		System.out.println("有返回值，有参数的方法");
		return "哈哈" + name;
	}
	//私有方法
	private void method5(){
		System.out.println("私有方法");
	}

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

2.3

通过反射获取构造方法并使用:

在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法：

-->>返回一个构造方法

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

获取public修饰, 指定参数类型所对应的构造方法

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

获取指定参数类型所对应的构造方法(包含私有的)

-->>返回多个构造方法

public Constructor<?>[] getConstructors() 

获取 所有的public 修饰的构造方法

public Constructor<?>[] getDeclaredConstructors()

获取所有的构造方法(包含私有的)

获取构造方法的代码演示：

public class ReflectDemo {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
		//获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名
		
		//获取所有的构造方法
		//Constructor[] cons = c.getConstructors();[看一下]
		Constructor[] cons = c.getConstructors();
		for (Constructor con : cons) {
			System.out.println(con);
		}
		
		System.out.println("------------------------");
		//获取一个构造方法
		//public Person() 
		Constructor con1 = c.getConstructor(null);
		System.out.println(con1);
		
		//public Person(String name)
		Constructor con2 = c.getConstructor(String.class);
		System.out.println(con2);
		
		//private Person(String name, int age)
		Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
		System.out.println(con3);
		
		//public Person(String name, int age, String address)
		Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
		System.out.println(con4);
	}
}

2.4 通过反射方式，获取构造方法，创建对象

获取构造方法，步骤如下：

1. 获取到Class对象

2. 获取指定的构造方法

3. 通过构造方法类Constructor中的方法，创建对象

public T newInstance(Object... initargs)     

代码演示:

public class ConstructorDemo {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1,获取到Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名
		//2,获取指定的构造方法
		//public Person()
		//Constructor con = c.getConstructor(null);
		
		//public Person(String name, int age, String address)
		Constructor con = c.getConstructor(String.class, int.class, String.class);
		
		//3,通过构造方法类中Constructor的方法，创建对象
		//Object obj = con.newInstance(null);
		Object obj = con.newInstance("小明", 22, "哈尔滨");
		
		//显示
		System.out.println(obj);
	}
}

2.5 通过反射方式，获取私有构造方法，创建对象

AccessibleObject 类是 Field、Method 和 Constructor 对象的父类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。

对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，会执行访问检查。常用方法如下：

l public void setAccessible(boolean flag) throws SecurityException 

参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。参数值为 false 则指示反射的对象应该实施 Java 语言访问检查。

 

获取私有构造方法，步骤如下：

1. 获取到Class对象

2. 获取指定的构造方法

3. 暴力访问, 通过setAccessible(boolean flag)方法

4. 通过构造方法类Constructor中的方法，创建对象

public T newInstance(Object... initargs)

 代码演示：

public class ConstructorDemo2 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1,获取到Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名
		
		//2,获取指定的构造方法
		//private Person(String name, int age)
		Constructor con = c.getDeclaredConstructor(String.class, int.class);
		
		//3,暴力反射 
		con.setAccessible(true);//取消 Java 语言访问检查
		
		//4,通过构造方法类中的功能，创建对象
		Object obj = con.newInstance("小明", 23);
		System.out.println(obj);
		
	}
}

2.6 通过反射获取成员变量并使用

在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：

l返回一个成员变量

public Field getField(String name) 获取指定的 public修饰的变量

public Field getDeclaredField(String name) 获取指定的任意变量

返回多个成员变量 public Field[] getFields() 获取所有public 修饰的变量

public Field[] getDeclaredFields() 获取所有的 变量 (包含私有)

 

 获取成员变量的代码演示：

public class FieldDemo {
		public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
			// 获取Class对象
			Class c = Class.forName("cn.itcast_01_Reflect.Person");
			// 获取成员变量
			// 多个变量
			// Field[] fields = c.getFields();
			Field[] fields = c.getDeclaredFields();
			for (Field field : fields) {
				System.out.println(field);
			}
			System.out.println("-----------------");
			// 一个变量
			// public int age;
			Field ageField = c.getField("age");
			System.out.println(ageField);
			// private String address
			Field addressField = c.getDeclaredField("address");
			System.out.println(addressField);
		}
	}










1.1.1 通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作
获取成员变量，步骤如下：
1. 获取Class对象
2. 获取构造方法
3. 通过构造方法，创建对象
4. 获取指定的成员变量（私有成员变量，通过setAccessible(boolean flag)方法暴力访问）
5. 通过方法，给指定对象的指定成员变量赋值或者获取值
l public void set(Object obj, Object value)
在指定对象obj中，将此 
Field 对象表示的成员变量设置为指定的新值
l public Object get(Object obj)
          返回指定对象obj中，此
Field 对象表示的成员变量的值



代码演示：
public class FieldDemo2 {
		public static void main(String[] args)
				throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException,
				IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
			// 1,获取Class对象
			Class c = Class.forName("cn.itcast_01_Reflect.Person");
			// 2，获取构造方法
			// public Person(String name)
			Constructor con = c.getConstructor(String.class);
			// 3，通过构造方法，创建对象
			Object obj = con.newInstance("小明");
			// 4，获取指定的成员变量
			// public String name;
			Field nameField = c.getField("name");
			// public int age;
			Field ageField = c.getField("age");
			// private String address;
			Field addressField = c.getDeclaredField("address");
			addressField.setAccessible(true); // 取消 Java 语言访问检查
			// 5，通过方法，给指定对象的指定成员变量赋值或者获取值
			System.out.println("name = " + nameField.get(obj));
			System.out.println("age = " + ageField.get(obj));
			System.out.println("address = " + addressField.get(obj));
			// 赋值
			ageField.set(obj, 23);
			addressField.set(obj, "凯利广场");
			System.out.println("------------------------");
			System.out.println("name = " + nameField.get(obj));
			System.out.println("age = " + ageField.get(obj));
			System.out.println("address = " + addressField.get(obj));
		}
	}










1.2 通过反射获取成员方法并使用
在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法：
l 返回获取一个方法：

  
  

 
l public Method getMethod(String name, Class<?>... parameterTypes)
  获取public 修饰的方法
l public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
  获取任意的方法，包含私有的方法
参数1: name 要查找的方法名称； 参数2： parameterTypes 该方法的参数类型
 

返回获取多个方法：
public Method[] getMethods() 获取本类与父类中所有public 修饰的方法
public Method[] getDeclaredMethods() 获取本类中所有的方法(包含私有的)

获取成员方法的代码演示：
	public class MethodDemo {
		public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
			// 获取Class对象
			Class c = Class.forName("cn.itcast_01_Reflect.Person");
			// 获取多个方法
			// Method[] methods = c.getMethods();
			Method[] methods = c.getDeclaredMethods();
			for (Method method : methods) {
				System.out.println(method);
			}
			System.out.println("-----------------------");
			// 获取一个方法：
			// public void method1()
			Method method = c.getMethod("method1", null);
			System.out.println(method);
			// public String method4(String name){
			method = c.getMethod("method4", String.class);
			System.out.println(method);
			// 私有方法
			// private void method5()
			method = c.getDeclaredMethod("method5", null);
			System.out.println(method);
		}
	}








1.2.1 通过反射，创建对象，调用指定的方法
获取成员方法，步骤如下：
1. 获取Class对象
2. 获取构造方法
3. 通过构造方法，创建对象
  4. 获取指定的方法
  5. 执行找到的方法
l public Object invoke(Object obj,  Object... args) 
执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。
l 代码演示：
public class MethodDemo2 {
		public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
				InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
			// 1， 获取Class对象
			Class c = Class.forName("cn.itcast_01_Reflect.Person");
			// 2,获取构造方法
			// public Person(String name, int age, String address){
			Constructor con = c.getConstructor(String.class, int.class, String.class);
			// 3，通过构造方法，创建对象
			Object obj = con.newInstance("小明", 23, "哈尔滨");
			// 4，获取指定的方法
			// public void method1() 没有返回值没有参数的方法
			// Method m1 = c.getMethod("method1", null);
			// public String method4(String name)
			Method m4 = c.getMethod("method4", String.class);
			// 5，执行找到的方法
			// m1.invoke(obj, null);
			Object result = m4.invoke(obj, "itcast");
			System.out.println("result = " + result);
		}
	}










1.2.2 通过反射，创建对象，调用指定的private 
方法
获取私有成员方法，步骤如下：
1. 获取Class对象
2. 获取构造方法
3. 通过构造方法，创建对象
4. 获取指定的方法
5. 开启暴力访问
6. 执行找到的方法
public Object invoke(Object obj,  Object... args)
执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。
代码演示：
public class MethodDemo3 {
		public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
				InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
			// 1， 获取Class对象
			Class c = Class.forName("cn.itcast_01_Reflect.Person");
			// 2,获取构造方法
			// public Person(String name, int age, String address){
			Constructor con = c.getConstructor(String.class, int.class, String.class);
			// 3，通过构造方法，创建对象
			Object obj = con.newInstance("小明", 23, "哈尔滨");
			// 4，获取指定的方法
			// private void method5(){
			Method m5 = c.getDeclaredMethod("method5", null);
			// 5,开启暴力访问
			m5.setAccessible(true);
			// 6，执行找到的方法
			m5.invoke(obj, null);
		}
	}