赵雅智_Java 反射

 

一个类有多个组成部分，例如：成员变量，方法，构造方法等。

反射就是加载类，并解剖出类的各个组成部分。

java反射机制提供的功能：

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时调用任意一个对象的方法。包括private的方法
• 生成动态代理

Java反射所需要的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。

class类：类和接口

Field类：字段

Constructor类：构造方法

Method类：方法

Array类：数组

注意：

Class类是Java反射的起源，针对任何一个你想探勘的类，只有先为它产生一个Class类的对象，接下来才能通过Class对象获取其他想要的信息。

class类：

• JVM为每种类型管理着一个独一无二的Class对象----每个类（型）都有一个Class对象。
• 系统对所有对象进行的运行时类型标识---->Class类对象用来保存这些类型信息的。

  • Java程序运行过程中，当需要创建某个类的实例时，JVM首先检查所要加载的类对应的Class对象是否已经存在。

  • 如果还不存在，JVM就会根据类名查找对应的字节码文件并加载，接着创建对应的Class对象，最后才创建出这个类的实例。

• 例如，

  • Java基本数据类型（boolean、byte、char、short、int、long、float 和 double）；

  • 关键字void 也都对应一个 Class 对象；

  • 每个数组属性也被映射为 Class 对象，所有具有相同类型和维数的数组都共享该 Class 对象。

• 因此，运行中的类或接口在JVM中都会有一个对应的Class对象存在，它保存了对应类或接口的类型信息。要想获取类或接口的相应信息，需要先获取这个Class对象。

获得class类对象

• Java中有一个Class类用于代表某一个类的字节码。
• 使用Class类的forName()静态方法获得与字符串对应的Class对象
  • 参数字符串必须是类或接口的完全限定名

    Class c = Class.forName("java.lang.String");

• 类名.class

  Class c1 = Manager.class;
  Class c2 = int.class;//int
  Class c3 = Integer,class;//java.lang.Integer
  Class c4 = double[].class;

• 对象.getClass()

  MyObject x = new MyObject();
  Class c1 = x.getClass();

Class对象提供了如下常用方法：

• public String getName()：获取Class对象所表示实体的完全限定名
• public Field[] getField()：所有public字段
• Public  Constructor  getConstructor(Class<?>... parameterTypes) ：所有public构造方法
• Public  Method  getMethod(String name, Class<?>... parameterTypes) ：所有public方法
• public Constructor getDeclaredConstructor(Class... parameterTypes)：所有的构造方法
• public Method getDeclaredMethod(String name,Class... parameterTypes)：所有的方法
• public Field getDeclaredField(String name) ：所有的字段

这些方法分别用于从类中解剖出构造函数、方法和成员变量（属性）。解剖出的成员分别使用Constructor、 Method 、 Field 对象表示。

 

构造方法：

Constructor类提供了如下方法，用于创建类的对象：
  public Object newInstance(Object... initargs)
  initargs用于指定构造函数接收的参数

sun公司为简化开发人员创建对象，它在class对象中也提供了一个newInstance方法，用于创建类的对象。

这样开发人员可以避免每次都需要去反射Constructor 类以创建对象。

不过需要注意的是：

class.newInstance方法内部是反射类无参的构造函数创建的对象，所以利用此种方式创建类对象时，类必须有一个无参的构造函数。

练习：反射类无参、有参、私有的构造函数，创建类的对象。

package com.hbsi.reflect;

public class Person {
	
	public String sex="nan";
	
	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	private String name="zhangsan";
	private int age;
	
	public Person(){
		//System.out.println("无参构造");
	}
	
	public Person(String name){
		//this.name=name;
		System.out.println(name);
	}
	
	public Person(String name,int age){
		System.out.println(name+"..."+age);
	}
	
	private Person(int age){
		System.out.println("私有");
	}
	
	
	
	public void run(){
		System.out.println("run...");
	}
	
	public void run(String name){
		System.out.println("run..."+name);
	}
	
	public void run(String name,int age){
		System.out.println("run..."+name+"..."+age);
	}
	
	public int sum(int i,int j){
		return i+j;
	}
	
	private void  sum1(){
		System.out.println("sum1...");
	}
	
	
	public static void sum2(){
		System.out.println("sum2...");
	}
	
	
	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;
	}
	

}

package com.hbsi.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import org.junit.Test;

public class Demo2 {
	
