JAVA基础-反射

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

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

如果想要对指定名称的字节码文件进行加载

反射的好处：大大的增强了程序的扩展性。 
反射的基本步骤： 
1、获得Class对象，就是获取到指定的名称的字节码文件对象。 
2、实例化对象，获得类的属性、方法或构造函数。 
3、访问属性、调用方法、调用构造函数创建对象。

得到类的字节码文件相同，这三种方式。
1.Class cls1=类名.class 相对简单，还是需要明确类名
2.cls1.getclass();必须要明确具体的类，并创建对象
3.class.forName("完整的类名（带包名）");

9个预定义的Class实例对象。

Integer.class包装类的字节码
Integer.TYPE Integer中基本类型的字节码
int.class==Integer.TYPE

数组 
class.isPrimitive();
class.isArray();

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

创建类的对象
     String  name="com.dsa.类名";
     寻找该名称类文件，并加载进内存，并非产生class对象
     Class clazz=Class.forName(name);
     产生该类的对象
     Object obj=clazz.newInstance();
      得到某一个指定构造方法
     Constructor  constructor= Class.forName("").getConstructor(String.class);
     创建实例对象
          Object obj=constructor.newInstance("abc");

Constructor 构造方法：代表某个类中的一个构造方法。

     得到某个类中所有的构造方法
     Constructor  constructors[]= Class.forName("").getConstructors();; 

     得到某一个构造方法
     Constructor  constructor= Class.forName("").getConstructor(StringBuffer.class);


          Constructor  constructor= Class.getConstructor(StringBuffer.class);
     创建实例对象
          String str=(String) constructor.newInstance(new StringBUffer("abc"));
          调用获得的方法时要用到上面相同类型的实例对象

      Class.newInstance()方法：
           String obj=（String）Class.forName("java.lang.String").newInstance();
            先得到默认的构造方法，然后用该构造方法创建实例对象。

成员变量 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);将新值赋给对象           

Method类 成员方法的反射。
   
    获取成员方法
   
    反射形式：
    Method  methodCharAt = String.class.getMethod("charAt"--方法名,int.class--这是参数类型，如果是空参函数则是 null);
     Object obj=clazz.newInstance();

          methodCharAt.invoke(str1,1);
  

数组的反射
    Class clazz=obj.getClass();
     if(clazz.isArray()){
     int len=array.getLength(obj);
     for(int i=0;i<len;I==){
             sopArray.get(obj,i))
      }   


  }
    

反射来获取泛型信息

通过指定对应的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()//返回泛型参数类型;

利用反射来获取泛型的类型（泛型信息）
步骤：
获取当前类
获取目标字段
获取包含泛型类型的类型 getGenericType()
强转至子类ParameterizedType 	因为Type没有任何对应的方法
获得泛型真正的类型 getActualTypeArguments()

例子

package junereflect624;

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 GetGenericTypeDemo14 {
    Map<String,Integer> map = new HashMap<String,Integer>();
    
    public static void main(String[] args) throws Exception {
        Class c = GetGenericTypeDemo14.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 getGenericType() 返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。 
         *  Type是Class的接口;
         */
        Type t = f.getGenericType();//包含泛型的类型
        System.out.println(t);
//java.util.Map<java.lang.String, java.lang.Integer>
        

        /**
         * Type这个类里面没有任何的方法，所以需要调用子类的方法，那么大的类型转到小的类型，需要强转！
         */
        ParameterizedType pt = (ParameterizedType)t;//强转到其子类
        /**
         *  Type[] getActualTypeArguments() 
                      返回表示此类型实际类型参数的 Type对象的数组。 
             Type getOwnerType() 
                      返回 Type 对象，表示此类型是其成员之一的类型。 
             Type getRawType() 
                      返回 Type 对象，表示声明此类型的类或接口。 
         */
        
        t = pt.getRawType();//类型的类或接口
        System.out.println(t);
        
        Type[] ts = pt.getActualTypeArguments();
        for (Type type : ts) {
            System.out.println(type);
            /**
             *  class java.lang.String
                class java.lang.Integer
             */
        }
    }
}

打印：
java.util.Map junereflect624.GetGenericTypeDemo14.map
map
获得其类型：interface java.util.Map
java.util.Map<java.lang.String, java.lang.Integer>
interface java.util.Map
class java.lang.String
class java.lang.Integer

我的总结：多查找api，参考api中方法使用的限制，比如是否静态、返回值类型等。