A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 黑马的小菜鸟 中级黑马   /  2014-9-20 00:56  /  1444 人查看  /  12 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文



第一节  Class

一、概述:

1、Class是Java程序中各个Java类的总称;它是反射的基石,通过Class类来使用反射。

2、Class和class的区别

1)class:Java中的类用于描述一类事物的共性,该类事物有什么属性,没有什么属性,至于这个属性的值是什么,则由此类的实例对象确定,不同的实例对象有不同的属性值。

2)Class:指的是Java程序中的各个Java类是属于同一类事物,都是Java程序的类,这些类称为Class。例如人对应的是Person类,Java类对应的就是Class。

3、属性:类名,类的访问属性,类所属包名,字段名称列表,方法名称列表等。

二、对象的创建和使用:

1、创建实例对象:不可用new Class()的方式,因为Class没有这样的构造方法。而是将字节码对象赋值给Class变量。如Class c1 =Person.class。

如Person类,它的字节码:首先要将Person的java文件编译为class文件放于硬盘上,即为二进制代码,再将这些代码加载到内存中,接着用它创建一个个对象。就是把类的字节码加载进内存中,再用此字节码创建一个个对象。当有如Person、Math、Date等等的类,那么这些字节码就是分别的一个Class对象。即Class c2 =Date.class;。

2、获得类的字节码对象:如Class.forName(”java.lang.String”)即获得String.class。得到这个字节码对象有两种情况:

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

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

3、得到各字节码对应的实例对象(Class类型)的方式:

1)类名.class:如System.class,String.class等等

2)对象.class:如new Date().getClass()或者d.getClass()。(Date d = new Date())

3)Class.forName(“类名”):如Class.forName(”java.lang.String”)

当获取类名的时候,是不知道此类的名称的,forName(字符串参数)方法中传入字符串型的变量作为对外访问的入口,即传入什么类名就获得什么类名,从而得知相应的类名。

注:

forName()是静态方法,是反射中使用的一种方式获取字节码的实例对象。

每个类的字节码对象只有唯一的一个,如任何字符串对象,对应唯一的String.clas字节码。

4、九个预定义的Class:

1)包括八种基本类型(byte、short、int、long、float、double、char、boolean)的字节码对象和一种返回值为void类型的void.class。

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

基本数据类型的字节码都可以用与之对应的包装类中的TYPE常量表示

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

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

三、方法:

1、static Class forName(String className)

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

2、Class getClass()

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

3、Constructor getConstructor()

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

4、Field getField(String name)

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

5、Field[] getFields()

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

6、Method getMethod(String name,Class… parameterTypes)

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

7、Method[] getMehtods()

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

8、String getName()

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

9、String  getSuperclass()

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

10、boolean isArray()

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

11、boolean isPrimitive()

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

12、T newInstance()

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


12 个回复

倒序浏览
第二节  反射

1、概述:把Java类中的各种成分映射成相应的Java类。

如Class中的每一个方法返回的都是一种类(型),即Method对所有方法抽取成了这个类Method,它的每一个对象(如变量methodObj1)代表了一个方法。

2、一个类中的组成成分:

成员变量、方法、构造函数、包等信息,也用一个个java类来表示(如汽车是一个类,其中的发动机,变速箱等也是对应的一个个类),表示Java类的Class类显然要提供一系列的方法来获取其中的变量、方法、构造函数、修饰符、包等信息,这些信息就是用相应的类的实例对象来表示,他们是Field、Method、Contructor、Package等。

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


反射中的各种类:

一、Constructor类

1、概述:Constructor代表某个类的构造方法

2、获取构造方法:

1)如何得到摸个类的所有构造方法:如得到String类的所有构造方法

Constructor[] cons = Class.forName(“java.lang.String”).getConstructors();

2)获取某一个构造方法:

Constructor con =String.class.getConstructor(StringBuffer.class);①

3、创建实例对象:

1)通常方式:String str = new String(new StringBuffer (”abc”));

2)反射方式:String str = (String)con.newInstance(new StringBuffer(“abc”));②

调用获得的方法时要用到上面相同类型的实例对象,即两个StringBuffer()要对应相等。

NewInstance():构造出一个实例对象,每调用一次就构造一个对象。

注意:上面的两个地方①②都要用到StringBuffer,这必须是一致的。

第①个是指定要带StringBuffer参数类型的构造方法,即所需使用的是含StringBuffer类型的构造方法。

第②个是用这个构造方法创建对象,要传入的参数类型是StringBuffer。

4、Class.newInstance():创建一个对象,不带参数的构造方法。

演示:

[java] view plaincopyprint?
//new String(new StringBuffer("abc"));  
Constructor constructor1 =   
String.class.getConstructor(StringBuffer.class);  
String str2 =  
(String)constructor1.newInstance(new StringBuffer("abc"));  
System.out.println(str2);  
         
