Java高新技术2(反射)

1.Class类概述:

/*
Java程序中的各个Java类属于同一类事物,描述这类事物的Java
类名就是Class
 对比提问,众多的人用一个什么类表示?众多的Java类用一个什么类表示?
   人->Person
   .class->Class
Class类代表Java类,它的各个实例对象又分别对应什么呢?
 1.对应各个类在内存中的字节码,例如:Person类的字节码,ArrayList类的字节码等
 2.一个类被加载器加载到内存中,占用一片存储空间,这个空间里面的内容就是类的字节码
   不同的类,字节码是不同的,这一个个的空间可以用一个个的对象来表示,这些对象显然具有相同的类型
   这个类型就是Class
 */

2.获取字节码对象:

/*
 如何得到各个字节码对应的实例对象(Class类型)
   1.类名.class,例如:System.class
   2.对象.getClass,例如new Date().getClass();
      返回:表示此 对象运行时 的Class对象
   3.Class.forName("java.lang.String"):
     运行时,可以接收字符串变量
     作用:
     返回字节码,如果JVM已加载该字节码,直接返回
     如果没有,则用类加载器将硬盘中的字节码加载到虚拟机中

基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）
和关键字 void 也表示为 Class 对象(Class cls=void.class)。 
*/

package com.itheima.day1;

public class ReflectTest {

    /**
     * @param args
     */
    public static void main(String[] args)throws Exception {
        // TODO 自动生成的方法存根
    /*验证通过三种方式获取到的字节码对象是否是同一个*/ 
    Class cls1=String.class;
    Class cls2="abc".getClass();
    Class cls3=Class.forName("java.lang.String");//此方法上声明有异常
    System.out.println("①"+(cls1==cls2));//true
    System.out.println("②"+(cls2==cls3));//true
    /*
     以上结果说明JVM中只会保存一份同样的字节码
     以后再用到还是该字节码
     */
//     isPrimitive():
//        判定指定的 Class 对象是否表示一个基本类型。 
//    有九种预定义的 Class 对象，表示八个基本类型和 void。
//   这些类对象由 Java 虚拟机创建，与其表示的基本类型同名
//   
    System.out.println("③"+cls1.isPrimitive());//false
    System.out.println("④"+int.class.isPrimitive());//ture
    System.out.println("⑤"+Integer.TYPE.isPrimitive());//ture
    System.out.println("⑥"+Integer.class.isPrimitive());//false
    
    //public boolean isArray()
   //判定此 Class 对象是否表示一个数组类。
    System.out.println("⑦"+int[].class.isArray());//true
    /*
     总之,只要是在源程序中出现的类型,都有各自的Class实例对象:例如:int[],void..
     */
   
  }

}

3.构造方法反射:

package com.itheima.day1;
/*
 反射就是把 Java类中的各种成分 映射成  相应的Java类.
 Java类中有什么?(类所属的包,类中的字段,类中的方法)
  Package getPackage() 
          获取此类的包。 
  Method getMethod(String name, Class<?>... parameterTypes) 
          返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 
  Field getField(String name) 
          返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
  每个返回值都是一个对象,都映射成相应的类(相当于对java中所有类中的成分向上抽取描述),对上面那句话的理解 
 学习反射的目的:
   一个类中的 每个成员都可以用相应的反射API类的一个实例对象来表示,通过调用Class类的方法可以得到这些
   实例对象后,如何用?怎么用?这才是学习和应用反射的关键
 */
import java.lang.reflect.*;
public class ReflectConstructor {

    /**
     * @param args
     */
    public static void main(String[] args)throws Exception {
        // TODO 自动生成的方法存根
     /*
      public Constructor<T> getConstructor(Class<?>... parameterTypes)
                              throws NoSuchMethodException,
                                     SecurityException
                                     返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
                parameterTypes 参数是 Class 对象的一个数组，
                                     这些 Class 对象按声明顺序标识构造方法的形参类型。 
      */
      //new String(new StringBuffer("abc"));
      Constructor strCons=String.class.getConstructor(StringBuffer.class);//对应String类中形参类型为StringBuffer的构造器对象
      Constructor strBufCon=StringBuffer.class.getConstructor(String.class);//对应StringBuffered类中形参类型为String的构造器对象
      /*
       public T newInstance(Object... initargs)//如果传入基本类型->自动装箱
              throws InstantiationException,
                     IllegalAccessException,
                     IllegalArgumentException,
                     InvocationTargetException
                     使用此 Constructor 对象表示的构造方法来   创建该构造方法的声明类 的新实例，
                     并用指定的初始化参数初始化该实例。个别参数会自动解包，以匹配基本形参，
                     必要时，基本参数和引用参数都要进行方法调用转换。 
       */
      String str=(String)strCons.newInstance(strBufCon.newInstance("abc"));//这里没有使用泛型,编译时期不能确定返回类型,返回Object                                                      //如果传入类型非StirngBuffer类型->IllegalArgumentException
     
      System.out.println(str+" "+str.length());
      System.out.println(String.class.newInstance());//

使用缓存机制来保存默认构造方法创建的实例对象

                                                  //Class类中的newInstance相当于调用该字节码对象所表示的类的无参构造器.
                                                     //该语句相当于new String();
    }

}

