反射机制初探 *

走进沼泽

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

取得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) );

	}

}

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

总结

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

巴特西

Java 反射机制初探*

反射机制初探 *

走进沼泽

Class 类对象实例化

反射实例化对象

实例化对象的方法：

反射调用方法

反射调用成员

总结

最新文章

热门文章

巴特西

Java 反射机制 初探*

反射机制初探 *

走进沼泽

Class 类对象实例化

反射实例化对象

实例化对象的方法：

反射调用方法

反射调用成员

总结

最新文章

热门文章

Java 反射机制初探*