反射基本概念与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中集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译阶段就无效了，因此可以通过反射绕过编译
