在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。
Class类
1）在面向对象的世界里，万事万物皆对象。
类是对象，任何一个类都是java.lang.Class类的实例对象，这个对象我们称为该类的类类型
这个实例对象有三种表示方式
第一种：实际在告诉我们任何一个类都有一个隐含的静态成员变量class
第二种：已经知道该类的对象通过getClass方法
第三种：直接通过Class.forName
package com.reflect.Foo;
public class ClassDemo1{
public static void main(String[] args){
Foo foo1 = new Foo();//是一个实例对象
//第一种
Class c1 = Foo.class;
//第二种
Class c2 = foo1.getClass();
//一个类都只可能是Class类的一个实例对象
System.out.println(c1==c2);//true
//第三种
Class c3 = null;
try{
c3 = Class.forName("com.reflect.Foo");
}catch(ClassNotFoundException e){
e.printStackTrance();
}
System.out.println(c2==c3);//true
//我们完全可以通过类的类类型创建该类的对象实例->通过c1 or c2 or c3创建Foo的实例
try{
Foo foo = (Foo)c1.newInstance();
foo.print();
}catch(InstantiationException e){
e.printStackTrace();
}catch(IllegalAcessException e){
e.printStackTrace();
}
}
}
class Foo{}
动态加载类
Class.forName("类的全称")
1、不仅表示了类的类类型，还代表了动态加载类
2、区分编译、运行。编译时刻加载类是静态加载类，运行时刻加载类是动态加载类
3、基本的数据类型，void关键字，都存在类类型
new创建的对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类，通过动态加载类可以解决该问题，即在需要的时候再创建类的实例对象（与单例模式的懒汉模式相似）
public class ClassDemo2{
public static void main(String[] args){
Class c1 = int.class;//int的类类型
Class c2 = String.class;//String类的类类型
Class c3 = double.class;
Class c4 = Double.class;
Class c5 = void.class;
System.out.println(c1.getName());
System.out.println(c2.getName());
System.out.println(c2.getSimpleName());//不包含包名的类的名称
System.out.println(c5.getName());
}
}
输出为：
int
java.lang.String
String
void
获取方法信息
public class ClassUtil{
/**
* 打印类的信息，包括类的成员函数、成员变量(可分开获取)
*/
public static void printClassMessage(Object obj){
//要获取类的信息，首先要获取类的类类型
Class c = obj.getClass();//传递的是哪个子类的对象，c 就是该子类的类类型
//获取类的名称
System.out.print("类的名称是：" + c.getName());
/**
*Method类，方法对象
*一个成员方法就是一个Method对象
*getMethods()方法获取的是所有的public的函数，包括父类继承而来的
*getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问
*/
Method[] ms = c.getMethods();//c.getDeclaredMethods()
for(int i=0;i<ms.length;i++){
//得到方法的返回值类型的类类型
Class returnType = ms[i].getReturnType();
System.out.println(returnType.getName()+" ");
//得到方法的名称
System.out.println(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类封装了关于成员变量的操作
*getField()方法获取的是所有的public的成员变量的信息
*getDeclaredField()获取的是所有该类自己声明的成员变量的信息
*/
Field[] fs = c.getDeclaredField();
for(Field field:fs){
//得到成员变量的类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getName();
//得到成员变量的名称
String fieldName = field.getName();
System.out.println(typeName+" "+fieldName);
}
}
/**
* 打印对象的构造函数的信息
*/
public static void printConMessage(Object obj){
Class c = obj.getClass();
/*
*构造函数也是对象
*java.lang.Constructor中封装了构造函数的信息
*getConstructors获取所有的public的构造函数
*getDeclaredConstructors得到所有的构造函数
*/
Constructor[] cs = c.getDeclaredConstructors();
for(Constructor constructor:cs){
System.out.print(constructor.getName()+"(");
}
//获取构造函数的参数列表--->得到的是参数列表的类类型
Class[] paramTypes = constructor.getParameterTypes();
for(Class class1:paramTypes){
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}
public class MethodDemo1{
public static void main(String[] args){
String s = "hello";
ClassUtil.printClassMessage(s);
//Integer i = 1;
//ClassUtil.printClassMessage(i);
}
}
方法的反射
1）如何获取某个方法
方法的名称和方法的参数列表才能唯一决定某个方法
2）方法反射的操作
method.invoke(对象，参数列表)
public class MethodDemo2{
public static void main(String[] args){
//要获取print(int,int)方法 1、要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
A a1 = new A();
Class c = a1.getClass();
//2、获取方法，由名称、参数列表决定
//getMethod获取的是public的方法
//getDeclaredMethod获取自己声明的方法
try{
//第二个参数为可变参数
Method m = c.getMethod("print",new Class[]{int.class,int.class});
//Method m = c.getMethod("print",int.class,int.class);
//方法的反射操作
//是用m对象来进行方法的调用 和a1.print调用的效果一样
//方法如果没有返回值返回null，有返回值返回具体的返回值
Object o = m.invoke(a1,new Object[]{10,20});
//Object o = m.invoke(a1,10,20);
System.out.println("=========================");
//获取方法print(String,String)
Method m1 = c.getMethod("print",String.class,String.class);
//用方法进行反射操作
o = m1.invoke(a1,"hello","WORLD");
System.out.println("=========================");
Method m2 = c.getMethod("print",new Class[]{});
//Method m2 = c.getMethod("print")
m2.invoke(a1,new Object[]{});
//m2.invoke(a1);
}catch(Exception 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());
}
public void print(){
System.out.println("helloworld");
}
}
通过反射了解集合泛型的本质
public class MethodDemo3{
public static void main(String[] args){
ArrayList list = new ArrayList();
ArrayList<String> list1 = new ArrayList<String>();
list1.add("hello");
//list1.add(20);//错误
Class c1 = list.getClass();
Class c2 = list1.getClass();
System.out.println(c1==c2);//返回true
//反射的操作都是编译之后的操作
//c1==c2结果返回true说明编译之后几乎的泛型是去泛型化的
//Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
//绕过编译就无效了
//验证：可以通过方法的反射来操作，绕过编译
try{
Method m = c2.getMethod("add",Object.class);
m.invoke(list1,20);//绕过编译操作就绕过了泛型
System.out.println(list1.size());
System.out.println(list1);
//不能使用for-each遍历，否则会有类型转换错误
}catch(Exception e){
e.printStackTrace();
}
}
}
