黑马程序员_高薪技术一（java反射）

----------- android培训、java培训、java博客、java学习型技术博客、期待与您交流！ --------------

 本章主要的知识点总结：1、了解Class类、得到字节码的三种方式以及反射的概念

                                2、Constructor类、Field类、Method类的反射应用

                                 3、数组的反射和Object的关系及数组反射的应用，hashcode的分析。

                                 4、用反射技术开发框架的原理、用类加载器的方式管理资源和配置文件
                                         

一.Class类——反射的基石

    （1）java程序中的各个java类属于同一类事物，描述这类事物的java类名就是Class.

   （2）举例

       人-->Person
       Java类-->Class
 （3）对比提问：Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，Class
      类代表Java类，它的各个实例对象又分别对应什么呢？
 ----对应各个类在内存中的字节码，例如：Person类的字节码，ArrayList类的字节码,等等。
 -----一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，
  -----不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个空间可分别用一个个
   -----的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？
（4）如何得到各个字节码对应的实例对象（Class类型）
     类名.class，         例如：Math.class
     对象.getClass()，      例如：new String().getClass()
      Class.forName("类名")，   例如：Class.forName("java.String")//查询或加载

java里面有9个预定义的Class实例对象（8个基本数据类型和void）。

     int.class == Integer.TYPE;

int.class.isPrimitive();-----true    //判断class类是否为基本数据类型。
      int[].class.isArray();-----true   //判断Class类是否为数组类。

总之在源程序出现的类型，都有各自的Class实例对象 如：int[ ] ,void

 2.class与Class的区别：
      class是指java类，java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，

  至于这个属性的值是什么，则由这个类的实例对象来确定，不同的实例对象有不同的属性值。
        java程序中的各个类,也属于同一类事物，Class类是用来描述java程序中的各个java类这一事物的，

  Class类描 述了类的名字，类的访问属性，类所属的包名，字段名称的列表，方法名称的列表等等。
 3.Class.forName("java.lang.String");中forName()的作用：
   返回字节码。有两种方式：第一，字节码已加载过。第二，字节码未被加载过，在java虚拟机中还不存在，
   则用类加载器去加载，然后缓存到虚拟机中，以后就不用再加载了。

二、反射概念  

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

          例如，一个java类可用一个Class类的对象来表示，一个类中的组成部分有：成员变量，方法，构造方法，包等等 信息也可用一个个的java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个类。表示java类 的  Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field,Method,Contructor,Package等等。
            一 个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法
   可以得到这些实例对象。然后再使用这些对象。

三、Constructor类

代表某个类中的一个构造方法。
（1）得到某个类所有的构造方法：
    例子：Constructor[] contructors = Class.forName("java.lang.String").getConstructors();
 （2）得到某一个构造方法：
  例子：Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
  //获取方法时要用到类型
（3） 创建实例对象：
  1、通常方式：String str = new String(new StringBuffer("abc"));
  2、反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));

//调用获得的方法时要用到上面的相同类型的实例对象
（4）Class.newInstance()方法：
  1、例子：String obj = (String)Class.forName("java.lang.String").newInstance();
  2、该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

四、Field类 

Field类代表某个类中的一个成员变量。
  注意：得到的Field对象是对应到类上面的成员变量，不是对应到对象上的成员变量，
     字段fieldX代表的是x的定义，而不是具体的x变量。

代码实例：

1. public class ReflectPoint   
2. {  
3.  private int x;  
4.  public int y;  
5.  public ReflectPoint(int x, int y) {  
6.   super();  
7.   this.x = x;  
8.   this.y = y;  
9.  }  
10.   
11. }  
12.   
13. import java.lang.reflect.Constructor;  
14. import java.lang.reflect.Field;  
15.   
16. public class ReflectTest   
17. {  
18.  public static void main(String[] args)throws Exception  
19.  {  
20.    
21.     ReflectPoint pt1 = new ReflectPoint(3,5);  
22.   Field fieldY = pt1.getClass().getField("y");  
23.   //fieldY的值是多少？不是5，fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值。  
24.   System.out.println(fieldY.get(pt1));  
25.   Field fieldX = pt1.getClass().getDeclaredField("x");//x 是私有变量，是看不见的，此方法则可看见，但不能用  
26.   fieldX.setAccessible(true);//暴力反射：可强制使用已看到但不能用的私有变量。  
27.   System.out.println(fieldX.get(pt1));  
28.  }  
29. }  
30. 
    

 五、Method类

                Method类代表某个类中的一个成员方法
     （ 1）得到类中的某一个方法：
                 如：Method charAt = String.class.getMethod("charAt",int.class);
     （2）调用方法：
             1、通常方式：System.out.println(str.charAt(1));
              2、反射方式：System.out.println(charAt.invoke(str,1));
               如果传递给Method对象的invoke()方法的第一个参数为null,说明该Method对象对应的是一个静态方法。

      对接收数组参数的成员方法进行反射

       问题：

         启动java程序的main方法的参数是一个字符串数组，即public static void main(String[] args),

       通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，

        整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，因为jdk1.5

       要兼容jdk1.4的语法，所以当把一个字符数组作为参数传递给invoke方法时，javac会按jdk1.4

          的语法进行处理。不能使用代码：mainMethod.invoke(null,new String[]{"xxx"});

      解决办法：

      （1）mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});//即封装成一个参数

       （2）mainMethod.invoke(null,(Object)new String[]{"xxx"});//这样做等于告诉编译器说这是一个参数

                  //编译器就不分把参数当数组看待，也不会把数组打散成若干个参数了.

     代码实例：