//Class.newInstrance创建不带参数的构造方法  
String str3 =   
(String)Class.forName("java.lang.String").newInstance();  
System.out.println("str3:"+str3);  

二、Field类

1、概述:Field类代表成员变量(字段)的反射。

示例:

[java] view plaincopyprint?
public class ReflectPoint {  
    private int x;  
    public int y;  
  
    public String toString(){  
        return str1+";" + str2 + ";" + str3;  
    }  
}  
public class FieldTest(){  
ReflectPoint pt1 = new ReflectPoint(3,5);  
    //fieldX和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));  
}  

2、获取成员变量:

如上例子所示:

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

getField(String name)和get(变量)

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

getDeclared(String name)

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

get(变量)

[java] view plaincopyprint?
//替换字符   
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);  
        }  
    }  
}  

三、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,说明Method对象对应的是一个静态方法

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

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

[java] view plaincopyprint?
//Method类演示  
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,不用拆包  
        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黑马币 +20 收起 理由
EDDY_Liang + 20 虽然没只是复述视频的内容,但打字也不容易.

查看全部评分

回复 使用道具 举报
四、数组的反射

1、数组字节码的名字:有[和数组对应类型的缩写,如int[]数组的名称为:[I

2、基本数据类型的一维数组不能转换为Object数组,如:

int[] a = new int[3];Object[] obj= a;这样是不成立的。

3、如何得到某个数组中的某个元素的类型:

例:int a = newint[3];Object[] obj= new Object[]{”ABC”,1};

无法得到某个数组的具体类型,只能得到其中某个元素的类型,如

Obj[0].getClass().getName()得到的是java.lang.String

若通过b.getClass().getName(),结果是:[Ljava.lang.Object;

[java] view plaincopyprint?
public static void arrayTest()throws Exception {  
    int[] a1 = new int[]{1,2,3};  
    int[] a2 = new int[4];  
    int[][] a3 = new int[2][3];  
    Integer[] ai = new Integer[3];  
    String[] a4 = new String[]{"a","b","c"};  
      
    System.out.println(a1.getClass() == a2.getClass());  
    System.out.println((Object)a1.getClass() == (Object)a3.getClass());  
         
    System.out.println(a3[0].getClass() == a1.getClass());  
    System.out.println(a3[0].getClass().getSuperclass().getName());  
    System.out.println(a1.getClass().equals(a3.getClass()));  
    System.out.println(a1.getClass().equals(a4.getClass()));  
    System.out.println(a1.getClass().getName());  
    System.out.println("----:" + a1.getClass());  
    System.out.println(a1.getClass().getSuperclass().getName());  
    System.out.println(a2.getClass().getSuperclass().getName());  
         
    Object obj1 = a1;  
    Object obj2 = a2;  
    //int基本数据类型不是Object的  
    //Object[] obj3 = a1;  
    Object[] obj4 = a3;  
    Object[] obj5 = a4;  
         
    System.out.println(a1);  
    System.out.println(a4);  
      
    System.out.println(Arrays.asList(a1));  
    System.out.println(Arrays.asList(a4));  
    System.out.println("-------");  
    int[] a = new int[3];  
    Object[] obj = new Object[]{"abc",new Integer(1)};  
    System.out.println(a.getClass().getName());  
    System.out.println(obj.getClass().getName());  
    System.out.println(obj[0].getClass().getName());  
}  

五、HashSet和与hashCode的分析

示例:

[java] view plaincopyprint?
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.HashSet;  
  
public class ReflectTest2 {  
    public static void main(String [] args){  
        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());  
    }  
}  
  
public class ReflectPoint {  
    private int x;  
    public int y;  
    public String str1 = "ball";  
    public String str2 = "basketball";  
    public String str3 = "itcast";  
      
    public ReflectPoint(int x, int y) {  
        super();  
        this.x = x;  
        this.y = y;  
    }  
      
    public int hashCode() {  
        final int prime = 31;  
        int result = 1;  
        result = prime * result + x;  
        result = prime * result + y;  
        //System.out.println("demo...");//测试  
        return result;  
    }  
  
    public boolean equals(Object obj) {  
        if (this == obj)  
            return true;  
        if (obj == null)  
            return false;  
        if (getClass() != obj.getClass())  
            return false;  
        ReflectPoint other = (ReflectPoint) obj;  
        if (x != other.x)  
            return false;  
        if (y != other.y)  
            return false;  
        return true;  
    }  
  
    public String toString(){  
        return str1+";" + str2 + ";" + str3;  
    }  
}  

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

1、哈希算法的由来:

若在一个集合中查找是否含有某个对象,通常是一个个的去比较,找到后还要进行equals的比较,对象特别多时,效率很低,通过哈希算法,将集合分为若干个区域,每个对象算出一个哈希值,可将哈希值分组(一般模32为一组),每组对应某个存储区域,依一个对象的哈希码即可确定此对象对应区域,从而减少每个对象的比较,只需在指定区域查找即可,从而提高从集合中查找元素的效率。

示意图:


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

3、只有类的实例对象要被采用哈希算法进行存入和检索时,这个类才需要按要求复写hashCode()方法,即使程序可能暂时不会用到当前类的hashCode()方法,但是为提供一个hashCode()方法也不会有什么不好,没准以后什么时候就会用到这个方法,所以通常要求hashCode()和equals()两者一并被覆盖。

4、提示:

1)若同类两对象用equals()方法比较的结果相同时,他们的哈希码也必须是相等的,但反过来就不成立了,如”BB”和”Aa”两字符串用equals()比较式不相等的,但是他们的哈希值是相等的。

2)当一个对象被存储进HashSet集合中,就不能再修改参与计算哈希值的字段,否则对象被修改后的哈希值与最初被存入的HashSet集合中的哈希值就不同了。在这种情况下,即使contains()方法是用对象的当前引用作为参数去HashSet集合中检索对象,也将返回找不到对象的结果,这也导致无法从HashSet集合中单独删除当前对象,从而造成内存泄露。

