黑马程序员-------------反射

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

1、反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。

简单说：反射技术可以对一个类进行解剖。

反射的好处：大大的增强了程序的扩展性。

 

2、反射的基本步骤：

1、获得Class对象，就是获取到指定的名称的字节码文件对象。

2、实例化对象，获得类的属性、方法或构造函数。

3、访问属性、调用方法、调用构造函数创建对象。

 

3、获取这个Class对象，有三种方式：

1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。

2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。

 前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。

3：使用的Class类中的方法，静态的forName方法。

 指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。

// 1. 根据给定的类名来获得  用于类加载

String classname = "cn.itcast.reflect.Person";// 来自配置文件

Class clazz = Class.forName(classname);// 此对象代表Person.class

// 2. 如果拿到了对象，不知道是什么类型   用于获得对象的类型

Object obj = new Person();

Class clazz1 = obj.getClass();// 获得对象具体的类型

// 3. 如果是明确地获得某个类的Class对象  主要用于传参

Class clazz2 = Person.class;

4、9个预定义的Class对象：

public boolean isPrimitive()判定指定的 Class 对象是否表示一个基本类型。 

有九种预定义的 Class 对象，表示八个基本类型和 void。这些类对象由 Java 虚拟机创建，与其表示的基本类型同名，即 boolean、byte、char、short、int、long、float 和 double。 

int.class == Integer.TYPE

5、反射的理解

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

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

(2)一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

6、Constructor类

由Class类中这些方法得到Constructor对象：

一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型：

void.class == Void.TYPE

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

得到某个类中所有公共的构造函数：

Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造函数

Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

Constructor对象上会有什么方法呢？得到名字，得到所属于的类，产生实例对象。

创建实例对象：

1、通常方法：String str = new String(new StringBuffer("abc"));

反射方法: Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

String str = (String)constructor.newInstance(new StringBuffer("abc"));

2、Class对象中有一个便利的方法创建实例对象：

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

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。（javabean要求有一个默认的构造函数）

该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

7、Filed类

Field类代表某个类中的一个成员变量   

getField(String name)  返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。

getFields()   返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

getDeclaredField(String name)  返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。

getDeclaredFields()     返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

假如有一个ReflectPoint类：

[java] view plaincopy

1. class ReflectPoint {  
2.     private int x;  
3.     public int y;  
4.   
5.     public ReflectPoint(int x, int y) {  
6.         super();  
7.         this.x = x;  
8.         this.y = y;  
9.     }  
10.   
11.     public void setX(int x) {  
12.         this.x = x;  
13.     }  
14.   
15.     public int getX() {  
16.         return x;  
17.     }  
18.   
19.     public void setY(int y) {  
20.         this.y = y;  
21.     }  
22.   
23.     public int getY() {  
24.         return y;  
25.     }  
26. }  

反射字段：

  //成员字段的反射

  ReflectPointpt1 = new ReflectPoint(3, 5);

  FieldfiledY = pt1.getClass().getField("y");

  System.out.println(filedY);

  System.out.println(filedY.get(pt1));

 

  //私有字段的暴力反射

  FieldfieldX = pt1.getClass().getDeclaredField("x");//可以得到私有字段但还不能用它的方法

  System.out.println(fieldX);

 fieldX.setAccessible(true);//经过暴力反射，强行使用它的方法

  System.out.println(fieldX.get(pt1));

练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

实现该功能的代码如下：

[java] view plaincopy

1. private static void changeStringValue(Object obj) throws IllegalArgumentException, IllegalAccessException {  
2.         Field[] fields = obj.getClass().getFields();  
3.   
4.         for (Field field : fields) {  
5.             if (field.getType() == String.class) {  
6.                 String oldValue = (String) field.get(obj);  
7.                 String newValue = oldValue.replace('b', 'a');  
8.                 field.set(obj, newValue);  
9.             }  
10.         }  
11.     }  

8、Method类

Method类代表某个类中的一个成员方法

1、大家应通过思考和推理的方式来学习反射中的API，例如，Class.getMethod方法用于得到一个方法，该方法要接受什么参数呢？显然要一个方法名，而一个同名的方法有多个重载形式，用什么方式可以区分清楚想得到重载方法系列中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。

再强调一遍参数类型用什么来表示啊？用Class对象！

得到Method对象的几个方法：

getMethod(String name, Class<?>... parameterTypes) 返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

getDeclaredMethod(String name, Class<?>... parameterTypes) 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。

getDeclaredMethods() 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

2、得到类中的某一个方法：

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

3、调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式：System.out.println(charAt.invoke(str, 1));

注意：如果传递给Method对象的invoke()方法的第一个参数为null时说明此方法为静态方法。

4、jdk1.4和jdk1.5的invoke方法的区别：（可变参数的出现）

Jdk1.5：public Objectinvoke(Object obj,Object... args)

