Java 反射机制 初探*

反射机制初探 *

走进沼泽

在正常的程序中，先有类，然后再有对象。

• 取得Class对象（类对象）

public final Class<?> getClass() ;

• 实例观察：

public class TestDemo {
	public static void main(String [] args) {
		Date date = new Date() ; // 产生对象
		System.out.println(date.getClass());
        // 因为所有类都是 Object的子类，而getClass是final型所以所有类都有getClass()方法
	}
}

• 运行结果

class java.util.Date

发现：调用getClass()方法输出的是类的完整名称，等于找到了对象出处：

——这就是“反”

Class 类对象实例化

• java.lang.Class是一个类，这个类就是反射操作的源头，即：所有的反射都要从Class类开始运行 三种实例化方法；

  • 调用Object中的Class方法

  Class<?> cls = date.getClass();
  // 此代码将Class类进行了实例化；getClass()是class类的实例化方法
  

  • 使用 类.class 方法

  Class<?> cls = Date.class;
  

  前者是产生了类的实例化对象之后取得Class类对象，但是类.class方法并没有实例化对象产生

  • 调用Class类提供的 forName() 方法

  Class<?> cls = Class.forName(String ClassName) ;
  

  此时可以不使用 import 语句导入一个明确的类名称，而类名称采用字符串的方式进行描述

反射实例化对象

当获得一个类时，使用关键字 new 进行类对象实例化操作；但是如果有了Class对象，那么就可以利用反射进行对象实例化操作。

实例化对象的方法：

public T newInstance();

• 实例分析：

class Book {
	public Book() {
		System.out.println("**********Book类 ***********");
	}
	@Override
	public String toString() {
		return "Hello,World!";
	}
}

public class TestDemo {
	public static void main(String [] args) throws InstantiationException, ReflectiveOperationException {
		Class<?> cls = Class.forName("helloworld.Book");
		@SuppressWarnings("deprecation")
		Object obj = cls.newInstance();
		Book book = (Book) obj ;// 向下转型
		System.out.println(book);// 调用了Book类的对象
		// 此过程没有 new 关键字实例化Book类，而是通过反射来实例化对象		
	}
}

在反射机制的加持下，类的对象实例化则不再单独依靠 new关键字 。

• new 与 反射 实例化对象的区别

package helloworld;
interface Fruit { // 函数是接口
	public void eat() ; 
}
class Apple implements Fruit {
	@Override
	public void eat() {
		System.out.println("苹果");
	}
}
class Factory {
	public static Fruit getInstance(String className) {
		if ("apple".equals(className)) {
			return new Apple();
		}
		return null ;
	}
}
public class TestFactory {
	public static void main(String[] args) {
		Fruit f = Factory.getInstance("apple");// 实例化Fruit对象
		f.eat();
	}
}

• 如果Fruit接口子类被增加了一个，那么就表示程序需要修改工厂类

package helloworld;
interface Fruit { // 函数是接口
	public void eat() ; 
}
class Apple implements Fruit {
	@Override
	public void eat() {
		System.out.println("苹果");
	}
}
class Orange implements Fruit{
	@Override
	public void eat() {
		System.out.println("橘子");
	}
}
class Factory {// 工厂类
	public static Fruit getInstance(String className) {
		if ("apple".equals(className)) {
			return new Apple();
		} else if ("orange".equals(className)) {
			return new Orange();
		} else {
			return null ;
		}
	}
}

public class TestFactory {
	public static void main(String[] args) {
		Fruit f = Factory.getInstance("apple");// 实例化Fruit对象
		f.eat();
	}
}

• 如上两则程序可以看出：

  每增加一个类，就要修改工厂类，非常的繁琐复杂；因为工厂类中的对象都是通过new直接实例化，而new就造成了这种高耦合的问题。