4.成员字段反射:

获取该类中的字段:

package com.itheima.day1;
//测试反射用
public class ReflectPoint {
  private int x;
  int y;
  public int z;
  String str;
    public ReflectPoint(int x, int y, int z) {
        super();
        this.x = x;
        this.y = y;
        this.z = z;
    }
    public ReflectPoint(String str) {
        super();
        this.str = str;
    }
    @Override
    public String toString(){
        return str;
    }
}

package com.itheima.day1;
import java.lang.reflect.Field;
public class ReflectField {

    /**
     * @param args
     */
    public static void main(String[] args)throws Exception{
        // TODO 自动生成的方法存根
      ReflectPoint rp=new ReflectPoint(4,5,6);
     
      
      
      
      /*
       public Field getField(String name)
               throws NoSuchFieldException,
                      SecurityException返回一个 Field 对象，
                   它反映此 Class 对象所表示的类或接口的指定公共成员字段.(default访问权限也不能,必须public)
        name 参数是一个 String，用于指定所需字段的简称。
                  返回: 由 name 指定的该类的 Field 对象 
       */
      //获取公共字段的值
      Field fieldZ=rp.getClass().getField("z");//ReflectPoint类中的字段z被封装成Field对象
                                                //注意Field对象中z并没有值
                                              //仅仅把ReflectPoint的字段z封装了,而字段的值需要对象去初始化的
                                              //一个类可以有成千上万个对象,每个对象的中同一个字段的值都可能不同
                                               //因此下面要获取z的值,指出ReflectPoint哪个对象
      System.out.println("z="+fieldZ.get(rp));//6
      
      
      
      //获取私有/默认字段的值
      /*
      public Field getDeclaredField(String name)
                       throws NoSuchFieldException,
                              SecurityException
                返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
      name 参数是一个 String，它指定所需字段的简称。注意，此方法不反映数组类的 length 字段。 
      */
      Field fieldX=rp.getClass().getDeclaredField("x");//注意该方法只要是类中声明过的一定能拿到
                                                       //只要你有,管你暴露不暴露,藏起来我也要弄出来
     
      /*
       即使拿到了该fieldX对象,但是你获取不到字段值,依然是权限问题,这时需要用到一个类: AccessibleObject
     AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。
     它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。
     对于公共成员、默认（打包）访问成员、受保护成员和私有成员，
     
     在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，
     或者创建和初始化类的新实例的时候，会执行访问检查。   
     
     public void setAccessible(boolean flag)
                   throws SecurityException
              将此对象的 accessible 标志设置为指示的布尔值。值为 true 
              则指示反射的对象在使用时应该取消 Java 语言访问检查。
              值为 false 则指示反射的对象应该实施 Java 语言访问检查。   
     */
      fieldX.setAccessible(true);//暴力反射,抢~~ - -!
      System.out.println("x="+fieldX.get(rp));//4
      
      Field fieldY=rp.getClass().getDeclaredField("y");
      //fieldY.setAccessible(true);//经测试,default权限可以不用进行标志设置也可以获取到,因为default权限的字段类外也可访问
      System.out.println("y="+fieldY.get(rp)+"
");//5
      getField(rp);
      
    }
    
    
    //尝试使用数组的方式获取
    public static void getField(ReflectPoint rp)throws Exception{
         
         //Field[] fieldArr=rp.getClass().getFields();//该数组只存入public字段
         Field[] fieldArr=rp.getClass().getDeclaredFields();
         for(Field f : fieldArr){
             System.out.println(f);
             f.setAccessible(true);
             System.out.println(f.get(rp));
         }
        
    } 

}
/*
 注意几个异常:
  1.如果对private/default字段使用getField(String)-->Exception in thread "main" java.lang.NoSuchFieldException: x/y
  2.如果未设置此Field对象的accessible(可存取)标志为true,而调用get
    -->Exception in thread "main" java.lang.IllegalAccessException: Class ReflectField can not access a member of class ReflectPoint with modifiers "private"
 */

字段反射练习:

package com.itheima.day1;
import java.lang.reflect.Field;
//将任意一个对象中的所有String类型的成员变量所对应的字符串内容中含有"b"改成"a"
public class ReflectFieldTest {

