黑马程序员-Java中反射

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

一、反射的概念
1、什么是反射机制
反射就是把Java类中的各种成分映射成相应的java类。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。
2、反射的优缺点
反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性。
它的缺点是对性能有影响。
二、Class类
1、Class类概念
Java程序中的各个Java类属于同一类事物,描述这类事物的Java类就是Class类。一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的。一个类在虚拟机中只有一份字节码。
2、获得Class对象
每个类被加载后，系统会为该类生成对应的Class对象，通过Class对象可以访问到JVM中的这个类，获得Class对象的三种方式：
a. 类名.class，例如，System.class。
b. 对象.getClass()，例如，new Date().getClass()。
c. Class.forName("类名")，例如，Class.forName("java.util.Date")。
3、预定义Class对象
基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void通过class属性也表示为 Class 对象。
Int.class == Integer.TYPE。
数组类型的Class实例对象Class.isArray()为true。
4、Class类中的方法
static Class forName(String className)：返回与给定字符串名的类或接口的相关联的Class对象
Class getClass()：返回Class对象即字节码对象
Constructor getConstructor()：返回Constructor对象，它反映此Class对象所表示的类的指定公共构造方法。
Field getField(String name)：返回一个Field对象，它表示此Class对象所代表的类或接口的指定公共成员字段。
Field[] getFields()：返回包含某些Field对象的数组表示所代表类中的成员字段。
Method getMethod(String name,Class… parameterTypes)：返回一个Method对象，它表示的是此Class对象所代表的类的指定公共成员方法。
Method[] getMehtods()：返回一个包含某些Method对象的数组，是所代表的的类中的公共成员方法。
String getName()：以String形式返回此Class对象所表示的实体名称。 boolean isArray()：判定此Class对象是否表示一个数组
boolean isPrimitive()：判断指定的Class对象是否是一个基本类型。
T newInstance()：创建此Class对象所表示的类的一个新实例。
5、使用反射创建对象
步骤：
a. 获取该类的Class对象。
b. 利用Class对象的getConstructor()方法来获取指定的构造方法。
c. 申请访问（设置为可访问）
d. 调用Constructor（构造方法）的newInstance()方法创建对象。
范例：

//Person类
public class Person {
private String name;
public int age;
public Person(){
System.out.println("Person is run");
}
public Person(String name,int age){
this.age=age;
this.name=name;
}

public String toString(){
return name+":"+age;
}
}
//示例
public class CreateClassDemo {
public static void main(String[] args) throws Exception {
createPersonClass();
}
//通过Class对象创建类实例方法
public static void createPersonClass() throws Exception{
//获取Person类的Class对象
String className="cn.frotly.Person";
Class clazz=Class.forName(className);
//通过newInstance方法获取类的无参构造函数实例
Person p=(Person)clazz.newInstance();
}
}

三、构造方法的反射
1、Constructor
Constructor类代表某个类中的一个构造方法。Constructor对象上的方法有：得到方法名字，得到所属于的类，产生实例对象。
2、获取类的构造方法
2.1得到某个类所有的构造方法：
Constructor[] constructors=Class.forName("java.lang.String").getConstructors();
2.2 得到某一个构造方法：
Constructor constructor =Class.forName("java.lang.String").getConstructor(StringBuffer.class);
注意：一个类有多个构造方法，可以根据参数的个数和类型区分清楚想得到其中的哪个方法呢，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。其中，参数类型用用Class实例对象表示。
3、创建实例对象
通常方式：String str = new String(new StringBuffer("abc"));
反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
Class.newInstance()方法：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
范例：

//Constructor演示
import java.lang.reflect.Constructor;

public class ReflectTest {

public static void main(String[] args) throws Exception {
//获取类的构造方法
Constructor constructor = String.class
.getConstructor(StringBuffer.class);
//创建实例对象
String str = (String) constructor.newInstance(new StringBuffer("abc"));
System.out.println(str.charAt(2));
}
}

输出结果：
c

四、成员变量的反射
Field类代表某个类中一个成员变量
Field getField(String s);//只能获取公有和父类中公有。
Field getDeclaredField(String s);//获取该类中任意成员变量，包括私有。
setAccessible(ture);//如果是私有字段，要先将该私有字段进行取消权限检查的能力，也称暴力访问。
set(Object obj, Object value);//将指定对象变量上此Field对象表示的字段设置为指定的新值。
Object get(Object obj);//返回指定对象上Field表示的字段的值。
范例：

//Field演示
//替换一个对象中String类型变量的字符串内容
import java.lang.reflect.Field;

class ReflectPoint {
private int x;
public int y;
public String str1 = "player";
public String str2 = "basketball";
public String str3 = "trainer";

public ReflectPoint(int x, int y) {
this.x = x;
this.y = y;
}

@Override
public String toString() {
return str1 + ":" + str2 + ":" + str3;
}
}

public class ReflectFieldDemo {

public static void main(String[] args) throws Exception {
// 创建ReflectPoit对象并初始化
ReflectPoint rp = new ReflectPoint(3, 5);
// 获取私有变量内容
Field fieldX = rp.getClass().getDeclaredField("x");
// 暴力反射
fieldX.setAccessible(true);
System.out.println(fieldX.get(rp));

changeStringValue(rp);
System.out.println(rp);
}

// 替换字符函数
public 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);// 设置新值
}
}
}
}