1. 1. 1. import java.lang.reflect.Constructor;  
      2. import java.lang.reflect.Field;  
      3. import java.lang.reflect.Method;  
      4.   
      5. public class ReflectTest {  
      6.  public static void main(String[] args)throws Exception  
      7.  {  
      8.   //TestArguments.main(new String[]{"111","222","333"});  
      9.   String startingClassName = args[0];  
      10.   Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);  
      11.   //mainMethod.invoke(null,new Object[]{new String[]{"111","222","333"}});  
      12.   mainMethod.invoke(null, (Object)new String[]{"111","222","333"});  
      13.  }  
      14. }  
      15.   
      16. class TestArguments  
      17. {  
      18.  public static void main(String[] args)  
      19.  {  
      20.   for(String arg : args)  
      21.   {  
      22.    System.out.println(arg);  
      23.   }  
      24.     
      25.  }  
      26. }  

六、数组的反射与Object关系及其反射类型

1.数组反射
（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"};
  System.out.println(a1.getClass() == a2.getClass());
  System.out.println(a1.getClass == a4.getClass());
  System.out.println(a1.getClass() == a3.getClass());
  System.out.println(a1.getClass().getName());
  System.out.println(a1.getClass().getSuperclass().getName());

//获取Class实例对象的父类对应的Class实例对象名称为Object
  System.out.println(a4.getClass().getSuperclass().getName());
  
  Object aobj1 = a1;
  Object aobj2 = a4;
  //Object[] aobj3 = a1;
  Object[] aobj4 = a3;
  Object[] aobj5 = a4;
  
  System.out.println(a1);
  System.out.println(a4);
  System.out.println(Arrays.asList(a1));//--->a1整体相当于一个Object类型，使用JDK1.5的，故打印结果为一个对象的哈希值。
  System.out.println(Arrays.asList(a4));//--->a4中相当于有三个Object类型，使用JDK1.4的，故打印结果为[a,b,c]。

Java.Lang.Reflect.Array类
     public final class Array extends Object
       Array 类提供了动态创建和访问 Java 数组的方法。 Array 允许在执行 get 或 set 操作期间进行扩展转换，
  但如果发生收缩转换，则抛出 IllegalArgumentException。 
  代码例子：

Object obj=null;

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));

}

}

   hash集合中hashcode()方法及内存泄漏
         当一个对象被存储到HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值
  的字段了，否则，对象修改后哈希值就变了，这种情况下，使用contains方法传入该对象当前
  引用作为参数无法检索到对象，这也导致无法从HashSet集合中单独删除当前对象，从而造成
  内存泄露。

七、用反射技术开发框架的原理

 1.反射的作用-->实现框架功能
 （ 1）框架与框架要解决的核心问题
  我做房子给用户住，用户自己安装门窗，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中，框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
   你做的门调用锁，锁是工具，你做的门被房子调用，房子是框架，房子和锁都是别人提供的。
  （2）框架要解决的核心问题：
       若干年前写的框架可以调用若干年后写的程序。
      写程序时无法知被调用的类名，所以在程序中无法直接new某个类的实例对象， 而要用反射来做。

八、用类加载器的方式管理资源和配置文件

1.类 ClassLoader
  public abstract class ClassLoader  extends Object类加载器是负责加载类的对象。
  ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。
  一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。 
  每个 Class 对象都包含一个对定义它的 ClassLoader 的引用。
   InputStream getResourceAsStream(String name) 
          返回读取指定资源的输入流。 
将文件放到源文件下，会自动将它的字节码文件搬到classPath目录下。

代码实例：
  （1）InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");
  //此例运行是将配置文件放在了源文件（src）目录下，意为：从根目录下开始查找，若不加cn/itcast/day1的话就找不到文件。

 （2）InputStream ips = ReflectTest2.class.getResourceAsStream("resources/config.properties");
  //此例运行是将配置文件放在了源文件的新建包cn.itcast.day1.resources下，意为：从默认的程序路径下开始查找，即从包cn.itcast.day下找。

     （3）InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/day1/resources/config.properties");

            //使用绝对路径