Java学习提高:反射(*重点*)

  ------- android培训java培训、期待与您交流! ----------  

一、Class

  1、概念:ClassJava程序中各个Java类的总称,一个Class对象代表一个Java类的字节码文件它是反射的基石, 

             通过Class类 来使用反射。

   2Class类中的元素:类名,类的访问属性,类所属包名,字段名称列表,方法名称列表等。

   3Classclass的区别

          classJava中的类用于描述一类事物的共性,该类事物有什么属性,没有什么属性,至于这个属性的值是什么,

                   则由此类的实例对象确定,不同的实例对象有不同的属性值。

          Class:指的是Java程序中的各个Java类是属于同一类事物,都是Java程序的类的字节码对象,这些类称为Class。 

                  例如人对应的是Person类,Java类对应的就是Class

   4、如何获取Class实例对象?

         不可用new Class()的方式,因为Class没有这样的构造方法。而是将字节码对象赋值给Class变量。 

          如Class c1 =Person.class

                  如Person类,它的字节码:首先要将Personjava文件编译为class文件放于硬盘上,即为二进制代码,再将 

          这些代码加载到内存中,接着用它创建一个个对象。就是把类的字节码加载进内存中,再用此字节码创建一个个 

          对象。当有如PersonMathDate等等的类,那么这些字节码就是分别的一个Class对象。即Class c2=Date.class;

   5、获取各个字节码对应的实例对象的方法

          类名.class,例如,System.class; 

          对象.getClass(),例如,new Date().getClass() 

          Class.forName("类名"),例如,Class.forName("java.util.Date");

   6Class.forName(java.lang.String)的作用(面试题)

         获取字符串类的字节码文件String.class。得到这个字节码对象有两种情况:

      (1)此类已经加载进内存:若要得到此类字节码,不需要再加载。

      (2)此类还未加载进内存:类加载器加载此类后,将字节码缓存起来,forName()方法返回加载进来的字节码。

   7、九个预定义的Class

      (1)包括八种基本类型(byteshortintlongfloatdoublecharboolean)的字节码对象和一种 

                返回值为void类型的void.class

     (2Integer.TYPEInteger类的一个常量,它代表此包装类型包装的基本类型的字节码,所以和int.class是相等的。

            基本数据类型(可用isPrimitive方法判断)的字节码都可以用与之对应的包装类中的TYPE常量表示

            数组类型的Class实例对象,可以用Class.isArray()方法判断是否为数组类型的。

    总结:  总之,只要是在源程序中出现的类型,都有各自的Class实例对象,例如,int[]void

 

 

    8Class类中的常用方法

 astatic Class forName(String className)

        返回与给定字符串名的类或接口的相关联的Class对象。

 bClass getClass()

        返回的是Object运行时的类,即返回Class对象即字节码对象

cConstructor getConstructor()

        返回Constructor对象,它反映此Class对象所表示的类的指定公共构造方法。

dField getField(String name)

        返回一个Field对象,它表示此Class对象所代表的类或接口的指定公共成员字段。

eField[] getFields()

        返回包含某些Field对象的数组,表示所代表类中的成员字段。

fMethod getMethod(String name,Class… parameterTypes)

        返回一个Method对象,它表示的是此Class对象所代表的类的指定公共成员方法。

gMethod[] getMehtods()

       返回一个包含某些Method对象的数组,是所代表的的类中的公共成员方法。

hString getName()

        以String形式返回此Class对象所表示的实体名称。

iString  getSuperclass()

        返回此Class所表示的类的超类的名称

jboolean isArray()

        判定此Class对象是否表示一个数组

kboolean isPrimitive()

        判断指定的Class对象是否是一个基本类型。

lT newInstance()

         创建此Class对象所表示的类的一个新实例。

 

二、反射概述

   1、  反射就是把Java类中的各种成分映射成相应的java类。

          例如,一个Java类中用一个Class类的对象来表示,一个类中的组成部分:成员变量,方法,构造方法, 

          包等等信息也用一个个的Java类来表示,就像汽车是一个类,汽车中的发动机,变速箱等等也是一个个的类。

   2、类的成分:表示java类的Class类显然要提供一系列的方法,来获得其中的变量,方法,构造方法,修饰符, 

          包等信息, 这些信息就是用相应类的实例对象来表示,它们是FieldMethodContructorPackage等等。    

   3、  一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示,通过调用Class类的方法可以 

          得到这些实例对象后,再通过这些实例对象使用它们对应成员的功能。

三、Constructor

  1、概念:Constructor类代表某个类中的一个构造方法

  2、得到某个类所有的构造方法:

             Constructor [] constructors= Class.forName(String 类名).getConstructors(); 

  3、得到某一个构造方法: 

             Constructor constructor = Class.forName(String 类名).getConstructor(Class 参数类型); 

         注:获得方法时要用到类型 

  4、创建实例对象: 

           通常方式:String str = new String(实参);  

           反射方式: String str = (String)constructor.newInstance(实参);//实参反射时传入的类的实例对象。 

       注:调用获得的方法时要用到上面相同类型的实例对象

   5、直接通过类对应的Class对象创建该类对象:Class类中的newInstance方法 

            例子:String obj = (String)Class.forName("java.lang.String").newInstance(); 

            该方法内部先得到默认的构造方法,然后用该构造方法创建实例对象。 

            用到了缓存机制来保存默认构造方法的实例对象。

 

四、Field

   1、概念:Field类代表某个类中的一个成员变量。

   2、示例:下面是是一个对Point类使用反射获取其成员变量的示例。

 /*创建一个Point类*/
 public class ReflectPoint {  
    private int x;  
    public int y;  
  
    public String toString(){  
        return str1+";" + str2 + ";" + str3;  
    }  
}  
 
 /*对Point类使用反射获取其成员变量*/
 public class FieldTest(){  
ReflectPoint pt1 = new ReflectPoint(3,5);  
    	//fieldY的值是多少?是5,错!fieldY不是对象身上的变量,而是类上,要用它去取某个对象上对应的值  
    	//要用它去取某个对象上的对应的值,传入什么对象,就取相应对象的值。  
    	Field fieldY = pt1.getClass().getField("y");  
    	System.out.println(fieldY.get(pt1));  
    	//获取私有的成员变量  
Field fieldX = pt1.getClass().getDeclaredField("x");  
    	fieldX.setAccessible(true);  
    	System.out.println(fieldX.get(pt1));  
}  


 总结:

     1、获取成员变量:

如上例子所示:

         (1)获取公有的成员变量:

               getField(String name)get(变量)

         (2)获取私有的成员变量:暴力反射

               getDeclared(String name)

               setAccessible(boolean b),将b设为true即可

               变量.get(变量所属对象)

 

    2、对字节码的比较用等号。

         因为内存中同一类型的字节码文件只有一份。

 

 

 

 3、练习:下面代码实现了将传入的参数字符串中的字符'b‘替换成字符'a'

 

/**
  * 将传入的参数字符串中的字符'b‘替换成字符'a'
  * @param obj:要被替换的字符串对象
  */
 private static void changeStringValue(Object obj) throws Exception {  
    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); //记得替换后设置到对象中 
        }  
    }  
}  
 

   注意:记得将替换后的结果通过set方法设置到对象中。

 

