java反射简介

想要了解反射，最基本的类就是Class类，因为Class能够保存类的信息。在类中含有构造方法、函数、属性。这些都能够通过某种手段得到。

1.获得字节码的方法：

（1）Class.forName(String)

（2）p.getClass();

（3）P.class;

Class c1 =...;

c1.getDeclaredConstructors();返回一个Constructor数组。 包含一个类中的构造函数。

2.通过构造方法进行反射：newInstance

getConstructor(Class)进行对某个类的构造函数进行声明。

newInstance(Object);能够创建一个实例。

以下为实例：

view
plain

Constructor c = String.class.getConstructor(StringBuffer.class);

String str = (String) c.newInstance(new StringBuffer("123"));

System.out.println(str);

这样就能够创建一个String的实例。

3.对于域的反射：get

能够反映出当前对象的域的值是多少.

私有变量的反射需要f.setAccessible(true);

view
plain

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

public class ReflectField {

public static void main(String[] args) {

ReflectPoint o = new ReflectPoint(1, 2);

Field fy = null;

try {

fy = o.getClass().getDeclaredField("y");

fy.setAccessible(true);

Integer x = (Integer) fy.get(o);

System.out.println(x);

} catch (Exception e) {

e.printStackTrace();

}

}

}

class ReflectPoint {

private int x;

private int y;

public ReflectPoint(int x, int y) {

super();

this.x = x;

this.y = y;

}

}

示例：有一个类，其中包含很多字符串的属性，想要把每个字符串属性中的‘b’变成‘a’，并显示结果

view
plain

import java.lang.reflect.AccessibleObject;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

public class ReflectField {

public static void main(String[] args) {

ReflectPoint o = new ReflectPoint(1, 2);

Field[] fs ;

try {

fs = o.getClass().getDeclaredFields();

AccessibleObject.setAccessible(fs, true);

for(Field f:fs)

{

if(f.getType() ==String.class)

{

String str = (String)f.get(o);

String result = str.replace("b", "a");

f.set(o, result);

System.out.println(result);

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

class ReflectPoint {

private int x;

private int y;

private String str1 = "basketball";

private String str2 = "ball";

private String str3 = "it";

public ReflectPoint(int x, int y) {

super();

this.x = x;

this.y = y;

}

}

4.方法反射：

(1)getMethod()声明

(2)invoke()方法调用

view
plain

import java.lang.reflect.AccessibleObject;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class ReflectField {

public static void main(String[] args) {

ReflectPoint o = new ReflectPoint();

try {

Method m = o.getClass().getDeclaredMethod("getStr1", null);

String name = (String) m.invoke(o, null);

System.out.println(name);

} catch (Exception e) {

e.printStackTrace();

}

}

}

class ReflectPoint {

private String str1 = "busketBall";

public ReflectPoint() {

super();

}

public String getStr1()

{

return str1;

}

}

Constructor：

(1)getModifiers()；返回访问权限。能够由Modifier.toString(i)转换成字符串。

(2)getName();返回构造函数的函数名。

(3)getParameterTypes()返回参数的Class，需要对每个参数Class调用getName()获得参数类型。

c1.getDeclaredFields();返回一个Field数组。 包含一个类中的属性。

Field：

(1)getType()返回属性类型

(2)f.get(Object obj);Obj是一个类，包含f属性，返回当前f属性的当前值。

(3)int i=getModifiers()返回访问权限。能够由Modifier.toString(i)转换成字符串。

(4)getName()返回属性名称。

(5)f.set(Object obj,Object val);把Object类中的f属性设置为val值。

c1.getDeclaredMethods()返回一个Method数组。 包含一个类中的一般方法。

Method：

(1)getModifiers()返回访问权限。能够由Modifier.toString(i)转换成字符串。

(2)getName();返回函数的函数名。

(3)getParameterTypes()返回参数的Class，需要对每个参数Class调用getName()获得参数类型。

(4)getReturnType()返回值的类型

下面是一个示例代码，输入一个类，然后把输入类的构造方法，域，函数都打印出来：

view
plain

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.Scanner;

public class ReflectTest {

public static void main(String args[])

{

Scanner in = new Scanner(System.in);

String str = in.nextLine();

Class c = null;

try {

c = Class.forName(str);

} catch (ClassNotFoundException e) {

System.out.println("********出错！********");

e.printStackTrace();

}

String tmp = Modifier.toString(c.getModifiers());

System.out.println(tmp+" class "+c.getName()+"{");

printField(c);

printConstructor(c);

printMethod(c);

System.out.println("}");

}

public static void printField(Class c)

{

Field[] f = c.getDeclaredFields();

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

{

int p = f[i].getModifiers();

String tmp = Modifier.toString(p);

String type = f[i].getType().getName();

String name = f[i].getName();

System.out.println(" "+tmp+" "+type+" "+name+";");

}

}

public static void printConstructor(Class c)

{

Constructor[] con = c.getDeclaredConstructors();

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

{

int p = con[i].getModifiers();

String tmp = Modifier.toString(p);

String name = con[i].getName();

Class[] param = con[i].getParameterTypes();

System.out.print(" "+tmp+" "+name+"(");

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

{

System.out.print(param[j].getName());

}

System.out.println(");");

}

}

public static void printMethod(Class c)

{

Method[] m = c.getDeclaredMethods();

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

{

int p = m[i].getModifiers();

String tmp = Modifier.toString(p);

String type = m[i].getReturnType().getName();

String name = m[i].getName();

Class[] param = m[i].getParameterTypes();

System.out.print(" "+tmp+" "+type+" "+name+"(");

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

{

System.out.print(param[j].getName());

}

System.out.println(");");

}

}

}