Java反射

Java反射

类有类类型

首先，记住一句话：There is a class named Class

public class ClassDemo1{
public static void main(String[] args) {
Foo foo1 = new Foo();
}
}
class Foo{}

看上面这段代码：我们称Foo为一个类，由于在面向对象的世界里，万事万物皆对象，所以这个类也有类型，那么如何表示这个类的类型呐？有三种方式

Class c1 = Foo.class;

c1就是Foo类的类类型。这个语句也可以告诉我们，每一个类中都有一个隐含的静态成员变量class

Class c2 = foo1.getClass();

c2也是Foo类的类类型。这是通过已知类对象来获得类的类类型。

Class c3 = Class.forName("Foo");

c3同样表示Foo类的类类型。并且

c1==c2 && c2==c3

，因为c1 c2 c3 都代表了一个类的类类型。一个类只可能是Class类的一个实例对象。

我们还可以通过类的类类型创建该类的实例：

c1.newInstance();

注意这里的返回值是Object类型，所有要强制转化为该类的真实类型。另外：通过这种方式创建该类的实例必须保证该类有无参数的构造方法。

动态加载类

首先我们来区分下什么是动态加载类，什么是静态加载类。动态加载类是指编译时刻加载的类，动态加载类是指在运行时刻加载的类。

public class Office{
public static void main(String[] args) {
if("Word".equals(args[0])){
Word word = new Word();
word.start();
}
if("Excel".equals(args[0]){
Excel excel = new Excel();
excel.start();
}
}
}

如果编译上面这段代码，必然会编译错误。因为我们没有定义Word和Excel这两个类。如果我们去定义了Word类，不去定义Excel类，程序编译依然会报错。这是因为用new创建对象是静态加载类，在编译时刻就要加载所有可能使用到的类。 这样说明：即使我们只想要运行word也不能运行这个程序Office。那么如何才能通过动态加载类来解决这个问题呐？？

public class OfficeBetter{
public static void main(String[] args) {
try{
//在运行时刻动态加载类
Class c = Class.forName(args[0]);
OfficeAble oa = (OfficeAble)c.newInstance();
oa.start();
}catch (Exception e){
e.printStackTrace();
}
}
}

public class Word implements OfficeAble{
@override
public void start(){
System.out.println("Word started!");
}
}

interface OfficeAble{
public void start();
}

现在我们更新了Office类的代码为OfficeBetter并编写了一个接口和一个实现类，这是我们编译OfficeBetter类并不会出现编译错误。我们输入命令

java OfficeBetter Word

就可以运行word了，是不是变的更加方便了呐。

当我们需要运行新的Office软件的时候只需要编写新的OfficeAble的实现类，不需要修改或者重新编译OfficeBetter。

功能性的类我们最好使用动态加载而不是静态加载，这样便于以后的升级和维护。

通过反射获取方法信息

并不是只有类才有类类型，所有在类中出现的关键字都有自己的类类型。看下面的代码：

public class ClassDemo2{
public static void main(String[] args) {
Class c1 = int.class;   //int类类型
Class c2 = Integer.class;   //Integer类类型
System.out.println(c1==c2); //false

Class c3 = String.class; //String的类类型
Class c4 = void.class; //只要在类里面声明的，都有相应的类类型

System.out.println(c1.getName());       //int
System.out.println(c2.getName());       //java.lang.Integer
System.out.println(c2.getSimpleName()); //Integer
System.out.println(c4.getName());       //void

}
}

下面我们来编写一个通过反射来获取类的方法信息的静态方法，通过下面这个类你可以了解有关获取类的方法信息的一些基本操作

/**
* Created by Chang on 15/12/28.
*/
public class ClassUtil{
/**
* 打印类的信息，包括类的成员函数、成员变量
* @param obj
*/
public static void printClassMessage(Object obj){
//首先要获取类的类类型
Class c = obj.getClass(); // 传递的是那个子类的对象，c就是该子类的类类型
//获取类的名称
System.out.println("类的名称是："+c.getName());

/*
* Method类，对象方法
* 一个成员方法就是一个Method对象
* getMethods() 方法获取的是所有的public的函数，包括父类继承而来的
* getDeclaredMethods() 获取的是所有该类自己声明的的方法，不问访问权限，不包括父类继承的方法
*/
Method[] ms = c.getMethods();
for(int i=0; i<ms.length; i++){
//得到方法的返回值类型的类类型
Class returnType = ms[i].getReturnType();
System.out.print(returnType.getName()+" ");
//得到方法的名称
System.out.print(ms[i].getName()+"(");
//获取参数类型--->得到的是参数列表类型的类类型
Class[] paramTypes = ms[i].getParameterTypes();
for(Class class1:paramTypes){
System.out.print(class1.getName()+",");
}
System.out.println(")");

}
}
}

获取成员变量和构造函数信息

获取成员变量信息

成员变量也是对象,是java.lang.reflect.Field的对象

Field类封装了关于成员变量的操作

getFields()方法获取的所有的public的成员变量信息

getDeclaredField()方法获取的是所有该类自己声明的成员变量的信息

Field[] fields = c.getFields();
for(Field field:fields){
//得到成员变量的类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getTypeName();
//得到成员变量的名称
String fieldName = field.getName();
System.out.println(typeName+" "+fieldName);
}

获取构造方法

构造函数也是对象 java.lang.Constructor

getConstructors()方法获取所有的public的构造函数

getDeclaredConstructors()方法获取所有的(该类的)构造方法

public static void printConMessage(Object object){
Class c = object.getClass();

Constructor[] constructors = c.getConstructors();
for (Constructor constructor:
constructors) {
System.out.print(constructor.getName()+"(");
//获取构造函数的参数列表
Class[] paramTypes = constructor.getParameterTypes();
for (Class class1:
paramTypes){
System.out.print(class1.getName()+",");
}
System.out.println(")");

}
}

还有更多关于Class类的方法，可以查看相关API

方法的反射操作

如何获取某个方法：方法的名称和方法的参数列表才能唯一决定某个方法

方法反射的操作：method.invoke(对象，参数列表)

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
* Created by Chang on 15/12/29.
*/
public class MethodDemo1 {
public static void main(String[] args) {
//1.要获取print(int,int)方法
A a1 = new A();
Class c = a1.getClass();
//2. 获取方法 名称和参数列表来决定
try {
//          Method method = c.getMethod("print",new Class[]{int.class, int.class});
Method method = c.getMethod("print",int.class,int.class);

//方法的反射操作,方法如果没有返回值object为null,如果有返回值就返回相应的值(需要强制转换)
Object object = method.invoke(a1,1,2);

System.out.println("=====================");
Method method1 = c.getMethod("print",String.class,String.class);
method1.invoke(a1,"a","a");
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}

class A{
public void print(int a, int b){
System.out.println(a+b);
}

public void print(String a,String b){
System.out.println(a.toUpperCase()+","+b.toLowerCase());
}
}

通过反射机制了解集合范型的本质

泛型在编译之后是去泛型化的，可以通过方法的反射来添加不同的类型

**
* Created by Chang on 15/12/29.
*/
public class MethodDemo4 {
public static void main(String[] args) {
ArrayList list  = new ArrayList();

ArrayList<String> list1 = new ArrayList<>();

Class c1 = list.getClass();
Class c2 = list.getClass();
list1.add("Hello");
//list1.add(1);     //会报错
//反射操作是编译之后的操作
System.out.println(c1==c2);//True

/**
* c1==c2为真,说明编译之后的集合的泛型是去泛型化的
* Java中集合的类型,是防止输入错误的,只在编译阶段有效,绕过编译就无效了
* 可以通过方法的反射来操作
*/

try {
Method m = c1.getMethod("add",Object.class);
m.invoke(list1,10);
System.out.println(list1.size());
//通过反射操作就绕过了泛型,可是这样不能通过指定类型的foreach遍历
System.out.println(list1);

//因为其中有一个类型不是String会有错误
//            for (String s:
//                 list1) {
//                System.out.println(s);
//            }
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}

}

}