五、Method

 1、概念:Method类代表某个类中的一个成员方法。

      调用某个对象身上的方法,要先得到方法,再针对某个对象调用。

 2、专家模式:谁拥有这个数据,谁就是根据这个数据实现功能的专家。

     如人关门:

       调用者:是门调用管的动作,对象是门,因为门知道如何执行关的动作,通过门轴之类的细节实现。

       指挥者:是人在指挥门做关的动作,只是给门发出了关的信号,让门执行。

  总结:变量使用方法,是方法本身知道如何实现执行的过程,也就是“方法对象”调用方法,才执行

       了方法的每个细节的。

  3、获取某个类中的某个方法:(如String str = abc”)

 

      (1)通常方式:str.charAt(1)

      (2)反射方式:

            Method charAtMethod = Class.forName(java.lang.String).getMethod(charAt,int.class); 

             charAtMethod.invoke(str,1);

        注:如果调用的方法是静态方法,那么传递给Method对象的invoke()方法的第一个参数为null

 

六、用反射方式执行某个main方法

  反射的作用:

       在写源程序时,并不知道使用者传入的类名是什么,但是虽然传入的类名不知道,而知道的是这个类中的方法有main这个方法,所以可以通过反射的方式,通过使用者传入的类名(可定义字符串型变量作为传入类名的入口,通过这个变量代表类名),内部通过传入的类名获取其main方法,然后执行相应的内容。

 

   下面是用反射执行main方法的代码演示

 private static void methodTest(String [] args) throws Exception {  
    String str1 = "abc";  
    //一般方法:  
    System.out.println(str1.charAt(1));  
    //反射方法 :  
    Method methodCharAt =  
        Class.forName("java.lang.String").getMethod("charAt",int.class);  
    System.out.println(methodCharAt.invoke(str1,1));  
      
    //用反射方式执行某个main方法  
    //一般方式:  
    Test.main(new String[]{"111","222","333"});  
    System.out.println("-------");  
      
    //反射方式:  
    String startingClassName = args[0];  
    Method methodMain =  
        Class.forName(startingClassName).getMethod("main",String[].class);  
        //方案一:强制转换为超类Object,告诉JVM传入参数是一个对象,不用拆包  
        methodMain.invoke(null,(Object)new String[]{"111","222","333"});  
        //方案二:将数组打包,编译器拆包后就是一个String[]类型的整体  
        methodMain.invoke(null,new Object[]{new String[]{"111","222","333"}});  
    }  
 