输出结果：
3
player:aasketaall:trainer

五、成员方法的反射
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对象对应的是一个静态方法。
范例：

import java.lang.reflect.Method;

public class ReflectMethodDemo {

public static void main(String[] args) throws Exception {
String str = "abc";
//运用成员方法的反射获取类中的方法
Method methodCharAt = String.class.getMethod("charAt" , int.class );
//运用成员方法的反射调用方法
System. out.println(methodCharAt.invoke(str, 1));
System. out.println(methodCharAt.invoke(str, new Object[]{2}));
}
}

输出结果为
b
c

六、接受数组参数的成员方法反射
启动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"}); 编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。
范例：

import java.lang.reflect.Method;

public class ReflectMainDemo{

public static void main(String[] args) throws Exception {
String startingClassName = args[0];
//运用反射获取main方法
Method mainMethod = Class.forName(startingClassName).getMethod( "main", String[]. class);
//执行main方法
mainMethod.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);
}
}
}

输出结果：
111
222
333

七、数组与Object的关系及其反射类型
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
范例：

//数组反射演示

import java.lang.reflect.Array;
import java.util.Arrays;

public class ReflectArrayDemo {

public static void main(String[] args) throws Exception {
int[] a1 = new int[3];
int[] a2 = new int[4];
int[][] a3 = new int[2][3];
String[] a4 = new String[3];

// 判断数组类型
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());
System.out.println(a4.getClass().getSuperclass().getName());

Object aObj1 = a1;
Object aObj2 = a4;
// a1是int 类型的数组，int 不是Object，因此编译就会报错
// Object[] aObj3 = a1;
// a3是数组的数组，第二维数组也是一维数组，父类是Object，因此不会报错
Object[] aObj4 = a3;
// a4是String的数组，String父类是Object，因此不会报错
Object[] aObj5 = a4;

int[] a5 = new int[] { 1, 2, 3 };
String[] a6 = new String[] { "a", "b", "c" };
// 直接使用System.out.println无法打印出数组的内容
System.out.println(a5);
// 结果：[I@18a992f
System.out.println(a6);
// 结果：[Ljava.lang.String;@4f1d0d

// 通过Arrays.asList方法打印出数组的内容
System.out.println(Arrays.asList(a5));
// 结果：[[I@18a992f]
// 原因是因为JDK1.4中为Arrays.asList(Object[] a)，JDK1.5中为Arrays.asList(T... a)。
// a5是int[]类型，JDK1.4中的asList方法处理不了，JDK1.5可以处理。但是JDK1.5将
// int数组整体作为一个参数进行处理。
// 因此最终结果就是将 int[]进行了封装，结果类型也就成了[[I。
System.out.println(Arrays.asList(a6));

String[] a7 = new String[] { "a", "b", "c" };
String a8 = "xyz";

printObject(a7);
printObject(a8);
}

// ArrayList工具类对数组进行反射操作
public 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);
}
}
}

输出结果：
true
[I
java.lang.Object
java.lang.Object
[I@659e0bfd
[Ljava.lang.String;@2a139a55
[[I@659e0bfd]
[a, b, c]
a
b
c
xyz

八、ArrayList_HashSet的比较及Hashcode分析
范例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

class ReflectList {
private int x;
public int y;

public ReflectList(int x, int y) {
super();
this.x = x;
this.y = y;
}

// 覆盖hashCode方法以及equals方法。
@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;
ReflectList other = (ReflectList) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}

}

public class ReflectTest {

public static void main(String[] args) throws Exception {

// Collection collections = new ArrayList();
Collection collections = new HashSet();
ReflectList pt1 = new ReflectList(3, 3);
ReflectList pt2 = new ReflectList(5, 5);
ReflectList pt3 = new ReflectList(3, 3);

collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);

pt1.y = 70;
collections.remove(pt1);
// pt1对象的y属性被修改了，因此该对象的哈希值也被修改了，所以无法删除掉。因此size值还是2

System.out.println(collections.size());
}
}

当集合为ArrayList时，其实质是一个数组，因此放入4个元素后，集合size为4。当集合为HashSet时，需要通过比较hashcode值以及equals方法是否返回true决定是否放入。如果hashcode值相等并且equals方法返回true，那么就不会放入。因此，集合size为3。如果想让size为2，也就是pt1与pt3作为同一个元素存入HashSet集合，那就需要覆盖ReflectPoint类的hashCode方法以及equals方法。
当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。

九、框架与反射
框架通过反射调用Java类的一种方式。通常调用用户提供给的类，而不是被用户调用。在程序中无法直接new某个类的实例对象，可以用反射的方式。
范例：

//框架——将调用的类放在配置文件中
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;

public class ReflectTest {

public static void main(String[] args) throws Exception {
//加载配置文件
InputStream is = new FileInputStream("config.properties" );
//将配置文件中的内容放进集合操作
Properties props = new Properties();
props.load(is);
is.close();
//获取集合中的类名
String className = (String)props.get( "className");
//创建相应集合对象，完成对应配置文件中类的操作
Collection collections = (Collection)Class.forName(className).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());
}
}

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