    public static void main(String[] args)throws Exception {
        // TODO Auto-generated method stub
        ReflectPoint rf=new ReflectPoint("bbca");
        setStrValue(rf);
        System.out.println(rf);//aaca
    }
    public static void setStrValue(Object obj)throws Exception{
         
    Field[] fieldArr=obj.getClass().getDeclaredFields();
    
    for(Field f : fieldArr){
      Class type=f.getType();
       

if(type==String.class){//判断下类型是否为String类型

           f.setAccessible(true);//为了修改所有满足条件的字段
           String value=(String)f.get(obj);
           if(value.contains("b"))
               f.set(obj, value.replaceAll("b","a"));//会将该字符串中所有是"b"的子串替换为"a"
        }
    }
  }
}

5.成员方法的反射:

package com.itheima.day1;
import java.lang.reflect.Method;
public class ReflectMethod {

    public static void main(String[] args)throws Exception{
        // TODO 自动生成的方法存根
//实现通过String对象调用charAt(1); 
    
    /*public Method getMethod(String name,Class<?>... parameterTypes) throws NoSuchMethodException
       SecurityException返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 */
       Method strMethod=String.class.getMethod("charAt", int.class);
       
       /*
        public Object invoke(Object obj,Object... args)
     throws IllegalAccessException,
            IllegalArgumentException,
            InvocationTargetException
       对带有 指定参数 的 指定对象 调用由此 Method 对象表示的底层方法。
       个别参数被自动解包，以便与基本形参相匹配，基本参数和引用参数都随需服从方法调用转换。 
         如果底层方法是静态的，那么可以忽略指定的 obj 参数,该参数可以为 null。   
        返回: 使用参数 args 在 obj 上指派该对象所表示方法的结果          
        
     */
    System.out.println(strMethod.invoke("abc", 1));//该方法被哪个对象调用,以及传入相应实参
    System.out.println(strMethod.invoke("abc", new Object[]{1}));//在JDK 1.5之前,传入一个数组对象
                                                                  //之所以为Object,因为数组中元素类型是不确定的
                                                                  //可以new Object[]{"abc",1}
    /*                                                             
     这里非常别扭:invoke方法是通过Method对象调用
     通俗例子:
       列车司机把列车刹车:列车司机给列车发信号(刹车动作),哥们停车吧,真正让列车停车的是列车自己(内部一系列动作)
       画圆方法定义在圆的内部(Circl.draw(圆心,半径)),关门(Door.close())
     */
  }

}

练习:通过反射调用某个类的main方法:

package com.itheima.day1;
import java.lang.reflect.Method;
import java.util.Arrays;
//需求:写一个程序,这个程序能够根据用户提供的类名,去执行该类中的main方法,由于不知道是哪个类,通过反射解决.

//该例子的难点:给main方法传入的实参!
//例如调用ReflectMethod中的main方法

public class ReflectMethodTest {
  public static void main(String[] args)throws Exception{
   invokeMainMethod("com.itheima.day1.TestInvoke");//不要忘了包名(完整类名) 
 }
  public static void invokeMainMethod(String className)throws Exception{
      Class  cls=Class.forName(className);
      Method method=cls.getMethod("main", String[].class);
      
      //第一种解决方案
      method.invoke(null,new Object[]{new String[]{"123","456"}});//以打包/拆包理解
                                                              //main方法的形参类型为String[]
                                                     //这里如果传入new String[]{"123"}等价于"123"->类型为String
                                                     //这里需要传入一个数组对象:new String[]{"123"},需要再封装为数组
          //new Object[]{new String[]{"123"}},Object[0]指向new String[]{"123"}-->相当于传入了一个实参->new String[]{"123"}
                //说明当传入new String[]{"123"},可变参数并不会再次封装成一个数组,而是把它当成String数组对待->兼容JDK 1.5以前版本
     

//第二种解决方案
      method.invoke(null,(Object)new String[]{"123","abc"});//(Object)强转动作告诉编译器->这是一个对象(字符串数组对象),别拆开
  }
}


//调用该类的main方法
class TestInvoke{
    public static void main(String[] args){
        System.out.println(Arrays.toString(args));
    }
    
}

6.数组,Object,Object[]之间关系探讨:

package com.itheima.day1;

import java.util.Arrays;

//数组反射
/*每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。*/
public class ReflectArray {