//定义一个用于测试类  
class Test{  
    public static void main(String [] args){  
        for(String arg : args){  
            System.out.println(arg);  
        }  
    }  
} 
 


七、数组的反射

  1、具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象(此处比较与值无关)

  2、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class

  3、基本类型的一维数组可以被当作Object类型使用,不能当作Object[]类型使用;非基本类型的一维数组,

     既可以当做Object类型使用,又可以当做Object[]类型使用。 

   例如:定义以下四个数组:

 

        int [] a1 = new int[]{1,2,3};

        int [] a2 = new int[4];

        int[][] a3 = new int[2][3];

        String [] a4 = new String[]{"a","b","c"};

 

       以下四个赋值:

 

        Object aObj1 = a1; //合法

        Object aObj2 = a4; //合法 

        Object[] aObj3 = a1; //不合法,a1里面元素是基本数据类型,不能当做Object对象

        Object[] aObj4 = a3; //合法,转成Object[]类型数组后,数组中元素是一维数组。

        Object[] aObj5 = a4; //合法

 

   4Arrays.asList()方法处理int[]String[]时的差异

     int[]类型数组作为参数时,因为该类型不属于Object[]类型,也不是其子类,所以JDK1.4版本处理不了。

     在JDK1.5里面会将传入的int[]型数组当成一个参数处理。

     当参数是String[]类型的数组时,JDK1.4版本的特性,会将参数当成一个数组处理,进行拆包,取里面

     的元素作为参数。

   5Array工具类用于完成对数组的反射操作

       通过定义一个打印功能演示

 

 

/**
 
  * 通过判断传入的对象将其打印,如果是数组,逐个打印其元素;若不是数组,直接打印。
 
  * @param obj 要打印的对象
 
  */
 
 private static void printObject(Object obj) {
  	Class clazz = obj.getClass();
  	if(clazz.isArray()){
   	 int len = Array.getLength(obj);
   	 for(int i=0;i<len;i++){
    	 System.out.println(Array.get(obj, i));
   	 }
  	}else{
   	 System.out.println(obj);
  	}
 
 }
 
 