	public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
		Demo2 d = new Demo2();
		d.test1();
		System.out.println("-----");
		d.test2();
		System.out.println("-----");
		d.test3();
		System.out.println("-----");
		d.test4();
		System.out.println("-----");
		d.test5();
	}
	
	
	//反射出无参的构造方法，并创建一个person对象
	@Test
	public void test1() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{
		
		//加载类
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		//反射出构造方法
		Constructor c=clazz.getConstructor(null);
		
		Person p=(Person)c.newInstance(null);
		
		System.out.println(p.getName());
		
	}
	//反射出 public Person(String name)
	@Test
	public void test2() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{
		
		//加载类
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		//反射出构造方法
		Constructor c=clazz.getConstructor(String.class);
		
		Person p=(Person)c.newInstance("lisi");
		
		System.out.println(p.getName());
		
	}
	
	//反射出public Person(String name,int age)
	@Test
	public void test3() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{
		
		//加载类
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		//反射出构造方法
		Constructor c=clazz.getConstructor(String.class,int.class);
		
		Person p=(Person)c.newInstance("lisi",23);
		
		System.out.println(p.getName());
		
	}
	
	//反射private Person(int age)
	@Test
	public void test4() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{
		
		//加载类
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		//反射出构造方法
		Constructor c=clazz.getDeclaredConstructor(int.class);
		
		c.setAccessible(true); //如果是private的，必须设置访问权限
		
		Person p=(Person)c.newInstance(24);
		
		System.out.println(p.getName());
		
	}
	
	
	@Test
	public void test5() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		
		//加载类
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		Person p=(Person)clazz.newInstance();
		
		System.out.println(p.getName());
		
	}

}

方法：

Method对象提供了如下方法，用于执行它所代表的方法：

 public Object invoke(Object obj,Object... args)

练习：使用Method分别执行无参、有参、多个参（带数组和基本数据类型）、静态、私有的方法。

package com.hbsi.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Test;

public class Demo3 {
	public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
		Demo3 d = new Demo3();
		d.test1();
		System.out.println("-----");
		d.test2();
		System.out.println("-----");
		d.test3();
		System.out.println("-----");
		d.test4();
		System.out.println("-----");
		d.test5();
	}
	
	// public void run()
	@Test
	public void test1() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		
		Person p=new Person();
		
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		Method m=clazz.getMethod("run",null);
		
		m.invoke(p,null);
		
		
		
	}
	
	//public void run(String name)
	@Test
	public void test2() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		
		Person p=new Person();
		
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		Method m=clazz.getMethod("run",String.class);
		
		m.invoke(p,"zhangsan");
		
		
		
	}
	
	//public int sum(int i,int j)
	
	@Test
	public void test3() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		
		Person p=new Person();
		
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		Method m=clazz.getMethod("sum",int.class,int.class);
		
		int value=(Integer)m.invoke(p,12,2);
		
		System.out.println(value);
		
	}
	
	//private void  sum1()
	@Test
	public void test4() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		
		Person p=new Person();
		
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		Method m=clazz.getDeclaredMethod("sum1",null);
		
		m.setAccessible(true);
		
		m.invoke(p,null);
		
	}
	
	//public static void sum2()
	
	@SuppressWarnings("unchecked")
	@Test
	public void test5() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		
		//Person p=new Person();
		
		Class clazz=Class.forName("com.hbsi.reflect.Person");
		
		Method m=clazz.getMethod("sum2",null);
			
		m.invoke(null,null);
		
	}
	

}

jdk1.4和jdk1.5的invoke方法的区别：

Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，

问题：

启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：

mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"});

编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

字段：

Field对象提供了如下方法，用于设置、获取对象属性的值：

public void set(Object obj,Object value)
public Object get(Object obj)

练习：利用Field分别设置和获取公有、私有的属性。

package net.csdn.high;

import java.util.Date;

public class Student {
	private String name = "zhangsan";
	private int age;
	private Date birthday;
	public String sex;
	
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	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;
	}
	
	public Student(){
		System.out.println("无参构造函数");
	}
	
	public Student(String name){
		System.out.println(name);
	}
	public Student(String name,int age){
		System.out.println(name+"....."+age);
	}
	private Student(int age){
		System.out.println("私有构造函数");
	}
	
	public void run(){
		System.out.println("run.....");
	}
	
	public void run(String name){
		System.out.println("run....."+name);
	}
	
	public void run(String name, int age){
		System.out.println("run....."+name+"....."+age);
	}
	
	public int sum(int i, int j){
		return i+j;
	}
	
	private void privateMethod(){
		System.out.println("privateMethod.....");
	}
	
	public static void staticMethod(){
		System.out.println("staticMethod.....");
	}
}

 

package net.csdn.high;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

import org.junit.Test;

public class RefFieDemo {
	public static void main(String[] args) throws Exception {
		RefFieDemo r = new RefFieDemo();
		r.test1();
		System.out.println("---------");
		r.test2();
	}

	@Test
	public void test1() throws IllegalAccessException, InvocationTargetException, ClassNotFoundException, NoSuchFieldException, SecurityException{
		Student s = new Student();
		Class clazz = Class.forName("net.csdn.high.Student");
		Field f = clazz.getField("sex");
		String sex = (String) f.get(s);
		System.out.println(sex);
		//类型
		Class type = f.getType();
		System.out.println(type);
		//设置值
		f.set(s, "nv");
		System.out.println(s.sex);
	}
	
	@Test
	public void test2() throws IllegalAccessException, InvocationTargetException, ClassNotFoundException, NoSuchFieldException, SecurityException{
		Student s = new Student();
		Class clazz = Class.forName("net.csdn.high.Student");
		Field f = clazz.getDeclaredField("name");
		f.setAccessible(true);
		String name = (String) f.get(s);
		System.out.println(name);
		//类型
		Class type = f.getType();
		System.out.println(type);
		//设置值
		f.set(s, "lisi");
		System.out.println(s.getName());
	}
}