    public static void main(String[] args)throws Exception {
        // TODO 自动生成的方法存根
     int[] arr1=new int[3];
     int[] arr2=new int[4];
     int[][] arr3=new int[2][3];
     String[] str=new String[2];
    
     System.out.println(arr1.getClass());//class [I
     System.out.println(arr3.getClass());//class [[I
     System.out.println(str.getClass());//class [java.lang.String
     System.out.println(arr1==arr2);//false
     System.out.println((arr1.getClass()==arr2.getClass())+"
");//同一个字节码对象:class [I
     
     //通过forName获取字节码对象
     System.out.println(Class.forName("[[I")+"
"); 
     
     //查看数组字节码文件对象所表示的类的 超类的字节码对象
     System.out.println(arr1.getClass().getSuperclass());
     System.out.println(arr3.getClass().getSuperclass()); 
     System.out.println(str.getClass().getSuperclass()+"
");//均为class java.lang.Object
    
     //Object,Object[],数组之间的转化
     convert(arr1,arr3,str);
    
    }
    
    public static void convert(int[] arr1,int[][] arr3,String[] str){
         Object obj=null;
         Object[] objArr=null;
         
         //一维数组
         obj=arr1;//obj和arr1均指向new int[3]
         System.out.println("arr1->"+arr1+"  obj->"+obj);//但是你不能使用obj[0]取出元素->因为obj类型为Object(指向一个对象)
        

//objArr=arr1;//

int[]与Object[] 类型不匹配(arr1数组中元素为int而不是Object或其子类)
         
         //数组的数组
         obj=arr3;//obj和arr3均指向new int[2][3];
         System.out.println("obj->"+obj+"  arr3->"+arr3);
         objArr=arr3;//Object[] objArr=new int[2][3];-->objArr数组中每个元素指向了一个一维数组对象
         System.out.println("objArr->"+objArr+"  arr3->"+arr3+
                             "  arr3[0]->"+arr3[0]+"  objArr[0]->"+objArr[0]+
                             "  arr3[1]->"+arr3[1]+"  objArr[1]->"+objArr[1]);
        
         //元素的类型为String
         obj=str;
         System.out.println("obj->"+obj+"  str->"+str);
         objArr=str;//区分上面数组元素为基本类型的objArr=arr1,Object[] objArr=new String[2];
                     //objArr中的每个元素指向一个String对象
         System.out.println("objArr->"+objArr+"  str->"+str+
                            "  str[0]->"+str[0]+"  objArr[0]->"+objArr[0]+
                            "  str[1]->"+str[1]+"  objArr[0]->"+objArr[1]);//str[0]/objArr[0]获取到数组的String类型元素的值(默认值null)
         str[0]="abc";
         System.out.println(str[0].length()+" "+((String)objArr[0]).charAt(1)+"
");//Object[] objArr=new String[2],元素类型为Object
        
        
         //最后关于Arrays.asList方法:
         /*
          JDK 1.4: public static List asList(Object[] a)//不能接受收基本类型一维数组(int[])
          JDK 1.5: public public static <T> List<T> asList(T... a)
         */
         arr1[0]=1;
         arr1[1]=2;
         System.out.println(Arrays.asList(arr1)+" "+Arrays.asList(str));//第一个使用:asList(T... a)->传入了一个参数(一个 一维数组对象)->存入集合 

//第二个使用:asList(Object[] a)->传入new String[2],将a数组中每一个元素(字符串对象)存入集合
                                                                         
    }

}

7.数组反射:

package com.itheima.day1;
import static java.lang.reflect.Array.getLength;
import static java.lang.reflect.Array.get;

import java.util.Arrays;
//数组反射获取数组属性length,数组中元素值
/*
 public boolean isArray() :判定此 Class 对象是否表示一个数组类。 
 
 public static int getLength(Object array)
                     throws IllegalArgumentException
    以 int 形式返回指定数组对象的长度。 
 
 public static Object get(Object array,
                         int index)
  throws IllegalArgumentException
   ArrayIndexOutOfBoundsException
 返回指定数组对象中索引组件的值。
 如果该值是一个基本类型值，则自动将其包装在一个对象中。  
 */
public class ReflectArray2 {
   
    public static void main(String[] args){
        // TODO 自动生成的方法存根
        Object obj=null;
        obj=new int[]{3,5};
        //System.out.println(Arrays.toString(obj.getClass().getDeclaredMethods()));
    
        printObj(obj);
        obj="cdef";
        printObj(obj);
        

}
   //一.根据传入对象不同采取不同方式打印
   //传入数组对象->打印数组中的元素,传入非数组对象->打印该对象
    private static void printObj(Object obj) {
        // TODO 自动生成的方法存根
        Class cls=obj.getClass();
        if(cls.isArray()){//true->实参为一个数组对象
          for(int i=0;i<getLength(obj);++i)
              System.out.println(get(obj,i));
        }
        else
         System.out.println(obj);
    }
  
}
/*
 思考:如何得到数组元素的类型?
 回到是:这是不可能的
 int[] arr=new int[3];//这样的数组还可能想办法获取数组元素类型
 Object[] obj=new Object[]{"abc",1,1.3};//数组元素的类型是什么? 不同统一而论
 obj[0].getClass().getName();//也就是说只能获取到某个元素的具体类型
 */