八、HashSet和与hashCode的分析

 1HashSet的特点:HashSet是一个集合容器,底层是哈希数据结构,元素不能重复,增删快,查询慢。

 2HashSet如何保证元素的唯一性?

     元素的重复与否是先判断哈希值是否相同,若相同再根据equals方法判断元素是否相同。

     所以可以复写hashCode方法和equals方法。

  注:只有存入的是具有hashCode算法的集合的,覆写hashCode()方法才有价值。

 3、哈希算法的由来:

    若在一个集合中查找是否含有某个对象,通常是一个个的去比较,找到后还要进行equals的比较,

    对象特别多时,效率很低,通过哈希算法,将集合分为若干个区域,每个对象算出一个哈希值,

    可将哈希值分组(一般模32为一组),每组对应某个存储区域,依一个对象的哈希码即可确定此对象

    对应区域,从而减少每个对象的比较,只需在指定区域查找即可,从而提高从集合中查找元素的效率。

    示意图:


 4、如果不存入是hashCode算法的集合中,那么则不用复写此方法。

 3、只有类的实例对象要被采用哈希算法进行存入和检索时,这个类才需要按要求复写hashCode()方法,

    即使程序可能暂时不会用到当前类的hashCode()方法,但是为提供一个hashCode()方法也不会

    有什么不好,没准以后什么时候就会用到这个方法,所以通常要求hashCode()equals()两者一

    并被覆盖。

 6、提示:

   (1)若同类两对象用equals()方法比较的结果相同时,他们的哈希码也必须是相等的,但反过来就

       不成立了,如”BB”和”Aa”两字符串用equals()比较式不相等的,但是他们的哈希值是相等的。

   (2)当一个对象被存储进HashSet集合中,就不能再修改参与计算哈希值的字段,否则对象被修改后

       的哈希值与最初被存入的HashSet集合中的哈希值就不同了。在这种情况下,即使contains()

       方法是用对象的当前引用作为参数去HashSet集合中检索对象,也将返回找不到对象的结果,这

        也导致无法从HashSet集合中单独删除当前对象,从而造成内存泄露。

   简单说,之前存入的对象和修改后的对象,是具有不同的哈希值,被认为是不同的两个对象,这样的对象

     不再使用,又不移除,而越来越多,就会导致内存泄露。

  拓展:用HashSet集合存储元素后,修改了用于计算hashCode值的参数,那么再去访问元素时会发生内存泄漏, 

       找不到要访问的元素。

    内存泄漏:内存中的某个数据不需要再使用了,但是该数据还存在着内存中,没有释放内存空间。

