Java中的反射逻辑

 1 .      反射是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都只能都调用它的任意一个方法和属性，这种动态获取的信息一级动态调用对象的方法的功能呢个称为java 的反射机制。

      反射其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。就是把JAVA类中的各种成分反射成为相应的JAVA类简单说：反射技术可以对一个类进行解剖

 2.      反射的好处：大大的增强了程序的扩展性。

 3.     反射的基本步骤：

          (1)、获得Class对象，就是获取到指定的名称的字节码文件对象。

          (2)、实例化对象，获得类的属性、方法或构造函数。

          (3)、访问属性、调用方法、调用构造函数创建对象。

  4.    得到类的字节码文件相同，这三种方式。

         1.  Class cls1=类名.class 相对简单，还是需要明确类名

         2.  cls1.getclass();必须要明确具体的类，并创建对象

         3.  class.forName("完整的类名（带包名）");

  5.  九个预定义的Class实例对象：

      (1).  Integer.class包装类的字节码

      (2).  Integer.TYPE Integer中基本类型的字节码

      (3).  int.class==Integer.TYPE

      (4).  数组

                A. class.isPrimitive();

                B. class.isArray();

          只要在源程序中出现的类型，都有各自的Class实例对象，例如 int[] void 等等

     (5).  创建类的对象

                String name="com.dsa.类名"; 

     (6).  寻找该名称类文件，并加载进内存，并非产生class对象:

                Class clazz=Class.forName(name); 

     (7) . 产生该类的对象:

                Object obj=clazz.newInstance();

     (8).  得到某一个指定构造方法:

                Constructor constructor= Class.forName("").getConstructor(String.class);

     (9).  创建实例对象

                Object obj=constructor.newInstance("abc");

 6.  成员变量 Filed类 代表某个类中的一个成员变量

        ReflectPoint pt1=new ReflectPoint(3,5);

        Filed filedy=pt1.getclsss().getFiled("Y"); //只代表哪个对象

        Filed filedy=pt1.getclsss().getDeclaredField("x"); //获取对象不管是私有还是被保护的

        filedy.setAccessible(true); //设置可以访问，暴力反射

        filedy.get(pt1); //取出Y的值

    将字段中的b全变成a

        Field[] fields=obj.getClass().getFields();//获取全部对象

        for(Field field :fields){

             if(field.getType()==String.class){  //如果是字符串

                   String oldValue = (String)field.get(obj); //获取字符串内容

                    String newValue = oldValue.replace('b','a'); //将字符串内容替换

                     field.set(obj,newValue); //将新值赋给对象   

7. Method类成员方法的反射

          获取成员方法 反射形式：

               Method methodCharAt = String.class.getMethod("charAt"--方法名,int.class--这是参数类型，如果是空参函数则是 null);

               Object obj=clazz.newInstance(); methodCharAt.invoke(str1,1);

8. 数组的反射

  Class clazz=obj.getClass();

      if(clazz.isArray()){

            int len=array.getLength(obj);

                 for(int i=0;i<len;I==){

                      sopArray.get(obj,i))

              }

      }

9. 反射来获取泛型信息

         通过指定对应的Class对象，程序可以获得该类里面所有的Field，不管该Field使用private 方法public。获得Field对象后都可以使用getType()来获取其类型。

               Class<?> type = f.getType(); //获得字段的类型

         但此方法只对普通Field有效,若该Field有泛型修饰,则不能准确得到该Field的泛型参数,如Map<String,Integer>;为了获得指定Field的泛型类型，我们采用：

              Type gType = f.getGenericType();

  得到泛型类型然后将Type对象强转为ParameterizedType,其表示增加泛型后的类型

              Type getRawType();  //返回被泛型限制的类型

              Type[] getActualTypeArguments(); //返回泛型参数类型

10.利用反射来获取泛型的类型（泛型信息）

          步骤：

            (1).    获取当前类

            (2).    获取目标字段

            (3).  获取包含泛型类型的类型 getGenericType()

            (4).  强转至子类ParameterizedType（ 因为Type没有任何对应的方法)

            (5). 获得泛型真正的类型 getActualTypeArguments()

11.例子：

package cn.itcast.day01;

import java.lang.reflect.Field;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.HashMap;

import java.util.Map;

public class GetGenericTypeDemo{

        Map<String,Integer> map = new HashMap<String,Integer>();

       public static void main(String[] args) throws Exception {

              Class c = GetGenericTypeDemo.class;

              Field f = c.getDeclaredField("map");

              System.out.println(f);

              System.out.println(f.getName()); //map

           // Class<?> getType() 返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。

             Class cl = f.getType();

             System.out.println("获得其类型："+cl);//获得其类型：interface java.util.Map

            Type t = f.getGenericType();//包含泛型的类型

            System.out.println(t);  //java.util.Map<java.lang.String, java.lang.Integer

            ParameterizedType pt = (ParameterizedType)t;//强转到其子类

            t = pt.getRawType();//类型的类或接口

            System.out.println(t);

            Type[] ts = pt.getActualTypeArguments();

                   for (Type type : ts) {

                           System.out.println(type);

              }

      }

 }