JAVA入门之反射

Class类的使用

1. 万物皆对象

类是java.lang.Class类的实例对象。

2. 这个对象如何表示

class Foo{

}

Foo foo1 = new Foo();

Class c1 = Foo.class;

Class c2 = foo1.getClass();

// Class 是类类型
// 不管c1 or c2 都是Foo类的类类型，一个类只可能是Class类的一个实例对象。

Class c3 = null;
c3 = Class.forName("com.imooc.reflect.Foo");

// 可以通过类类型来创建该类对象实例
// 需有无参构造方法
Foo foo = (Foo)c1.newInstance();

Class动态加载类

编译时刻加载类是静态加载类。
运行时刻加载类是动态加载类。

// new 创建对象，是静态加载类。
// 在编译时刻就需要加载所有的可能用到的类

Word w = new Word();

// 动态加载类

Class a = Class.forName("类的全称");

OA oa =(OA)a.newInstance();

基本数据类型

Class c1 = int.class;
Class c2 = String.class;

c1.getName();
// int
c2.getName();
// Java.lang.String

打印类的信息

包括类的成员函数，成员变量。

public class ClassUtil{

  public static void printClassMessage(Object obj){
    Class c = obj.getClass();
    System.out.println("类的名称："+c.getName());
    
    /*
    *    获取成员函数
    */
    
    // 所有public方法
    Method[] ms = c.getMethods();
    // 该类所有自己声明的方法
    // c.getDeclaredMethods()
    
    for(int i = 0;i<ms.length;i++){
      
      // 得到方法返回值的 类类型
      Class returnType = ms[i].getReturnType();
      System.out.print(returnType.getName()+" ");
      
      // 得到方法名称
      System.out.print(ms[i].getName());
      
      System.out.print("(");
      // 获取参数类型
      // 得到参数列表的类型的类类型。
      Class[] paramTypes = ms[i].getParameterTypes();
      for(Class class1:ParamTypes){
        System.out.print(class1.getName()+",");
      }
      System.out.print(")");
      
    }
    
    /*
    *   获取成员变量
    */
    
    // 获取所有共有成员变量信息
    // Field[] fs = c.getFields();  
    
    // 获取该类所有自己声明的成员变量信息
    Field[] fs = c.getDeclaredFields();
    
    for(Field field : fs){
      Class fieldType = field.getType();
      String typeName = fieldtype.getName();
      String fieldName =  field.getName();
      
      System.out.println(typeName+" "+ fieldName);
    }
    
    /*
    *   获取构造函数
    *   getConstructors 获取所有公有
    *   getDeclaredConstructors 得到自己声明的
    *    （构造方法必须自己声明）
    */
    
    Constructor[] cs = c.getConstructors();
    
    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(")");
    }
    
  }
}

Java方法反射的基本操作

1. 如何获取某个方法

方法的名称和方法的参数列表能决定某个方法

2. 方法的反射操作

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());
  }
}

A a1 = new A();
Class c = a1.getClass();

// 获取方法名称和参数列表，来确定一个方法

Method m = c.getMethod("print",new Class[]{int.class,int.class});
// c.getMethod("print",int.class,int.class);

// 方法的反射操作
// Object o = m.invoke(a1,new Object[]{10,20})
Object o = m.invoke(a1,10,20)

集合泛型的本质

通过Class,Method来认识泛型的本质。

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

list1.add("hello");
// ok
list1.add(20);
// 抛出异常

Class c1 = list.getClass();
Class c2 = list1.getClass();

System.out.println(c1==c2);
// True
// 也就是说编译之后，两个集合是一样的。
// 即，编译后集合的泛型是去泛型化的。

// 尝试编译后对该集合操作。

Method m = c2.getMethod("add",object.class);
// 绕过编译操作
m.invoke(list1,20); 

System.out.println(list1.size())
System.out.println(list1);

// ["hello",20]