九、反射的作用——>实现框架功能

 1、框架:通过反射调用位置Java类的一种方式。

     如房地产商造房子用户住,门窗和空调等等内部都是由用户自己安装,房子就是框架,用户需使用

     此框架,安好门窗等放入到房地产商提供的框架中。

   框架和工具类的区别:工具类被用户类调用,而框架是调用用户提供的类。

 2、框架机器要解决的核心问题:

     我们在写框架(造房子的过程)的时候,调用的类(安装的门窗等)还未出现,那么,框架无法知

     道要被调用的类名,所以在程序中无法直接new其某个类的实例对象,而要用反射来做

 3、简单框架程序的步骤:

   (1)右击项目名-->File-->命名,写入键值对:className=java.util.ArrayList,等号右边

       的可以自己定义集合的名称,即用户可以对此记事本修改成自己的类名。

   (2)代码实现,加载此文件:

       ①将文件读取到读取流中,一定要用完整的路径,可以使用getRealPath()方法获取路径名,

         再加上自己定义的文件夹名。

       ②用Properties类的load()方法将流加载经内存,即提取文件中的信息。

       ③关闭流:关闭的是读取流,因为流中的数据已经加载进内存。

   (3)通过getProperty()方法获取类名属性,将传入的类名赋值给指定变量。

   (4)用反射的方式,创建对象newInstance()

   (5)进行相关的具体操作。

 

 4、类加载器:

  (1)简述:类加载器是将.class的文件加载经内存,也可将普通文件中的信息加载进内存。

  (2)文件的加载问题:

     aeclipse会将源程序中的所有.java文件加载成.class文件,以确保编译,然后放到classPath

        指定的目录中去。并且会将非.java文件原封不动的复制到.class指定的目录中去。在真正编译的

        时候,使用classPath目录中的文件,即放置.class文件的目录。

     b、写完程序是要讲配置文件放到.class文件目录中一同打包,这些都是类加载器加载的,资源文

        件(配置文件)也同样加载了配置文件。

     c、框架中的配置文件都要放到classPath指定的文件夹中,原因是它的内部就是用类加载器加载的文件。

  (3)资源文件的加载:是使用类加载器。

     a、由类加载器ClassLoader的一个对象加载经内存,即用getClassLoader()方法加载。

        若要加载普通文件,可用getResourseAsStream(String name)classPath的文件中

        逐一查找要加载的文件。

     b、在.class身上也提供了方法来加载资源文件,其实它内部就是先调用了Loader方法,再加载的

        资源文件。

       如:Reflect.class.getResourseAsStream(String name)

 5、配置文件的路径问题:

     第一、用绝对路径,通过getRealPath()方法运算出来具体的目录,而不是内部编码出来的

       一般先得到用户自定义的总目录,在加上自己内部的路径。可以通过getRealPath()方法获取

       文件路径。对配置文件修改是需要要储存到配置文件中,那么就要得到它的绝对路径才行,因此,

       配置文件要放到程序的内部。

     第二、name的路径问题:

       ①如果配置文件和classPath目录没关系,就必须写上绝对路径,

       ②如果配置文件和classPath目录有关系,即在classPath目录中或在其子目录中(一般是

         资源文件夹resource),那么就得写相对路径,因为它自己了解自己属于哪个包,是相对于

         当前包而言的。

  示例:

    配置文件内容:

    className=java.util.ArrayList

    程序示例:

import java.io.InputStream;  
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.HashSet;  
import java.util.Properties;  
  
public class ReflectTest2 {  
    public static void main(String [] args)throws Exception{  
        //读取系统文件到读取流中  
        //方式一:  
        //InputStream ips = new FileInputStream("config.propert");  
        /*getRealPath()--得到完整的路径//如:金山词霸/内部 
         * 一定要用完整的路径,但完整的路径不是硬编码出来的,而是运算出来的。*/  
        //方式二:  
        //InputStream ips = ReflectTest2.class.getClassLoader()
 
.getResourceAsStream("cn/itcast/text1/config.propert");  
        //方式三:  
            //第一种:配置文件(资源文件)在当前包中  
        InputStream ips = ReflectTest2.class
 
.getResourceAsStream("resourse/config.propert");  
            //第二种:配置文件(资源文件)不在当前包中,和此包没太大关系  
        //InputStream ips = ReflectTest2.class.getClassLoader()
 
.getResourceAsStream("cn/itcast/test2/resourse/config.properties");  
          
        //加载文件中的键值对  
        Properties props = new Properties();  
        props.load(ips);  
        //关闭资源,即ips调用的那个系统资源  
        //注意:关闭的是ips操作的流,加载进内存后,就不再需要流资源了,需要关闭  
        ips.close();  
        //定义变量,将文件中的类名赋值给变量  
        String className = props.getProperty("className");  
        //通过变量,创建给定类的对象  
        Collection cons =   
                (Collection)Class.forName(className).newInstance();  
          
        //将元素添加到集合中  
        /*Collection cons = new HashSet();*/  
        ReflectPoint pt1 = new ReflectPoint(3,3);  
        ReflectPoint pt2 = new ReflectPoint(5,5);  
        ReflectPoint pt3 = new ReflectPoint(3,3);  
        cons.add(pt1);  
        cons.add(pt2);  
        cons.add(pt3);  
        cons.add(pt1);  
        //移除元素  
        cons.remove(pt1);  
        System.out.println(cons.size());  
    }  
}  
 
 
 


 


------- android培训java培训、期待与您交流! ----------

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值