java反射基本总结

反射的用武之地：
实际开发里面用反射的机会不是特别多，除非自己开发框架，如果只是单纯用别人写好的框架，是不会直接和反射打交道的。但是理解好反射之后对以后框架的使用感觉完全是不同的。


在java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于java语言的反射机制(Reflection)。
Java反射机制主要提供了以下功能：
1、 在运行时判断任意一个对象所属的类。
2、 在运行时构造任意一个类的对象。
3、 在运行时判断任意一个类所具有的成员变量和方法。
4、 在运行时调用任意一个对象的方法。

Reflection是java被视为动态(或准动态)语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifies(诸如public、static等等)、superclass(例如Object)、实现之interfaces(例如Serializable)，也包括fields和methods的所有信息，并可于运行时改变fields内容或调动methods。

总结起来一句话：只要知道某个类的名字，那么这个类里面的所有信息都可以得到。


一般而言，开发者社群说到动态语言，大致认同的一个定义是：“[color=red]程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言[/color]”。从这个观点看，Perl，Python，Ruby是动态语言，C++，java，C#不是动态语言。


尽管在这样的定义与分类下java不是动态语言，它却有着一个非常突出的动态相关机制：
Reflection。这个字的意思是：“[color=red]反射、映像、倒影[/color]”，用在java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知classes。换句话说，java程序可以加载一个运行时才得知名称的classes，获悉其完整构造([color=red]但不包括methods定义[/color])，并生成其对象实体、或对其fields设值、或唤起其methods。这种“看透class”的能力(the abilith of the program to examine itself)被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

在JDK中，主要由以下类来实现java反射机制，这些类都位于[color=red]java.lang.reflect[/color]包中：
1、 Class类：代表一个类。
2、 Field类：代表类的成员变量(成员变量也称为类的属性)。
3、 Method类：代表类的方法。
4、 Constructor类：代表类的构造方法。
5、 Array类：提供了动态创建数组，以及访问数组的袁术的静态方法。

[size=large][color=red]Java中，无论生成某个类的多少个对象，这些对象都会对应同一个Class对象。【描述了这个类的整个结构，它是在没有生成任何的一个对象之前由Java虚拟机JVM帮助创建的，是在类被装载的时候创建的】


Class是Reflection（反射）起源。针对任何您想探勘的class，唯有先为它产生一个Class object，接下来才能经由后者唤起为数十多个的Reflection APIs
[/color][/size]

1、要想使用反射，首先需要获得待处理类或对象所对应的Class对象。

2、若想通过类的不带参数的构造方法来生成对象(反射里面生成对象)，我们有两种方式：
a) 先获得Class对象，然后通过该Class对象的newInstance()方法直接生成即可：
Class<?> classType = String.class;
Object obj = classType.newInstance();
b) 先获得Class对象，然后通过该对象获得对应的Constructor对象，再通过该Constructor
对象的newInstance()方法生成：
Class<?> classType = Customer.class;
Constructor cons = classType.getConstructor(new Class[]{});
Object obj = cons.newInstance(new Object[]{});

3、若想通过类的带参数的构造方法生成对象，只能使用下面这一种方式：
Class<?> classType = Customer.class;
Constructor cons = classType.getConstructor(new Class[]{String.class, int.class});
Object obj = cons.newInstance(new Object[]{“hello”, 3});


下面是一个java反射的最基本的例子：

package com.test.reflection;

import java.lang.reflect.Method;

public class DumpMethods {
	public static void main(String[] args) throws Exception {
		// 加载并初始化命令行参数指定的类
		Class classType = Class.forName(args[0]);

		// 获得类的所有方法
		Method methods[] = classType.getDeclaredMethods();

		for (int i = 0; i < methods.length; i++) {
			System.out.println(methods[i].toString());
		}
	}
}

下面是一个一般难度的反射示例：

package com.shengshiyuan.refect;

import java.lang.reflect.Method;

public class InvokeTester {

	public int add(int param1, int param2) {
		return param1 + param2;
	}

	public String echo(String message) {
		return "hello: " + message;
	}

	public static void main(String[] args) throws Exception {
		// 通过常规手段使用上述方法
		InvokeTester tester = new InvokeTester();
		System.out.println(tester.add(1, 2));
		System.out.println(tester.echo("Tom"));

		// 下面使用反射机制使用上面定义的方法
		// 获取Class对象（要想使用反射操作某个class类，首先必须获得它的Class对象）
		Class<?> classType = InvokeTester.class;
		// 创建InvokeTester类的一个实例
		Object invokeTester = classType.newInstance();
		System.out.println(invokeTester instanceof InvokeTester);
		// 通过InvokeTester对应的Class对象调用getMethod方法获得它里面add方法对应的Method对象，getMethod方法接收两个参数，第一个为想要获得的方法的名称，第二个为方法接收参数类型的Class对象构成的数组(可变参数)
		Method addMethod = classType.getMethod("add", new Class[] { int.class,
				int.class });
		// 调用Method对象的invoke方法就表示调用了Method这个对象所对应的那个目标方法。它接收两个参数，第一个参数表示目标方法对应的对象，第二个参数(可变参数，可以传递一个数组进去)表示方法调用的时候接收的实际的参数。
		Object result = addMethod.invoke(invokeTester, new Object[] { 1, 2 });// 自动装箱
		System.out.println(result);
		System.out.println("--------------------------------------------");
		Method echoMethod = classType.getMethod("echo",
				new Class[] { String.class });
		//invoke返回值
		Object result2 = echoMethod
				.invoke(invokeTester, new Object[] { "Tom" });
		System.out.println((String) result2);
	}
}

