反射基本概念与Class(三)：包信息和方法

Class类的使用

Java中，静态成员、普通数据类型不是对象，静态成员是属于类的，而不是属于某个对象的

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

public static void main(String[] args){
//Foo的实例对象
Foo foo1 = new Foo();
//Foo这个类 本身也是一个实例对象 它是Class类的实例对象
//任何一个类都是Class类的实例对象，这个实例对象有三种表示方式
//第一种-->实际告诉我们任何一个类都有一个隐含的静态成员变量class
Class c1 = Foo.class;

   //第二种-->通过该类的对象的getClass()方法得到
   Class c2 = foo1.getClass();
   
   //c1,c2表示了Foo类的类类型(class type)
   //一个类只可能是Class类的一个实例对象
   
   //第三种
   Class c3 = null;
   try{
       c3 = Class.forName("xxx.Foo");
   }catch(ClassNotFoundException e){
       e.printStackTrace();
   }
   //c1 = c2 = c3
   
   //通过该类的类类型创建该类的对象实例
   Foo foo = (Foo)c1.newInstance();//需要有无参数的构造方法
 }
}
class Foo{}

所有的数据类型（int, String, Integer）以及void都有自己的类类型，通过int.class可以得到相应的类类型

Java动态加载类

编译时加载类时静态加载类，运行时加载类时动态加载类，可以通过Class.forName()动态加载类

下面是一个静态加载类的例子：

Class Test{
  public static void main(String[] args){
    if("A".equals(args[0])){
        A a = new A();
        a.start();
    }
    if("B".equals(args[0])){
        B b = new B();
        b.start();
    }
}
}

Class A{
    public static void start(){
        System.out.println("A start");
    }
}

结果是编译出错。

new 创建对象是静态加载类，在编译时刻就加载所有可能用到的类，就算我们写了A类，但是因为没有B类，编译时还是不会通过。如果我们想使用更多的类，我们就要在一开始把所有类写好，当以后想要扩展时，就要重新编译！

下面通过Class.forName()动态加载类

class Test1{
    public static void main(String[] args){
        Class c1 = null;
        try{
            c1 = Class.forName(args[0]);
        }catch(ClassNotFoundException e){
          e.printStackTrace();
      } 
    }
}

这样 编译就不会报错，在我们使用的时候，传入想要运行的类名称即可。

接下来我们可以通过上面提到的newInstance()方法来创建对象，并通过强制类型转换编程我们想要用的对象。但是这里有一个问题，就是我们不知道我们传入的究竟是A类还是B类，所以在做强制类型转换的时候并不知道要转换成什么，解决办法就是为他们创建一个接口，实现其共有的方法

MyChar myChar = (MyChar)c1.newInstance();
myChar.start();

其中

interface MyChar(){
    public void start();
}

这时我们只需要用A类实现该接口即可

class A implements MyChar{
    public void start(){
        System.out.println("A start");
    }
}

编译通过，我们不需要用B类即可，当我们想用B类的时候，只需要用B类实现该接口即可。如果我们想使用更多的类，只需要实现该接口即可，不需要每次都重新编译。因此，在设计程序时，可以尽可能的考虑动态加载类

获取类的信息

1.获取方法信息

//首先要得到该类的类类型
Class c = foo1.getClass();
//获取类的名称
String name = c.getName();
//获取类的方法
Methods[] ms = c.getMethods();//万事万物皆对象，每一个方法都是Method的对象
//getMethods()得到的是所有public函数，包括从父类继承来的
//getDeclaredMethods()得到的是该类自己声明的方法，不论访问权限

//获取方法的信息
for(int i = 0; i<ms.length;i++){
    //得到方法的返回值的类类型，如int.class, String.class
    Class returnType = ms[i].getReturnType();//returnType.getName()即得到返回值的名称
    //得到方法的名称
    String methodName = ms[i].getName();
    //获取参数类型：得到的是参数列表的类类型
    Class[] paramTypes = ms[i].getParameterTypes();//遍历通过getName()即可得到参数类型名称
}

下面是获取某个具体方法

Method method = XXX.getClass().getMethod(methodName,new Class[0]);
//getMethod第一个参数是方法名，第二个参数是该方法的参数类型,按传入顺序，
//因为存在同方法名不同参数这种情况，所以只有同时指定方法名和参数类型才能唯一确定一个方法
//没有参数传入null，获取不传
//如一个函数 int test(int a, String b);
//getMethod("Test",int.class,String.class);

得到的是一个方法对象，通过调用invoke()函数来调用此方法

//函数原型：Object Java.lang.reflect.Method.invoke(Object receiver, Object... args)

//Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，
 //如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，
  //如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，再将其返回

//receiver：该方法所在类的一个对象
//args： 传入的参数 如 100，“hello”，没有就不传
//下面是一个完整例子
class Foo{
    public void run(String str) {
        System.out.println("Foo run " + str);
    }
}
public class Demo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Foo foo1 = new Foo();
        Class<? extends Foo> c1 = foo1.getClass();
        System.out.println(c1.getName());
        try {
            Method method = c1.getMethod("run", String.class);
            method.invoke(foo1, "test reflect");
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果：

study_refect.Foo
Foo run test reflect

2.获取成员变量的信息

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

Field[] fs = c.getFields();//获取的是public成员变量信息
//getDeclaredFields()获取的是该类所有成员变量
for(Field field:fs){
    //得到成员变量的类类型
    Class fieldType = field.getType();
    String typeName = fieldType.getName();
    //得到成员变量的名称
    String fieldName = field.getName();
}

3.获取构造函数的信息

构造函数也是对象，是java.lang.Constructor的对象,获取方法这里不再赘述

通过反射理解泛型的本质（类型擦除）

Java中的泛型是通过类型擦除来实现的。所谓类型擦除，是指通过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。

下面通过两个例子来证明在编译时确实发生了类型擦除。

例1分别创建实际类型为String和Integer的ArrayList对象，通过getClass()方法获取两个实例的类，最后判断这个实例的类是相等的，证明两个实例共享同一个类。

// 声明一个具体类型为String的ArrayList
ArrayList<String> arrayList1 = new ArrayList<String>();  
arrayList1.add("abc");  

// 声明一个具体类型为Integer的ArrayList
ArrayList<Integer> arrayList2 = new ArrayList<Integer>();  
arrayList2.add(123);  

System.out.println(arrayList1.getClass() == arrayList2.getClass());  // 结果为true

例2创建一个只能存储Integer的ArrayList对象，在add一个整型数值后，利用反射调用add(Object o)add一个asd字符串，此时运行代码不会报错，运行结果会打印出1和asd两个值。这时再里利用反射调用add(Integer o)方法，运行会抛出codeNoSuchMethodException异常。这充分证明了在编译后，擦除了Integer这个泛型信息，只保留了原始类型。

ArrayList<Integer> arrayList3 = new ArrayList<Integer>();
arrayList3.add(1);
arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");
for (int i = 0; i < arrayList3.size(); i++) {
    System.out.println(arrayList3.get(i)); // 输出1，asd
}
arrayList3.getClass().getMethod("add", Integer.class).invoke(arrayList3, 2); // NoSuchMethodException：java

Java中集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译阶段就无效了，因此可以通过反射绕过编译