Java反射机制

Java反射机制Reflection，是在程序运行的时候能够获取和改变类的属性、方法等信息。

因为反射的动态控制类的特性，所以大多被用在框架开发中等。

我主要通过实例的方式来展现Java反射的常用方法。

Java 反射机制主要提供了以下功能：

1. 在运行时判断任意一个对象所属的类;

2. 在运行时构造任意一个类的对象;

3. 在运行时判断任意一个类所具有的成员变量和方法;

4. 在运行时调用任意一个对象的方法;

5. 生成动态代理。

在 JDK 中，主要由以下类来实现Java 反射机制，这些类都位于java.lang.reflect

包中。

Class类：代表一个类。

Field类：代表类的成员变量(成员变量也称为类的属性)。

Method类：代表类的方法。

Constructor 类：代表类的构造方法。

Array类：提供了动态创建数组，以及访问数组元素的静态方法。

1. 获取类的包名称

Demo类

[java] view
plaincopyprint?





package com.xxx.test;

/**

* 一个测试的Demo类

* @author zhuli

* @date 2014-6-22

*/

public class Demo {

private Integer age;

private String userName;

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

@Override

public String toString() {

return "Demo [age=" + age + ", userName=" + userName + "]";

}

}

Java main：

[java] view
plaincopyprint?





package com.xxx.test;

public class JavaTest {

public static void main(String args[]) {

//第一种方法

Class<?> demoClass = Demo.class; //通过 类名.class 直接获取类的Class

System.out.println("Demo.class的方式获取包名：" + demoClass.getName());

//第二种方法

Demo demo = new Demo();

Class<?> demoClass2 = demo.getClass(); //通过对象的getClass获取类的Class

System.out.println("demo.getClass()的方式获取包名：" + demoClass2.getName());

//第三种方法

Class<?> demoClass3 = null;

try {

demoClass3 = Class.forName("com.xxx.test.Demo");

} catch (Exception e) {

}

System.out.println("Class.forName(\"Demo\")的方式获取包名：" + demoClass3.getName());

}

}

2. 获取类的方法信息

通过getDeclaredMethods()方法就可以获取到类中的方法信息。

通过getDeclaredFields()方法获取类的域信息

[java] view
plaincopyprint?





package com.xxx.test;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class JavaTest {

public static void main(String args[]) {

//获取类提供的方法

Class<?> demoClass = Demo.class; //通过 类名.class 直接获取类的Class

Demo demo = null;

//获取类的域信息

Field[] fields = demoClass.getDeclaredFields();

for (int i = 0; i < fields.length; i++) {

System.out.println(fields[i].getName() + fields[i].getType());

}

//获取方法信息

Method methods[] = demoClass.getDeclaredMethods();

for (int i = 0; i < methods.length; i++) {

System.out.println(methods[i]);

}

}

}

输出：

[html] view
plaincopyprint?





ageclass java.lang.Integer

userNameclass java.lang.String

public java.lang.Integer com.xxx.test.Demo.getAge()

public void com.xxx.test.Demo.setAge(java.lang.Integer)

public void com.xxx.test.Demo.setUserName(java.lang.String)

public java.lang.String com.xxx.test.Demo.toString()

public java.lang.String com.xxx.test.Demo.getUserName()

3. 实例化一个类

[java] view
plaincopyprint?





package com.xxx.test;