在java.lang.Object类中定义了getClass()方法，因此对于任意一个Java对象，都可以通过此方法获得对象的类型。Class类是Reflection API中的核心类，它有以下方法：
getName()：获得类的完成名字。
getFields()：获得类的public 类型的属性。
getDeclaredFields()：获得类的所有属性。
getMethods()：获得类的public类型的方法。
getDeclaredMethods()：获得类的所有方法。
getMethod(String name, Class[] patameterTypes)：获得类的特定方法，name参数指定方法的名字，patameterTypes参数指定方法的参数类型。
getConstrutors()：获得类的public类型的构造方法。
getConstrutor(Class[] patameterTypes)：获得类的特定构造方法，patameterTypes参数指定构造方法的参数类型。
newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。


通过默认构造方法创建一个新对象：
Object objectCopy = classType.getConstructor(new Class[] {})
.newInstance(new Object[] {});
以上代码先调用Class类的getConstructor()方法获得一个Constructor对象，它代表默认的构造方法，然后调用Constructor对象的newInstance()方法构造一个实例。

Class类的getDeclaredFields()方法返回类的所有属性，包括public,protected,默认和private访问级别的属性。

Method类的invoke(Object obj,Object args[]) 方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。Invoke()方法的返回值总是对象，如果实际被调用的方法的返回类型是基本数据类型，那么invoke()方法会把它转换为相应的包装类型的对象，再将其返回。

总所周知Java有个Object class，是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods:
hashCode(),equals(),clone(),toString(),getClass()等。其中getClass()返回一个Class object。

一个类可以生成多个对象，但这些对象对应的Class对象只有一个，一个类只有一个Class对象。

Class是Reflection起源。针对人也您想探勘的class，唯有先为它产生一个Class object，接下来才能经由后者唤起位数十多个的Reflection APIs。


[color=red]获取某个类或某个对象所对应的Class对象的常用的3种方式：
a) 使用Class类的静态方法forName：Class.forName(“java.lang.String”);
b) 使用类的.class 语法：String.class;
c) 使用对象的getClass()方法：String s = “aa”; Class<?> clazz = s.getClass();[/color]


下面是一个比较复杂的反射示例：

package com.test.reflection;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 进一步演示了反射机制的基本使用方法
 * Spring底层大概就是这么干的，嘎嘎嘎
 * 利用反射实现的一个对象之间属性值拷贝的功能
 * 类: ReflectTester <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Jul 19, 2013 2:02:03 PM
 */
public class ReflectTester {
	public Object copy(Object object) throws Exception {
		// 获得对象类型
		Class classType = object.getClass();
		System.out.println("Class:" + classType.getName());

		// 通过默认构造方法创建一个新的对象
		// getConstructor方法是获得与这个类里面的构造方法所对应的这个类的对象，“new Class[]
		// {}”参数表示的是这个构造方法是不带参数的
		// 然后调用newInstance方法就生成了对象的实例
		Object objectCopy = classType.getConstructor(new Class[] {})
				.newInstance(new Object[] {});

		// 获得对象的所有属性
		Field fields[] = classType.getDeclaredFields();

		for (int i = 0; i < fields.length; i++) {
			Field field = fields[i];
			String fieldName = field.getName();

			String firstLetter = fieldName.substring(0, 1).toUpperCase();
			// 获得和属性对应的getXXX()方法的名字
			String getMethodName = "get" + firstLetter
					+ fieldName.substring(1, fieldName.length());
			// 获得和属性对应的setXXX()方法的名字
			String setMethodName = "set" + firstLetter
					+ fieldName.substring(1, fieldName.length());
			// 获得和属性对应的getXXX()方法
			Method getMethod = classType.getMethod(getMethodName,
					new Class[] {});
			// 获得和属性对应的setXXX()方法（new Class[] { field.getType() }表示传入方法的接收参数类型）
			Method setMethod = classType.getMethod(setMethodName,
					new Class[] { field.getType() });
			// 调用原对象的getXXX()方法，（先取出原来对象属性的值）
			Object value = getMethod.invoke(object, new Object[] {});
			System.out.println(fieldName + ":" + value);
			// 调用拷贝对象的setXXX()方法，（把原来对象的属性值拷贝到新的对象中）
			setMethod.invoke(objectCopy, new Object[] { value });
		}
		return objectCopy;
	}

	public static void main(String[] args) throws Exception {
		Customer customer = new Customer("Tom", 21);
		customer.setId(new Long(1));

		Customer customerCopy = (Customer) new ReflectTester().copy(customer);
		System.out.println("Copy information:" + customerCopy.getId() + " "
				+ customerCopy.getName() + " " + customerCopy.getAge());
	}

}

class Customer {
	private Long id;
	private String name;
	private int age;

	public Customer() {
	}

	public Customer(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	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;
	}
}

下面是几个关于反射的讲解：
[img]class1.jpg[/img]
[img]class2.jpg[/img]
[img]class3.jpg[/img]

Java.lang.reflect.Array类提供了[color=red]动态创建[/color]和访问数组元素的各种[color=red]静态[/color]方法。这个类都是在反射里面用到的，[color=red]反射模块里面的相关类都是在java.lang.reflect包里面[/color]。

[color=red]注意Array类和Arrays类的区别:
Array类一般都是在反射里面用到的，属于反射模块里面的类，功能见上面一句的解释。
Arrays类包含用来操作数组（比如排序和搜索）的各种方法，是数组的一个辅助类，就像Collections类是集合Collection的辅助类一样，都是正常开发里面用到的，和反射不沾边。[/color]


接下来又讲解了反射里面的数组的操作，主要讲解了Array类的用法，自己感觉这部分只是用的不会太多，就没认真听，也没总结。（在第52.发射机制大总结.avi里面）。