Java反射原理

一、Class类的应用

1.类类型的对象该如何表示

public class Foo{
public void say(){
System.out.println("hello world");
}
}

public class ClassDemo1{
public static void main(String[] args){
//Foo的实例对象
Foo foo1 = new Foo();
//Foo这个类本身也是一个实例对象
//任何一个类都是Class类的实例对象
//这个实例对象有三种表示方式

//第一种方式，实际在告诉我们任何一个类都有一个隐含的静态成员变量
Class clazz1 = Foo.class;

//第二种方式，已知该类的对象，通过getClass方法得到
Class clazz2 = foo1.getClass();

//第三种表达方式，通过Class类的静态方法forName()加全限定名
try{
Class clazz3 = Class.forName("com.destiny.reflect.Foo");
}catch(ClassNotFoundException e){
e.printStackTrace();
}

//不管clazz1还是clazz2都代表了Foo类的类类型，一个类只可能是一个Class类的一个实例对象
System.out.println(clazz1 == clazz2);
//官方文档：clazz表示了foo类的类类型
//万事万物皆对象，是Class类的对象，这个对象我们称之为该类的类类型

//我们完全可以通过类的类类型创建该类的实例对象，即通过clazz创建Foo的实例对象
Foo foo1 = clazz1.newInstance();
foo1.say();

}
}

编译：编译时期加载类是静态加载类

运行：运行时期加载类是动态加载类

public class Word{
public static void start(){
System.out.println("word......start");
}
}

public class Office{
public static void main(){
//由于我们只有Word类而没有Excel类，因此本类在编译时无法通过
//new创建对象属于静态加载类，在编译时期就需要加载所有可能使用到的类
//通过动态加载类可以解决该问题
if("word".equals(args[0])){
Word w = new Word();
w.start();
}
if("excel".equals(args[0])){
Excel e = new Excel();
e.start();
}
}
}

public class OfficeBetter{
<span style="white-space:pre">	</span>public static void main(String[] args){
<span style="white-space:pre">	</span>try{
//动态加载类，在运行时刻加载
Class clazz = Class.forName(args[0]);
//通过类类型创建对象
//使用Word与Excel的抽象接口OfficeAble
OfficeAble oa = (OfficeAble)clazz.newInstance();
oa.start();
}catch(ClassNotFoundException e){
e.printStackTrace();
}
}
}

2.基本数据类型

类中存在的关键字都存在类类型

public class ClassDemo2{
public static void main(String[] args){
//int的类类型
Class clazz1 = int.class;
//String的类类型，String类字节码
Class clazz2 = String.class;

Class clazz3 = double.class;
Class clazz4 = void.class;

System.out.println(clazz2.getName());		//java.lang.String
System.out.println(clazz2.getSimpleName());	//String
}
}

public class ClassUtil{
//打印类的信息，包括类的成员变量、成员函数
public static void printClassMessage(Object obj){
//要获取类的信息，首先要获取类的类类型
//一直参数obj，是一个对象
Class clazz = obj.getClass();
System.out.println("类的名称是："+clazz.getName());
//Method是方法的对象
//一个成员方法就是一个method对象
//getMethods()方法获取的是所有public方法，包括从父类继承而来的
//getDeclaredMethod()获取的是所有该类自己生命的方法，无视访问权限
Method[] methods = clazz.getMethods();
for(int i = 0; i < methods.length; ++i){
//得到方法的返回值类型的类类型
Class returnType = methods[i].getReturnType();
//通过返回值的类类型打印返回值类型
System.out.println(returnType.getName()+" ");
//得到方法名称
System.out.println(methods[i].getName()+"(");
//获取参数类型===>得到的是参数裂变的类型的类类型
Class[] paramTypes = methods[i].getParamTypes();

for(Class clazz : paramTypes){
System.out.println(class.getName()+",");
}

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

3.成员变量的反射

成员变量也是对象

java.lang.reflect.Field
Field类封装了关于成员变量的操作

Field[] fields = clazz.getFields();
//Field[] fields = clazz.getDeclaredFields();
for(Field field : fields){
//得到成员变量类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getName();
//得到成员变量的标识符
String fieldName = field.getName();
}

二、方法的反射操作

1.如何获取某个方法

一个方法的名称和其参数列表可以唯一决定一个方法

2.方法反射的操作

method.invoke(对象, 参数列表);

3.案例

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

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

public class MethodDemo1{
public static void main(String[] args){
//获取print(int, int)方法
//1.获取类的类类型
A a = new A();
Class clazz = a.getClass();
//2.获取方法，名称和参数列表来决定
//getMethod()获取的是public
Method method = clazz.getMethod("print", new Class[]{int.class, int.class});
Method method = clazz.getMethod("print", int.class, int.class);

//方法的反射操作
//用方法对象来进行调用
//如果方法没有返回值，那么obj的值为null
//如果方法有返回值，那么obj就是该方法的返回值，需要强制类型转换
Object obj = method.invoke(a, new Object[]{10, 20});
Object obj = method.invoke(a, 10, 20);
}
}

三、通过Class, Method了解泛型的本质

反射的操作都发生在运行期

public class MethodDemo4{
List list1 = new ArrayList();
List<String> list2 = new ArrayList<String>();
list2.add("hello");
//list2.add(10);
Class clazz1 = list1.getClass();
Class clazz2 = list2.getClass();

System.out.println(clazz1 == clazz2);
//输出结果为true，说明编译之后的结果是去泛型化
//即编译后，list2不再具有泛型
//java中集合的泛型是防止错误输入，只在编译阶段有效，绕过编译泛型就不再发生作用
//我们可以通过方法的反射绕过编译
Method method = clazz2.getMethod("add", Object.class);
//绕过编译执行add方法
method.invoke(list2, 10);
//添加成功，成功绕过泛型的限制
System.out.println(list2.size);
}