public class JavaTest {

public static void main(String args[]) {

//获取类提供的方法

Class<?> demoClass = Demo.class; //通过 类名.class 直接获取类的Class

Demo demo = null;

try {

demo = (Demo) demoClass.newInstance();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

demo.setAge(20);

demo.setUserName("initphp");

System.out.println(demo.toString());

}

}

输出：

Demo [age=20, userName=initphp]

4. 通过反射设置私有属性值

[java] view
plaincopyprint?





package com.xxx.test;

import java.lang.reflect.Field;

public class JavaTest {

public static void main(String args[]) throws Exception {

//获取类提供的方法

Class<?> demoClass = Demo.class; //通过 类名.class 直接获取类的Class

Demo demoObj = (Demo) demoClass.newInstance();

//设置类的属性值

Field field = demoClass.getDeclaredField("age");

field.setAccessible(true); //设置私有属性范围

field.set(demoObj, 20);

Field field2 = demoClass.getDeclaredField("userName");

field2.setAccessible(true);

field2.set(demoObj, "initphp");

System.out.println("获取一个值：" + field2.get(demoObj));

System.out.println(demoObj.toString());

}

}

输出：

获取一个值：initphp

Demo [age=20, userName=initphp]

5. 通过反射调用类的方法

[java] view
plaincopyprint?





package com.xxx.test;

import java.lang.reflect.Method;

public class JavaTest {

public static void main(String args[]) throws Exception {

//获取类提供的方法

Class<?> demoClass = Demo.class; //通过 类名.class 直接获取类的Class

Demo demoObj = (Demo) demoClass.newInstance();

//调用类的方法

Method method = demoClass.getMethod("setAge", Integer.class); //获取类方法信息

method.invoke(demoObj, 100); //调用方法

Method method2 = demoClass.getMethod("getAge");

System.out.println("Age:" + method2.invoke(demoObj));

Method method3 = demoClass.getMethod("setUserName", String.class);

method3.invoke(demoObj, "initphp");

Method method4 = demoClass.getMethod("getUserName");

System.out.println("UserName:" + method4.invoke(demoObj));

System.out.println(demoObj.toString());

}

}

输出：

Age:100

UserName:initphp

Demo [age=100, userName=initphp]

6. 获取父类/interface/构造函数等信息

新增Demo的接口/父类

[java] view
plaincopyprint?





package com.xxx.test;

public class People {

private String sex;

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

}

package com.xxx.test;

public interface Test {

}

package com.xxx.test;

/**

* 一个测试的Demo类

* @author zhuli

* @date 2014-6-22

*/

public class Demo extends People implements Test {

public Demo() {

}

public Demo(String userName, Integer age) {

this.age = age;

this.userName = userName;

}

private Integer age;

private String userName;

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

@Override

public String toString() {

return "Demo [age=" + age + ", userName=" + userName + "]";

}

}

例子：

[java] view
plaincopyprint?





package com.xxx.test;

import java.lang.reflect.Constructor;

public class JavaTest {

public static void main(String args[]) throws Exception {

//获取类提供的方法

Class<?> demoClass = Demo.class; //通过 类名.class 直接获取类的Class

//获取构造函数信息

Constructor<?> ctorlist[] = demoClass.getDeclaredConstructors();

for (int i = 0; i < ctorlist.length; i++) {

Constructor<?> ct = ctorlist[i];

System.out.print("构造函数 = " + ct.getName());

Class<?> pvec[] = ct.getParameterTypes(); //获取参数类型。数组形式

for (int j = 0; j < pvec.length; j++) {

System.out.print(" 参数： " + pvec[j]);

}

System.out.println("");

//通过构造函数实例化对象

if (pvec.length > 0) {

Demo demo = (Demo) ct.newInstance("zhul", 10);

System.out.println("通过构造函数(Demo) ct.newInstance(\"zhul\", 10)实例化：" + demo.toString());

}

}

//获取父类信息

Class<?> temp = demoClass.getSuperclass(); //Java只能单继承，所以只有一个父类

System.out.println("父类名称：" + temp.getName());

//获取interface信息

Class<?> interfaces[] = demoClass.getInterfaces(); //Java可以支持多个接口，所以是数组

for (int i = 0; i < interfaces.length; i++) {

System.out.println("实现的接口 " + interfaces[i].getName());

}

}

}

输出：

构造函数 = com.xxx.test.Demo

构造函数 = com.xxx.test.Demo 参数： class java.lang.String 参数： class java.lang.Integer

通过构造函数(Demo) ct.newInstance("zhul", 10)实例化：Demo [age=10, userName=zhul]

父类名称：com.xxx.test.People

实现的接口 com.xxx.test.Test

反射实例应用

一 什么是 Java反射机制 有什么用

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

（2）：Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。

（可以进行百度或google 有详细的解释 嘻嘻 偷点懒）

二 Java反射机制主要提供了以下功能

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

用实例 来说明

(1) class 类的使用：获取类的属性、方法、构造方法、类的相关信息

[java] view
plaincopy

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

/**

*

* @author lijian

*class 类的使用：获取类的属性、方法、构造方法、类的相关信息

*/

public class TestClass_1 {

public static void main(String[] args) throws ClassNotFoundException {

//forName(String className)返回与带有给定字符串名的类或接口相关联的 Class 对象。

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

//getDeclaredFields();返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段，包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。

Field[] field = clazz.getDeclaredFields();

System.out.println("---------------------显示类的属性----------------------------");

for (Field f : field) {

//getName()返回此 Field 对象表示的字段的名称

//getType()返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。

System.out.println(f.getName() + " " + f.getType());

}

System.out.println("---------------------显示类的方法-----------------------------");

//getDeclaredMethods() 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。

Method[] method = clazz.getDeclaredMethods();

for (Method m : method) {

System.out.println(m.getName());

}

System.out.println("---------------------显示类的构造方法-----------------------------");

//getDeclaredConstructors() 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

Constructor[] constructors = clazz.getDeclaredConstructors();

for(Constructor c:constructors)

{

System.out.println(c);

}

System.out.println("----------------------获取类的相关的信息----------------------------------------------");

System.out.println("类所在的包为："+ clazz.getPackage().getName());

System.out.println("类名："+ clazz.getName());

System.out.println("父类的名称："+ clazz.getSuperclass().getName());

}

}

（可以运行瞧瞧效果····嘿嘿）

以下示例中会使用到User.java类，其代码如下：

[java] view
plaincopy

public class User {

private String name;

private int age;

public User(){}

public User(String name, int age) {

}

属性的setter 和getter 方法 省略······

(2)生成一个类的Class对象有一下四种方式

[java] view
plaincopy

import entity.User;

/**

*

* @author lijian

* 创建Class对象的4种方法

*/

public class TestClass_2 {

public static void main(String[] args) throws ClassNotFoundException {

User user = new User();

// 第一种：对象.Class

Class clazz = user.getClass();

// 使用包装器获取Class 对象

String str = "asdasd";

clazz = str.getClass();

// 第二种 ：类.class

clazz = User.class;

clazz = String.class;

clazz = Integer.class;

// 第三种：Class.forname();

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

clazz = Class.forName("java.lang.Long");

//第四种：包装类.type

clazz = Integer.TYPE;

}

}

(3)使用反射动态创建对象实例 有两种方式：

方法一：通过Class的newInstance()方法

该方法要求该Class 对象的对应类有无参构造方法

执行newInstance()实际上就是执行无参构造方法来创建该类的实例

方法二：通过Constructor的newInstance() 方法

先使用Class对象获得指定的Constructor对象

再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象

通过该方法可以选择使用指定的构造方法来创建对象

下面就两种方法写个简单的实例

[java] view
plaincopy

import java.lang.reflect.Constructor;

import entity.User;

/**

*

* @author lijian

* 使用反射 动态创建对象 两种方式

*/

public class TestClass_3 {

public static void main(String[] args) throws Exception {

/**

* 方法1：通过Class的newInstance()方法

* 该方法要求该Class对象的对应类有无参构造方法

* 执行newInstance()实际上就是执行无参构造方法来创建该类的实例

*/

// Class clazz = Class.forName("entity.User");

// Object obj = clazz.newInstance();

/**

* 方法2：通过Constructor的newInstance()方法

* 先使用Class对象获取指定的Constructor对象

* 再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象

* 通过该方法可选择使用指定构造方法来创建对象

*/

Class clazz = Class.forName("entity.User");

//指定有参的构造方法

Constructor cons = clazz.getConstructor(new Class[] {int.class,String.class,String.class});

//使用有参数的构造方法实例对象

Object obj = cons.newInstance(new Object[]{1,"scott","1234"});

//转换为实际操作类

User user = (User)obj;

//也可以调用无参构造方法，比第一种方法复杂

obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{});

user = (User)obj;

//以下也可以调用无参构造方法

obj = clazz.getConstructor().newInstance();

//转换为实际操作类

user = (User)obj;

}

}

（4）使用反射动态修改查询的属性值

通过Class对象的getFields() 或者getField()方法可以获得该类所包括的全部Field属性或指定Filed属性。Field类提供了以下方法来方法访问属性

getXxx(Object obj) ：获取obj对象该Field的属性值。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用get(Objectobj)

setXxx(Object obj,Xxx val) ：将obj对象的该Field赋值val。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用set(Objectobj, Object val)

setAccessible(Boolean flag)：若flag为true，则取消属性的访问权限控制，即使private属性也可以进行访问

[java] view
plaincopy

import java.lang.reflect.Field;

/**

*

* @author lijian

* 使用反射动态修改查询属性值

*/

public class TestClass_4 {

public static void main(String[] args) throws Exception {

Class clazz = Class.forName("entity.User");

Object obj = clazz.newInstance();//获得类的实例

//获得 User 类中的指定属性对应的Field对象（每个属性对应一个Field对象）

Field field = clazz.getDeclaredField("name");

//取消属性的访问权限控制，即使private 属性也可以进行访问

field.setAccessible(true);

//调用 getter 方法获取属性值

System.out.println(field.get(obj));

//调用setter 方法给属性赋值

field.set(obj, "scott");

//调用 getter 方法获取对应属性修改后的值

System.out.println(field.get(obj));

}

}

（5）使用反射动态执行方法

通过Class对象的getMethods()方法可以获得该类所包括的全部方法，返回值是Method[]

通过Class对象的getMethod() 方法可以获得该类所包括的执行方法，返回值是Method

每个Method对象对应一个方法，获得Method对象后，可以调用其invoke() 来调用对应方法

Objectinvoke(Object obj , Object [] args): obj代表当前方法所属的对象的名字，

args代表当前方法的参数列表，

返回值Object是当前方法的返回值，即执行当前方法的结果。

[java] view
plaincopy

import java.lang.reflect.Method;

import entity.User;

/**

*

* @author lijian

* 使用反射动态执行方法

*/

public class TestClass_5 {

public static void main(String[] args) throws Exception{

Class clazz = User.class;

Object obj = clazz.newInstance();

//调用该对象的 setName方法

Method method = clazz.getMethod("setName", new Class[]{String.class});

Object result =method.invoke(obj, new Object[]{"scott"}); // obj.setName("scott");

System.out.println("返回值为："+result);

//调用对象的getName()方法

Method method1 = clazz.getMethod("getName", new Class[]{});

Object obj1 = method1.invoke(obj, new Object[]{});

System.out.println("返回值为："+obj1);

}

}

（6）使用反射动态创建数组并存取元素

在java.lang.reflect包下提供了Array类，包括一系列static方法，通过这些方法可动态的创建数组、给元素赋值、取出元素值等

Array提供的主要方法如下：

static ObjectnewInstance(Class<?> componentType, int[] dim) ：创建一个具有指定的组件类型和维度的新数组

static void setXxx(Objectarray, int index ，xxx val)：给数组对象array中第index个元素赋值val

static xxx getXxx(Objectarray, int index)：以 xxx形式返回指定数组对象array中第index个元素值
<1>动态创建一维数组，并给数组赋值：

[java] view
plaincopy

import java.lang.reflect.Array;

/**

*

* @author lijian

* 动态创建一维数组，并给数组赋值：

*/

public class TestClass_6 {

public static void main(String[] args) throws Exception {

Class clazz = Class.forName("java.lang.Integer");

Object array = Array.newInstance(clazz, 10);//根据类的class 创建大小为10的数组

Array.set(array, 5, 10);//给数组的第5个元素赋值为10

Object el = Array.get(array, 5);//取出数组的第5个元素值显示

System.out.println(el);

}

}

<2>动态创建二维数组，并给数组赋值：

[java] view
plaincopy

import java.lang.reflect.Array;

/**

*

* @author lijian

*动态创建二维数组，并给数组赋值：

*/

public class TestClass_7 {

public static void main(String[] args) {

int dims[] = {10,15};

Object array = Array.newInstance(int.class, dims);//创建一个10行15列二维数组，等价与：array[10][15]

Object array1 = Array.get(array, 5);//获取二维数组中的第5行

Array.set(array1, 8, 300); //给数组的第5行8列赋值300，等价与：array[5][8]=300

Object el = Array.get(array1, 8);//取出数组中第5行8列的值

System.out.println(el);

}

}

总结一下：

以上就是反射机制的简单的使用 （呵呵 很简单 就是对方法的调用而已， 希望对刚刚对初学或菜鸟们有帮助 ）

其实吧 我也不知道啥总结 我也只是总结了一句话而已

"反射就是拿面镜子自己照自己 自己有的东西 通过镜子可以全部显示出来"(就上面的例子而言，本人涉及不深 就是看Api来的 总结不出高深的来，见笑了)

想要深入的了解这个Java反射机制 还得自己去挖掘 ，就项目的需求去做，其实吧Struts2 也是用到了反射机制（有很多都用到了，想要深入Java，Java反射机制是必须要掌握的） ， 但是现在还不是弄那个的时候

虽然本人是菜鸟 但是“菜鸟先飞”（笨鸟先飞）总有一天会飞到那个高度的（虽然需要的时间多了点，但是坚持就是胜利！）。各位菜鸟加油了！！！