简单说,之前存入的对象和修改后的对象,是具有不同的哈希值,被认为是不同的两个对象,这样的对象不再使用,又不移除,而越来越多,就会导致内存泄露。

补充:

内存泄露:某些对象不再使用了,占用着内存空间,并未被释放,就会导致内存泄露;也就是说当程序不断增加对象,修改对象,删除对象,日积月累,内存就会用光了,就导致内存溢出。

3)对象在调用方法时,对象会先进行一次自身hashCode()方法的调用,再进行操作方法。
回复 使用道具 举报
第三节  反射的作用--> 实现框架的功能

一、概述:

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

如房地产商造房子用户住,门窗和空调等等内部都是由用户自己安装,房子就是框架,用户需使用此框架,安好门窗等放入到房地产商提供的框架中。

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

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

我们在写框架(造房子的过程)的时候,调用的类(安装的门窗等)还未出现,那么,框架无法知道要被调用的类名,所以在程序中无法直接new其某个类的实例对象,而要用反射来做。

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

1)右击项目名-->File-->命名,写入键值对:className=java.util.ArrayList,等号右边的可以自己定义集合的名称,即用户可以对此记事本修改成自己的类名。

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

①将文件读取到读取流中,一定要用完整的路径,可以使用getRealPath()方法获取路径名,再加上自己定义的文件夹名。

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

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

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

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

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

二、类加载器:

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

2、文件的加载问题:

1)eclipse会将源程序中的所有.java文件加载成.class文件,以确保编译,然后放到classPath指定的目录中去。并且会将非.java文件原封不动的复制到.class指定的目录中去。在真正编译的时候,使用classPath目录中的文件,即放置.class文件的目录。

2)写完程序是要讲配置文件放到.class文件目录中一同打包,这些都是类加载器加载的,资源文件(配置文件)也同样加载了配置文件。

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

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

1)由类加载器ClassLoader的一个对象加载经内存,即用getClassLoader()方法加载。若要加载普通文件,可用getResourseAsStream(String name)在classPath的文件中逐一查找要加载的文件。

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

如:Reflect.class.getResourseAsStream(String name)

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

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

一般先得到用户自定义的总目录,在加上自己内部的路径。可以通过getRealPath()方法获取文件路径。对配置文件修改是需要要储存到配置文件中,那么就要得到它的绝对路径才行,因此,配置文件要放到程序的内部。

第二、name的路径问题:

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

②如果配置文件和classPath目录有关系,即在classPath目录中或在其子目录中(一般是资源文件夹resource),那么就得写相对路径,因为它自己了解自己属于哪个包,是相对于当前包而言的。

示例:

配置文件内容:

className=java.util.ArrayList

程序示例:

[java] view plaincopyprint?
<span style="font-family:Arial;">import java.io.FileInputStream;  
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());  
    }  
}  
</span>  
回复 使用道具 举报
希望一些同学看到了可以获得帮助!!另外 求打赏!!我也不容易的!!
回复 使用道具 举报
非常好额
回复 使用道具 举报
正在看反射,看的头晕摸不着头脑:(
回复 使用道具 举报
谢谢楼主分享 ,理清了思路
回复 使用道具 举报
楼主,厉害,先收着,早晚会用到
回复 使用道具 举报
昨天刚看开始看发射,谢谢分享
回复 使用道具 举报
亲,先别打击我。。。。:)
回复 使用道具 举报
收藏了    谢谢楼主分享
回复 使用道具 举报
这是发技术博客的节奏嘛...
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马