Jdk1.4：public Objectinvoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

 

9、用反射方式执行某个类中的main()方法：

main()虽属于Method范畴内的，但由于其特殊性，与一般的函数有一定的区别：

1、问题的出现：

启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

 

2、解决的方法：

mainMethod.invoke(null,new Object[]{newString[]{"xxx"}});

mainMethod.invoke(null,(Object)newString[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

Class clazz = Class.forName(arg[0]);//运行时将类名作为参数传递进去，开发中一般写在配置文件中并读取

Method mMain = clazz.getMethod("main",String[].class);

mMain.invoke(null,new Object[]{new String[]{"aaa","bbb"}});

mMain.invoke(null,(Object)new String[]{"aaa","bbb"});

[java] view plaincopy

1. class TestArrayArguments {  
2.  public static void main(String [] args)  
3.  {  
4.   for(String arg:args)  
5.   {  
6.    System.out.println("----------" + arg + "----------");  
7.   }  
8.  }  
9. }  

10、数组的反射：

1、具有相同维数和元素类型的数组属于同一类型，即具有相同的Class实例对象。

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

3、基本类型的一维数组可以当做Object类型来使用，不能当做Object[]来使用；

     非基本类型的一维数组既可以当做Object类型来使用，也可以当做Object[]来使用。

   int[] a1 = new int[3];

 int[]a2 = new int[4];

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

 String[]a4 = new String[3];

 Integer[]a5 = new Integer[3];

 Object[]aObj3 = a5;//可以，非基本类型的一维数组可以当做Object[]类型来使用

 //Object[]aObj4 = a1; //不可以，基本类型的一维数组不能当做Object[]来使用；

 ObjectaObj1 = a1;//可以，基本类型的一维数组可以当做Object类型来使用

 ObjectaObj2 = a4;//可以，非基本类型的一维数组能当做Object来使用；

 System.out.println(a1.getClass()== a2.getClass());//true

 //System.out.println(a1.getClass()== a3.getClass()); //不兼容类型

 //System.out.println(a1.getClass()== a4.getClass()); //不兼容类型

 System.out.println(a1.getClass().getName());//[I

 System.out.println(a3.getClass().getName());//[[I

 //代表数组的Class实例对象的getSupperClass()方法返回的父类为Object类对应的Class。

 System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object

 System.out.println(a4.getClass().getSuperclass().getName());//java.lang.Object

11、反射的作用（做框架）

1、什么是框架：

比如：我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。

框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架的特点：

框架就是将开发中大量重复的代码集中起来写个通用的程序；

框架是用反射来实现的,框架需要现在的类调用将来写的类；（核心问题）

框架调用未来程序员所写的类，框架不能实现完整的功能，框架只是一些通用的代码；

框架要依赖将来写的类才能运行；

现在写的类要调用将来写的类，我们先针对接口进行调用，将来的类需要实现接口，那么方法就固定了；

但是将来写的类的类名我们无法获知，这时就需要调用者通过配置文件告诉框架具体的类名。

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

我再写框架（盖房子）的时候，将来的客户可能还在上小学，还不会写程序，那么我写的框架怎样能调用到你以后写的类（门窗）呢？----------->用反射技术来解决

3、实现一个小框架，通过配置文件获取要调用的类名。

配置文件：config.properties

className=java.util.HashSet//当需要ArrayList时可以改为className=java.util.HashSet

框架类：ReflecTest2

[java] view plaincopy

1. class ReflecTest2 {  
2.     public static void main(String[] args) throws Exception {  
3.         // 应该先直接用ArrayList和HashSet，然后才引入从配置文件读，这样便于学员学习。  
4.         Properties props = new Properties();  
5.         // 先演示相对路径的问题  
6.         // InputStream ips = new FileInputStream("config.properties");  
7.         /* 
8.          * 一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不 
9.          * 顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。 
10.          */  
11.         // InputStream ips =  
12.         // ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config. //properties");  
13.         // Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件  
14.         // InputStream ips =  
15.         // ReflectTest2.class.getResourceAsStream("config.properties");  
16.         InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");  
17.         props.load(ips);  
18.         ips.close();  
19.   
20.         String className = props.getProperty("className");  
21.         Class clazz = Class.forName(className);  
22.   
23.         Collection collection = (Collection) clazz.newInstance();  
24.         // Collection collection = new ArrayList();  
25.         ReflectPoint pt1 = new ReflectPoint(3, 3);  
26.         ReflectPoint pt2 = new ReflectPoint(5, 5);  
27.         ReflectPoint pt3 = new ReflectPoint(3, 3);  
28.         collection.add(pt1);  
29.         collection.add(pt2);  
30.         collection.add(pt3);  
31.         collection.add(pt1);  
32.         System.out.println(collection.size());  
33.     }  
34. }