• 解决方法：

  依靠反射实例化对象来完成

  package helloworld;
  interface Fruit { // 函数是接口
  	public void eat() ; 
  }
  class Apple implements Fruit {
  	@Override
  	public void eat() {
  		System.out.println("苹果");
  	}
  }
  class Orange implements Fruit{
  	@Override
  	public void eat() {
  		System.out.println("橘子");
  	}
  }
  class Factory {// 工厂类
  	@SuppressWarnings("deprecation")
  	public static Fruit getInstance(String className) throws InstantiationException, ReflectiveOperationException, ClassNotFoundException {
  		Fruit f = null ; 
  		try {
  			f = ((Fruit) Class.forName(className).newInstance());
  		// 因为 Class.forName（）方法返回的是Object（默认/推荐），所以需要向下转型为Fruit
  		} catch (Exception e) {	}
  		return f ;
  	}
  }
  
  public class TestFactory {
  	public static void main(String[] args) throws InstantiationException, ClassNotFoundException, ReflectiveOperationException {
  		Fruit f = Factory.getInstance("helloworld.Apple");
  		f.eat();
  	}
  }
  // 程序中出现疑虑，可以参照"实例分析"
  

• 此时的程序就完成了解耦和的目的，而且可扩展性非常的强

反射调用方法

• 定义Book类

package helloworld;

public class Book {
	private String title ; 
	public void setTitle(String title) {
		this.title = title;
	}
	public String getTitle() {
		return title;
	}
}

类中有 无参构造方法 所以实例化对象的时候可以直接利用Class类中的newInstance()方法

• 在Class类中定义有如下的取得类中Method的操作：

  • 取得类中的全部方法：

  public Method [] getMethods();
  

  • 取得指定类中方法：

  public Method getMethod(String className , Class<?>... parameterTypes);
  

  以上返回的是：java.lang.reflect.Method 类的对象

• Methos类中的调用方法：

  public Object invoke(Object obj , Object … args);
  

• 实例：

package helloworld;
import java.lang.reflect.Method;

public class TestDemo {
	public static void main(String [] args) throws InstantiationException, ReflectiveOperationException {
		String classname = "title" ; 
		Class<?> cls = Class.forName("helloworld.Book");
		Object obj = cls.newInstance(); // 给出了Book类的实例化对象
		Method setMet = cls.getMethod("set" + initcap(classname),String.class);
		Method getMed = cls.getMethod("get" + initcap(classname));
		setMet.invoke(obj, "Java");
		System.out.println(getMed.invoke(obj));
	}
	private static String initcap(String str) { // 首字母大写
		return str.substring(0,1).toUpperCase() + str.substring(1) ;
	}
}

反射调用成员

• 类中的属性，一定要在本类实例化对象产生之后才可以分配内存空间。

• 取得全部成员：

  public Field [] getDeclaredFields() ;
  

• 取得指定成员：

  public Field getDeclaredFields() ;
  

• 返回的类型：java.lang.reflect.Field 类对象

  • 取得属性内容：

  public Object get(Object obj);
  

  • 设置属性内容：

  public void set(Object obj , Object Value);
  

• 定义Book类：

package helloworld;

public class Book {
	public String title ;
}

package helloworld;
import java.lang.reflect.Field;;

public class TestDemo {
	public static void main(String [] args) throws InstantiationException, ReflectiveOperationException {
		String classname = "title" ; 
		Class<?> cls = Class.forName("helloworld.Book");
		Object obj = cls.newInstance(); // 给出了Book类的实例化对象
		java.lang.reflect.Field titleField = cls.getDeclaredField("title") ;
		titleField.set(obj, "Java");
		System.out.println(titleField.get(obj));
	}
}

• 另外，还有一个访问private私有成员的方法，利用 setAccessible() 方法取消封装，然后调用成员。

package helloworld;
import java.lang.reflect.Field;;

public class TestDemo {
	public static void main(String [] args) throws InstantiationException, ReflectiveOperationException {
		String classname = "title" ; 
		Class<?> cls = Class.forName("helloworld.Book");
		Object obj = cls.newInstance(); // 给出了Book类的实例化对象
		Field titleField = cls.getDeclaredField("title") ;
		titleField.setAccessible(true);// 取消封装
		titleField.set(obj, "Java");
		System.out.println( titleField.get(obj) );
	}
}

构造方法和普通方法，也同样可以取消封装，但很少使用。

总结

• 实例化对象的方法增加一种“反射”
• 反射调用类机构只是一个开始