黑马程序员-----程序员之路_____基础加强之反射

----------android培训、Java培训、期待与您交流！----------

1、反射概念

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

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

2、反射的基石Class

（1）众多的人用一个什么类表示？众多的Java类用一个什么类表示？

Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

人----->Person

Java类------>Class

（2）Class类代表Java类，它的各个实例对象又分别对应什么呢？

对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。

一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可（3）分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？

如何得到各个字节码对应的实例对象（ Class类型）
三种：

类名.class，例如，System.class
对象.getClass()，例如，new Date().getClass()
Class.forName("类名")，例如，Class.forName("java.util.Date");//静态方法加载，在写源程序的时候不用知道就可以

String str1="abc";
Class cls1= str1.getClass();
Class cls2=String.class;
Class cls3=Class.forName("java.lang.String");
System.out.println(cls1==cls2);
System.out.println(cls1==cls3);

三种获取方式的结果都是一样的，都是同一份字节码文件

（4）System.out.println(cls1.isPrimitive());

isPrimitive（）此方法是验证类字节码是否是基本类型（int……）。

int.class==Integer.class 结果是false他们不是同一份字节码

而 int.class==Integer.TYPE 结果就是true。type表示的是包装类的基本类型的字节码

数组也是一种类型。用isArray（）判断

总之，只要是在原程序中出现的类型都有各自的Class实例对象，int[]、void……

3、反射的应用

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

得到某个类所有的构造方法：

例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：

例子：Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);//获得方法时要用到上面相同的类型创建实例对象：
通常方式：String str=new String(new StringBuffer("abc"));
反射方式：String str=(String)constructor.newlnstance(new StringBuffer("abc"));

Class.newInstance()方法：

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

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

代码：

new String (new StringBuffer("abc"));
//String.class.getConstructor(StringBuffer.class);
Constructor constructor1= String.class.getConstructor(StringBuffer.class);
String str2=(String) constructor1.newInstance(new StringBuffer("abc"));
//在编译器时并不知道constructor的具体类型所以告诉编译器（String）
System.out.println(str2.charAt(2));

newInstance（）详解

在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式？这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。

Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。

例如：

class c = Class.forName(“Example”);

factory = (ExampleInterface)c.newInstance();

其中ExampleInterface是Example的接口

可以写成如下形式：

String className = "Example";
class c = Class.forName(className);
factory = (ExampleInterface)c.newInstance();

进一步可以写成如下形式：

String className = readfromXMlConfig;//从xml 配置文件中获得字符串
class c = Class.forName(className);
factory = (ExampleInterface)c.newInstance();

上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。

从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。

现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。

最后用最简单的描述来区分new关键字和newInstance()方法的区别：

newInstance: 弱类型。低效率。只能调用无参构造。

new: 强类型。相对高效。能调用任何public构造。
（2）File类

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

演示用eclipse自动生成Java类的构造方法

问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。

示例代码：

ReflectPoint point = new ReflectPoint(1,7);

Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");

System.out.println(y.get(point));

//Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");

Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");

x.setAccessible(true);

System.out.println(x.get(point));

获取一个类中的成员变量

这里有一个类包含x，y变量

package cn.itcast.day1;

public class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x, int y) {
super();
this.x = x;<pre name="code" class="java">
</pre>this.y = y;}}
<pre></pre>
用反射方式获取变量
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>

ReflectPoint pt1= new ReflectPoint(3,5);
Field fieldY =pt1.getClass().getField("y");
//filedY不是对象身上的变量。而是类上，要用它去取某个对象上对应的值
System.out.println(fieldY.get(pt1));
Field fieldX =pt1.getClass().getDeclaredField("x");
//x是私有的直接用会报错,所以使用getDeclaredField方法
fieldX.setAccessible(true);//暴力获取
System.out.println(fieldX.get(pt1));

（3）Method

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

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

调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str,1));

如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

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

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

Method methodCharAt= String.class.getMethod("charAt",int.class);
System.out.println(methodCharAt.invoke(str1,1));
//当invoke的第一参数是null则说明该方法为静态

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

目标：

写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后,大家要明白为什么要用反射方式去调呀？

问题：

启动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的语法解释，因此会出现参数类型不对的问题。

解决办法：

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

（5）数组的反射

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

int[] a1=new int [3];
int[] a2 = new int [4];
sys(a1.getClass()==a2.getClass());

结果是true。

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

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

int[] a1=new int [3];
int[] a2 = new int [4];
int[] []a3= new int [2][4];
String [ ]a4 =new String[3];

Object  aobj1=a1;//数组
Object  aobj2=a2;//数组
Object [ ] aobj3=a1;//int基本类型不可以作为Object[]
Object [ ] aobj4=a3;//int [ ]是数组他属于Object类型，可以作为Object
Object [ ] aobj5=a4;//String

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

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

（6)ArrayList HashSet的比较及Hashcode分析。

首先重写了Hashcode方法

public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}

Collection collecitons= new HashSet();

ReflectPoint pt1=new ReflectPoint(3,3);

ReflectPoint pt1=new ReflectPoint(5,3);

ReflectPoint pt1=new ReflectPoint(3,3);

collections.add(pt1);

collections.add(pt2);

collections.add(pt3);

pt1.y=7;

collections.remove(pt1);
这时我们在存储之后对y进行修改后，发现删除没有成功，因为修改y之后变量在内存中的hashcode就变了，所以无法删除，这就是造成了内存溢出
（7）练习：
将任意一个对象中的所有的String类型的成员变量所对应的字符串内容中的“b”改成”a“。

package cn.itcast.day1;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
changeStringValue(pt1);
System.out.println(pt1);
}
private static void changeStringValue(Object obj) throws Exception {
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//if(field.getType().equals(String.class)){
//比较字节码用 ==
if(field.getType() == String.class){
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}
}
}

package cn.itcast.day1;
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;
}
<span style="white-space:pre">	@Override</span>
//为了打印效果，覆盖toString方法
public String toString(){
return str1 + ":" + str2 + ":" + str3;
}
}

4、反射的作用（实现框架功能）

1)框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
2)框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
3)综合案例
先直接用new 语句创建ArrayList和HashSet的实例对象，要注意用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
引入了elipse对资源文件的管理方式的讲解。

package cn.itcast.day1;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;
public class ReflectTest2 {
public static void main(String[] args) throws Exception{
InputStream ips = new FileInputStream("config.properties");
Properties props = new Properties();
props.load(ips);
ips.close();
String className = props.getProperty("className");
Collection collections = (Collection)Class.forName(className).newInstance();//newInstance()调用无参构造方法
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System.out.println(collections.size());
}
}

package cn.itcast.day1;
public class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final ReflectPoint other = (ReflectPoint) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}

配置文件信息



-------android培训、Java培训、期待与您交流！
----------