Java框架基础——反射(reflect)

一、Class类的使用

1）在面向对象(oop)的世界里，万事万物皆对象。
　　在Java中，包括基本的数据类型，都是对象。
　　Class c = int.class;//int 的类类型
　　那就是说：
　　类是对象，类是java.lang.Class类的实例对象。这个对象我们称之为类类型。
　　换言之，每一个类都有一个类类型，这个类类型就是java.lang.Class的实例对象
2）如何获取一个类的类类型（三种方法）

• 类名.class;
• 类的对象.getClass();
• Class.forName(“类的全称包含包名”);

　　class Foo{}
　　Foo foo1=new Foo();
　　1. Class c1 = Foo.Class;//任何一个类都有一个隐含的静态成员变量class
　　2. Class c2 = foo1.getClass()//已经知道该类的对象通过getClassF方法
　　3. Class c3 = null;
　　c3 = Class.forName("com.immoc.reflect.Foo");
　　//of course, c1 == c2 == c3 is true
3)利用类类型来创造实例对象(需要有无参数的构造方法)(需要有强制类型转化，且有异常抛出)
　　Foo foo2 = (Foo)(c1.newInstance());
　　Foo foo3 = (Foo)(c2.newInstance());
　　Foo foo4 = (Foo)(c3.newInstance());

 package com.study.reflect;

 /**
  * @description   * @date 2016-3-28 下午4:06:29
  */
 public class ClassDemo1 {

     public static void main(String[] args){
         //Foo的实例对象如何表示？
         Foo foo1=new Foo();//foo1就表示Foo的实例对象
         //Foo这个类也是一个实例对象，它是Class类的对象，那Class类的实例对象，如何表示呢？
         //任何一个类都是Class的实例对象，但是不能通过new关键字来创建。这个实例对象有三种表示方式：

         //第一种表示方式---->实际是在告诉我们任何一个类都有一个隐含的静态成员变量class
         Class c1=Foo.class;//如果Foo已经存在，可以用这种方法来创建Foo的类类型（class type），即Foo类的类类型就是Class类的一个实例对象。

         //第二种方式-->已知该类的对象，通过getClass方法
         Class c2=foo1.getClass();//如果Foo类的对象foo1已经存在，可以通过这种方法来创建Foo类的类类型。

         /**
          * 上面官网说c1,c2 是表示了Foo类的类类型（class type）---->指的就是Class的对象
          * 类类型，即万事万物皆对象，
          * 类也是一个对象，是Class类的实例对象
          * 这个对象我们把它称为该类的类类型
          */

         //不管c1 or c2,他们都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
         System.out.println(c1==c2);//true

         //第三种表示：
         Class c3=null;
         try {
             c3=Class.forName("com.study.reflect.Foo");//通过Foo的全称来创建
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         System.out.println(c2==c3);//true

         //我们完全可以通过类的类类型创建该类的对象实例-->通过c1 or c2 or c3 创建Foo的实例
         try {
             //如果c1是A类的类类型，创建的就是A类的实例对象，所以需要做强制类型转换，也会有异常
             Foo foo = (Foo) c1.newInstance();//这个前提要求是需要有无参数的构造方法
             foo.print();
         } catch (InstantiationException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
     }

 }
 class Foo{
     void print(){
     }
 }

二、动态加载类

首先区分什么是动态加载和静态加载。

也就是区分编译和运行。

• new 创建对象，是静态加载类，在编译时刻就需要加载所有可能使用到的类
• 通过动态加载类可以解决该问题。通过类类型创建该类的对象

1、静态加载类，是编译时刻加载；动态加载类，是运行时刻加载
2、new创建对象：是静态加载类，在编译时刻就需要加载所有的【可能使用到的类】。有一个类有问题（如不存在），都不能通过编译，会报错。
3、Class.forName()通过动态加载类，可以用到一个类时，才进行加载。
【功能性的类尽量使用动态加载，并对新添的类实现功能性接口（标准），这样就不用重新编译】

比如：

//new 创建对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类。eg：word excel
//通过动态加载类可以解决该问题
//动态加载类，在运行时刻加载
Class c=Class.forName(args[0]);
//通过类类型，创建该类对象
OfficeAble oa=(OfficeAble)c.newInstance();//word 和excel都想加载就用一个标准oa
oa.start();
—————————————————————————————————
//编写一个标准接口
interface OfficeAble
{
public void start();
}
—————————————————————————————————
//让word 和excel继承oa
class Excel implements OfficeAble
{
    public void start(){
}
}

动态加载的好处（设计思想）：
扩展性，主程序不需要修改，不需要重新编译，只要新功能实现了相同的接口，启动的时候换个新的参数就可以。

三、获取方法信息

public class ClassDemo2 {
    public static void main(String[] args) {
        /**
         * 基本数据类型、void关键字都存在类类型
         */
        Class c1=int.class;//基本数据类型int的类类型
        Class c2=String.class;//String类的类类型（可以理解为String类的字节码,如：编译生成的xx.class文件即xx的字节码文件）
        Class c3=double.class;//double这个数据类型的类类型
        Class c4=Double.class;//Double这个类的类类型
        Class c5=void.class;//在类里面声明的，比如void,也是有类类型

        //获取类的全称getName()
        System.out.println(c1.getName());//输出：int
        System.out.println(c2.getName());//输出：java.lang.String
        //获取不包含包名的类的全称
        System.out.println(c2.getSimpleName());//输出：String

    }
}

Class类的基本API操作

获取类的全部信息，包括类的成员函数、成员变量

 public class ClassUtil {

     /**
      *
      * @description 打印类的信息，包括类的成员函数、成员变量
      * @date 2016-3-28 下午5:12:42
      * @param @param obj 该对象所属类的信息
      * @return void
      */
     public static void printClassMessage(Object obj){
         //要获取类的信息，首先要获取类的类类型
         Class c = obj.getClass();//传递的是哪个子类的对象，c就是该子类的类类型
         //获取类的名称
         System.out.println("类的名称是："+c.getName());
         //在Java中，方法是Method类的对象
         /**
          * Method类，是方法的对象
          * 一个成员方法就是一个Method的对象
          * Method类中封装了对方法的操作
          * getMethods()方法获取的是所有public的函数，包括父类继承而来的
          * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
          */
         Method[] methods = c.getMethods();
         Method[] declaredMethods = c.getDeclaredMethods();
         for(int i=0;i<methods.length;i++){
             //得到方法的名称
             System.out.print(methods[i].getName()+"(");
             //获得参数类型--->得到的参数列表的类型的类类型
             Class[] parameterTypes = methods[i].getParameterTypes();
             for(Class class1 : parameterTypes){
                 System.out.print(class1.getName()+",");
             }
             System.out.print(")");
             //得到方法的返回值类型的类类型
             Class returnType = methods[i].getReturnType();//如果方法返回得到的是int,那结果就是int.class
             System.out.println("方法的返回值类型名称："+returnType.getName());//这个得到的就是名称int
         }
     }
 }

测试类：

 public class ClassDemo3 {
     public static void main(String[] args) {
         String s="Hello";
         ClassUtil.printClassMessage(s);

         System.out.println("=================================");
         Integer i=1;
         ClassUtil.printClassMessage(i);
     }
 }

运行结果：

 类的名称是：java.lang.String
 hashCode()方法的返回值类型名称：int
 compareTo(java.lang.Object,)方法的返回值类型名称：int
 compareTo(java.lang.String,)方法的返回值类型名称：int
 indexOf(java.lang.String,int,)方法的返回值类型名称：int
 indexOf(java.lang.String,)方法的返回值类型名称：int
 indexOf(int,)方法的返回值类型名称：int
 indexOf(int,int,)方法的返回值类型名称：int
 equals(java.lang.Object,)方法的返回值类型名称：boolean
 toString()方法的返回值类型名称：java.lang.String
 charAt(int,)方法的返回值类型名称：char
 codePointAt(int,)方法的返回值类型名称：int
 codePointBefore(int,)方法的返回值类型名称：int
 codePointCount(int,int,)方法的返回值类型名称：int
 compareToIgnoreCase(java.lang.String,)方法的返回值类型名称：int
 concat(java.lang.String,)方法的返回值类型名称：java.lang.String
 contains(java.lang.CharSequence,)方法的返回值类型名称：boolean
 contentEquals(java.lang.StringBuffer,)方法的返回值类型名称：boolean
 contentEquals(java.lang.CharSequence,)方法的返回值类型名称：boolean
 copyValueOf([C,int,int,)方法的返回值类型名称：java.lang.String
 copyValueOf([C,)方法的返回值类型名称：java.lang.String
 endsWith(java.lang.String,)方法的返回值类型名称：boolean
 equalsIgnoreCase(java.lang.String,)方法的返回值类型名称：boolean
 format(java.lang.String,[Ljava.lang.Object;,)方法的返回值类型名称：java.lang.String
 format(java.util.Locale,java.lang.String,[Ljava.lang.Object;,)方法的返回值类型名称：java.lang.String
 getBytes(java.nio.charset.Charset,)方法的返回值类型名称：[B
 getBytes()方法的返回值类型名称：[B
 getBytes(java.lang.String,)方法的返回值类型名称：[B
 getBytes(int,int,[B,int,)方法的返回值类型名称：void
 getChars(int,int,[C,int,)方法的返回值类型名称：void
 intern()方法的返回值类型名称：java.lang.String
 isEmpty()方法的返回值类型名称：boolean
 lastIndexOf(java.lang.String,)方法的返回值类型名称：int
 lastIndexOf(int,)方法的返回值类型名称：int
 lastIndexOf(int,int,)方法的返回值类型名称：int
 lastIndexOf(java.lang.String,int,)方法的返回值类型名称：int
 length()方法的返回值类型名称：int
 matches(java.lang.String,)方法的返回值类型名称：boolean
 offsetByCodePoints(int,int,)方法的返回值类型名称：int
 regionMatches(int,java.lang.String,int,int,)方法的返回值类型名称：boolean
 regionMatches(boolean,int,java.lang.String,int,int,)方法的返回值类型名称：boolean
 replace(char,char,)方法的返回值类型名称：java.lang.String
 replace(java.lang.CharSequence,java.lang.CharSequence,)方法的返回值类型名称：java.lang.String
 replaceAll(java.lang.String,java.lang.String,)方法的返回值类型名称：java.lang.String
 replaceFirst(java.lang.String,java.lang.String,)方法的返回值类型名称：java.lang.String
 split(java.lang.String,int,)方法的返回值类型名称：[Ljava.lang.String;
 split(java.lang.String,)方法的返回值类型名称：[Ljava.lang.String;
 startsWith(java.lang.String,int,)方法的返回值类型名称：boolean
 startsWith(java.lang.String,)方法的返回值类型名称：boolean
 subSequence(int,int,)方法的返回值类型名称：java.lang.CharSequence
 substring(int,)方法的返回值类型名称：java.lang.String
 substring(int,int,)方法的返回值类型名称：java.lang.String
 toCharArray()方法的返回值类型名称：[C
 toLowerCase()方法的返回值类型名称：java.lang.String
 toLowerCase(java.util.Locale,)方法的返回值类型名称：java.lang.String
 toUpperCase()方法的返回值类型名称：java.lang.String
 toUpperCase(java.util.Locale,)方法的返回值类型名称：java.lang.String
 trim()方法的返回值类型名称：java.lang.String
 valueOf([C,)方法的返回值类型名称：java.lang.String
 valueOf(int,)方法的返回值类型名称：java.lang.String
 valueOf(long,)方法的返回值类型名称：java.lang.String
 valueOf(float,)方法的返回值类型名称：java.lang.String
 valueOf(double,)方法的返回值类型名称：java.lang.String
 valueOf(java.lang.Object,)方法的返回值类型名称：java.lang.String
 valueOf(char,)方法的返回值类型名称：java.lang.String
 valueOf([C,int,int,)方法的返回值类型名称：java.lang.String
 valueOf(boolean,)方法的返回值类型名称：java.lang.String
 wait()方法的返回值类型名称：void
 wait(long,int,)方法的返回值类型名称：void
 wait(long,)方法的返回值类型名称：void
 getClass()方法的返回值类型名称：java.lang.Class
 notify()方法的返回值类型名称：void
 notifyAll()方法的返回值类型名称：void
 =================================
 类的名称是：java.lang.Integer
 hashCode()方法的返回值类型名称：int
 reverseBytes(int,)方法的返回值类型名称：int
 compareTo(java.lang.Object,)方法的返回值类型名称：int
 compareTo(java.lang.Integer,)方法的返回值类型名称：int
 equals(java.lang.Object,)方法的返回值类型名称：boolean
 toString(int,int,)方法的返回值类型名称：java.lang.String
 toString(int,)方法的返回值类型名称：java.lang.String
 toString()方法的返回值类型名称：java.lang.String
 toHexString(int,)方法的返回值类型名称：java.lang.String
 decode(java.lang.String,)方法的返回值类型名称：java.lang.Integer
 valueOf(java.lang.String,)方法的返回值类型名称：java.lang.Integer
 valueOf(java.lang.String,int,)方法的返回值类型名称：java.lang.Integer
 valueOf(int,)方法的返回值类型名称：java.lang.Integer
 reverse(int,)方法的返回值类型名称：int
 byteValue()方法的返回值类型名称：byte
 doubleValue()方法的返回值类型名称：double
 floatValue()方法的返回值类型名称：float
 intValue()方法的返回值类型名称：int
 longValue()方法的返回值类型名称：long
 shortValue()方法的返回值类型名称：short
 parseInt(java.lang.String,)方法的返回值类型名称：int
 parseInt(java.lang.String,int,)方法的返回值类型名称：int
 bitCount(int,)方法的返回值类型名称：int
 getInteger(java.lang.String,)方法的返回值类型名称：java.lang.Integer
 getInteger(java.lang.String,int,)方法的返回值类型名称：java.lang.Integer
 getInteger(java.lang.String,java.lang.Integer,)方法的返回值类型名称：java.lang.Integer
 highestOneBit(int,)方法的返回值类型名称：int
 lowestOneBit(int,)方法的返回值类型名称：int
 numberOfLeadingZeros(int,)方法的返回值类型名称：int
 numberOfTrailingZeros(int,)方法的返回值类型名称：int
 rotateLeft(int,int,)方法的返回值类型名称：int
 rotateRight(int,int,)方法的返回值类型名称：int
 signum(int,)方法的返回值类型名称：int
 toBinaryString(int,)方法的返回值类型名称：java.lang.String
 toOctalString(int,)方法的返回值类型名称：java.lang.String
 wait()方法的返回值类型名称：void
 wait(long,int,)方法的返回值类型名称：void
 wait(long,)方法的返回值类型名称：void
 getClass()方法的返回值类型名称：java.lang.Class
 notify()方法的返回值类型名称：void
 notifyAll()方法的返回值类型名称：void

四、获取成员变量、构造函数信息

 public class ClassUtil {

     /**
      *
      * @description 打印类的成员函数的信息
      * @date 2016-3-28 下午5:12:42
      * @param @param obj 该对象所属类的信息
      * @return void
      */
     public static void printClassMethodMessage(Object obj){
         //要获取类的信息，首先要获取类的类类型
         Class c = obj.getClass();//传递的是哪个子类的对象，c就是该子类的类类型
         //获取类的名称
         System.out.println("类的名称是："+c.getName());
         //在Java中，方法是Method类的对象
         /**
          * Method类，是方法的对象
          * 一个成员方法就是一个Method的对象
          * Method类中封装了对方法的操作
          * getMethods()方法获取的是所有public的函数，包括父类继承而来的
          * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
          */
         Method[] methods = c.getMethods();
         Method[] declaredMethods = c.getDeclaredMethods();
         for(int i=0;i<methods.length;i++){
             //得到方法的名称
             System.out.print(methods[i].getName()+"(");
             //获得参数类型--->得到的参数列表的类型的类类型
             Class[] parameterTypes = methods[i].getParameterTypes();
             for(Class class1 : parameterTypes){
                 System.out.print(class1.getName()+",");
             }
             System.out.print(")");
             //得到方法的返回值类型的类类型
             Class returnType = methods[i].getReturnType();//如果方法返回得到的是int,那结果就是int.class
             System.out.println("方法的返回值类型名称："+returnType.getName());//这个得到的就是名称int
         }
     }

     /**
      * @description 打印类的成员变量的信息
      * @date 2016-3-29 上午9:32:58
      * @param @param obj 该对象所属类的信息
      * @return void
      */
     public static void printClassFieldMessage(Object obj) {
         //要获取类的信息，首先要获取类的类类型
         Class c = obj.getClass();//传递的是哪个子类的对象，c就是该子类的类类型
         /**
          * 成员变量也是对象
          * 它是java.lang.reflect.Field的对象
          * Field类封装了关于成员变量的操作
          * getFields()方法获取的是所有的public的成员变量的信息
          * getDeclaredFields()方法获取的是该类自己声明的成员变量信息,不问访问权限
          */
         Field[] fields = c.getFields();//public的成员变量用的比较少
         Field[] declaredFields = c.getDeclaredFields();
         for(Field field:declaredFields){
             //得到成员变量的类型的类类型
             Class fieldType = field.getType();
             String typeName = field.getName();
             //得到成员变量的名称
             String fieldName = field.getName();
             System.out.println(typeName+" "+fieldName);
         }
     }

     /**
      *
      * @description 打印对象的构造函数信息
      * @date 2016-3-29 上午9:39:50
      * @param @param obj 该对象所属类的信息
      * @return void
      */
     public static void printClassConstructorMessage(Object obj){
         //要获取类的信息，首先要获取类的类类型
         Class c = obj.getClass();//传递的是哪个子类的对象，c就是该子类的类类型
         /**
          * 构造函数也是对象
          * 它是java.lang.reflect.Constructor的对象
          * Constructor类中封装了构造函数的信息
          * getConstructors()获取所有public的构造函数
          * getDeclaredConstructors()获取的是该类自己声明的所有的构造函数
          * 构造方法是没有返回值类型的
          */
         Constructor[] constructors = c.getConstructors();
         Constructor[] declaredConstructors = c.getDeclaredConstructors();
         for (Constructor constructor : declaredConstructors) {
             System.out.print(constructor.getName()+"(");
             //获取构造函数的参数列表--->得到的是参数列表的类类型
             Class[] parameterTypes = constructor.getParameterTypes();
             for (Class class1 : parameterTypes) {
                 System.out.print(class1.getName()+",");
             }
             System.out.println(")");
         }
     }
 }

测试类：

 /**
  * @description 测试ClassUtil类的操作
  * @date 2016-3-28 下午5:34:47
  */
 public class ClassDemo3 {
     public static void main(String[] args) {
         System.out.println("=========获取类的成员函数的信息========================");
         //测试获取类的成员方法的信息
         String s="Hello";
         ClassUtil.printClassMethodMessage(s);

         Integer i=1;
         ClassUtil.printClassMethodMessage(i);

         System.out.println("=========获取类的成员变量的信息========================");
         //测试获取类的成员变量的信息
         Integer i1=1;
         ClassUtil.printClassFieldMessage(i);

         System.out.println("=========获取类的构造函数的信息========================");
         ClassUtil.printClassConstructorMessage("Hello");
         ClassUtil.printClassConstructorMessage(new Integer(1));
     }
 }

注意：要获取类的信息，首先要获取类的类类型。obj.getClass()　　

五、方法的反射

1、如何获取某个方法

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

2、方法反射的操作

method.invoke(对象，参数列表)

 public class MethodDemo1 {
     public static void main(String[] args) {
         /**思考：如何获得方法对象，然后用方法对象进行反射操作
          * 1、要获取一个方法首先要获取类的信息，获取类的信息首先要获取类的类类型
          * 2、获取方法必须要有名称和参数列表来决定
          */
         //1、首先要获取类的信息，获取类的信息首先要获取类的类类型
         A a1=new A();
         Class c = a1.getClass();

         /*2、获取方法 名称和参数列表来决定
          * getMethod获取的是public的方法
          * getDeclaredMethod()获取自己声明的方法
          */
         try {
             //获取print(int,int)方法.
             System.out.println("=================获取print(int,int)===============");
             //这个一定会抛出异常，我们这里简单的处理一下异常，原因：万一这个方法（带两个整型参数的方法）不存在呢
             Method method = c.getMethod("print", new Class[]{int.class,int.class});//这个方法中“...”代表可变参数，当有几个参数的时候，可以new Class数组
             //也可以这样写：有几个参数就传几个参数
             Method method2 = c.getMethod("print", int.class,int.class);
             a1.print(10, 20);//普通调用(可以理解为a1这个对象操作方法对象print)
             /*方法的反射操作是用method/method2对象来进行方法调用 和a1.print()调用的效果完全相同
              *方法如果没有返回值，返回null。有返回值就返回具体的返回值如下面的Object o
              */
             Object o = method.invoke(a1, new Object[]{10,20});//方法的反射(可以理解为print这个方法对象，即method/method2来操作a1，即上面普通调用反过来操作，通过invoke来进行操作)
             //也可以这样：
             Object o1 = method.invoke(a1, 10,20);

             System.out.println("=================获取print(String,String)===============");
             //获取方法print(String,String)
             Method method3 = c.getMethod("print", String.class,String.class);
             a1.print("hello", "world");//普通调用
             //对方法进行反射操作
             Object o2 = method3.invoke(a1, "hello","world");

             System.out.println("=================获取print()无参方法===============");
 //            Method method4 = c.getMethod("print", new Class[]{});
             Method method5 = c.getMethod("print");//没有参数就不传
 //            method5.invoke(a1, new Object[]{});
             method5.invoke(a1);
         }catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

 class A{
     public void print(){
         System.out.println("hello world");
     }
     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.toUpperCase());
     }
 }

六、通过反射了解集合泛型的本质

通过Class、Method来认识集合泛型的本质

 public class MethodDemo2 {
     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
         /**
          * 分析：
          * Class,我们可以认为是类类型或字节码，因为文件编译之后就生成*.class文件
          * 也就是说：反射的操作（Class、Method、field的操作）都是编译之后的操作（就是变成字节码之后的操作）就是在运行时刻执行的
          *
          * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
          * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效了
          * 验证：我们可以通过方法的反射来操作，绕过编译
          */
         try {
             Method method = c2.getMethod("add", Object.class);//参数是Object类型，没有任何的泛型类型
             method.invoke(list1,20);//绕过了编译就绕过了泛型
             System.out.println(list1.size());//输出size为2，说明整型20加进去list1集合里面了
             System.out.println(list1);//输出[hello, 20]
             //不能再用foreach进行遍历了，这时他认为都是String类型，会报异常：java.lang.ClassCastException，会提示说int类型不能转换成String类型
             /*for (String string : list1) {
                 System.out.println(string);
             }*/
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }