-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
第一讲.概述
- Class类：Java中对类这个抽象概念的描述，是一个“描述类的类”，说起来比较哲学。。
- Class类存放在java.lang包中，同样的像构造器(Constructor)，字段(Field)，方法(Method)这些抽象概念也被一一描述并存放在这里。当然它们都是Class类的属性了，都存在java.lang.reflect包中。
- JVM在使用某个类之前需要对其进行加载，也就是说把这个类对应的Class对象加载进内存中(也可以说是把编译生成的.class字节码文件加载进内存中)，通过这个Class对象映射出这个类的实例。而反射呢，就是一种反溯的过程了。
- 有三种方法得到Class对象(就以String为例了)：
String str = "abc";
//第一种：利用实例的getClass()方法
Class cls1 = str.getClass();
//第二种：利用类的class属性，当然这些方法属性都是从Object继承的
Class cls2 = String.class;
//第三种：用Class的forName静态方法，类名需是完整的
Class cls3 = Class.forName("java.lang.String");
//Class类的对象在内存中是唯一的(类加载器什么的。。)，所以下列判断皆为真，
System.out.println(cls1 == cls2);
System.out.println(cls2 == cls3); - Class对象中一些基本的判断型方法：
//isPrimitive()基本类型，isArray()是否为数组System.out.println(cls1.isPrimitive());System.out.println(int.class.isPrimitive());//基本类型与其包装类不是相同的。。基本类型甚至都不是Object。。System.out.println(int.class == Integer.class);//八大基本类型的包装类中有TYPE字段，标识出其基本类型System.out.println(int.class==Integer.TYPE);//数组类型就是数组类型啦~System.out.println(int[].class.isPrimitive());System.out.println(int[].class.isArray());
第二讲. 构造方法、字段、方法的反射
- 构造方法的反射
//得到构造方法 Constructior getConstructor(Class class);
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
//编译时不知道返回结果类型，所以用强制类型转换
str = (String)constructor1.newInstance(new StringBuffer("abcd"));
//甚至连constructor1是谁的哪一个构造方法都不知道，所以可以说反射把报错的时机都推迟到运行时了。。。
System.out.println(str); - 字段的反射
//获得属性字段：Field getField(String name)ReflectPoint rp1 = new ReflectPoint(3,5);Field fieldY = rp1.getClass().getField("y");System.out.println(fieldY.get(rp1));Field fieldX = rp1.getClass().getDeclaredField("x");//暴力反射，x是private字段，设置为可以访问fieldX.setAccessible(true);System.out.println(fieldX.get(rp1));//其中的ReflectPoint是这么定义的：class ReflectPoint{private int x;public int y;ReflectPoint(int x,int y){this.x=x;this.y=y;}} - 练习：将任意一个对象中所用String类型成员变量中的"b"变为"a"
//练习一：将任意一个对象中所用String类型成员变量中的"b"变为"a"//在main中这么写：Test test = new Test("badboy","balabala");test_1(test);System.out.println(test);//test_1如下：private static void test_1(Object obj)throws Exception{Field[] fields = obj.getClass().getDeclaredFields();String str = null;for(Field item:fields){//可以用Field的getType方法返回字段类型，详见JDKif(item.getType()==String.class){item.setAccessible(true);str = (String)item.get(obj);str = str.replace("b","a");item.set(obj,str);}}} - 方法的反射
//获得方法 Method getMethod(String name,Class class)Method methodCharAt = String.class.getMethod("charAt",int.class);System.out.println(methodCharAt.invoke(str,1));//等同于str.charAt(1);//若invoke的第一个参数为null，则method为静态方法 - 练习：动态调用其他类中的main方法
//练习二：调用其他类的main方法，通过主函数的args参数传入想要动态调用的类//下面代码效果如同：TestArguments.main(new String[]{"11","22"});//主函数里写：String className = args[0];Method mainMethod = Class.forName(className).getMethod("main",String[].class);mainMethod.invoke(null,new Object[]{new String[]{"11","22"}});//main为静态的//这里涉及到java为了兼容1.4以前版本，会自动对数组类型参数进行拆包(因为1.5有了可变参数)//这么做也行：mainMethod.invoke(null,(Object)new String[]{"11","22"});//TestArguments如下：class TestArguments{public static void main(String[] args){for(String str:args)System.out.println(str);}} - 数组的反射
//数组的反射int[] a = new int[]{1,2,3};//注意int[]并不是Object[]String[] b = new String[]{"a","b"};System.out.println(a.getClass().getName());//getSuperclass()可以获得父类Class对象,下面两句运行结果都是java.lang.ObjectSystem.out.println(a.getClass().getSuperclass().getName());System.out.println(b.getClass().getSuperclass().getName());//但是注意，这里int[]并不能解析为Object[]，拆包操作是只会把它当成单个Object处理//所以下面语句打印int[]的a还是类型加哈希值，而b就会正常打印数组元素System.out.println(Arrays.asList(a));System.out.println(Arrays.asList(b)); - 数组反射应用：模拟Java中的数组拆包操作。(注：由于1.5中可变参数的引入，java为了兼容1.4以前版本，会自动对数组类型参数进行拆包)
//主函数对printObject()进行如下的测试：printObject("xyz");printObject(new String[]{"x","y","x"});//printObject如下:private static void printObject(Object obj){Class cls = obj.getClass();//如果是数组的话,注意这里java.lang.reflect.Array的使用if(cls.isArray()){int len = Array.getLength(obj);for (int i=0;i<len ;i++ )System.out.println(Array.get(obj,i));}//否则就是只能解析成单个Object或者基本类型elseSystem.out.println(obj);}
第三讲. 基于反射的框架
- 张孝祥老师的视频里，有一段hashCode()的深入讲解，代码如下，ReflectPoint类就是上面那个。有一点，我们知道HashSet通过hashCode()和equals()判断元素是否相等，哈希值不一样，元素就会被散列到不同的区间去，肯定不同了。pt1和pt2逻辑上是相同的。所以应该重写哈希算法，使得pt1和pt2的哈希值相同。但此时，如果元素存入HashSet后再对其进行修改，必然导致哈希值的变化，这就将导致这个元素无法被remove()，不意识到这一点而对集合反复增删时，就会发生内存泄露。
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
class ReflectEx
{
public static void main(String[] args) throws Exception
{
Collection c = new HashSet();//new ArrayList();
//对于HashSet和ArrayList分别测试
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(2,4);
ReflectPoint pt3 = new ReflectPoint(3,3);
c.add(pt1);
c.add(pt2);
c.add(pt3);
//我们知道Set是不允许添加重复元素的，List可以
c.add(pt1);
//HashSet的size为3；ArrayList为4
System.out.println(c.size());
}
}
- 反射的应用：实现框架功能。简单来说，我们使用框架和工具是不一样的：使用者去使用工具，它替我们做了内部的事情；而框架是去调用使用者，它替我们做了外面(框架嘛~)的事情。
- 接下来就要把上面的代码做成一个框架的形式。在config.properties中存入className=java.util.ArrayList ，那么运行下面的代码就会输出size为4；把ArrayList改为HashSet就会得到size为3；整个过程用户只需对配置文件config.properties进行修改即可，无需再编译下面的代码~这则小例子体现了框架的优越性。
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
class ReflectEx
{
public static void main(String[] args) throws Exception
{
InputStream in = new FileInputStream("config.properties");
Properties props = new Properties();
props.load(in);
in.close();
String className = props.getProperty("className");
Class cls = Class.forName(className);
Constructor cons = cls.getConstructor();
Collection c = (Collection)cons.newInstance();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(2,4);
ReflectPoint pt3 = new ReflectPoint(3,3);
c.add(pt1);
c.add(pt2);
c.add(pt3);
c.add(pt1);
System.out.println(c.size());
}
}
第四讲.JavaBean简述
- JavaBean是一种特殊的Java类：有getter、setter。getter即int getAge()这种获取字段的方法；setter即getAge(int age)这种写入字段的方法。它们拥有明确的命名方法：get+属性名、set+属性名，当然为了满足匈牙利命名法则首字母变大写。
- 由于类中存储的数据(字段)一般是受保护(私有)的，对外不可见。只对外提供getter、setter方法，JavaBean中的属性名干脆就利用getter和setter的函数名进行推断。推断过程例如：getAge-->Age-->如果第二个字母是小的,则把第一个字母变成小的-->age。
- 反过来，知道属性名的前提下，也可以轻松获得getter、setter函数名，并且利用反射对字段进行修改和获取，JDK也是提供了相关api来简化这种操作。
import java.beans.*;//JavaBean相关api所在的包
import java.lang.reflect.*;
class JavaBeanDemo
{
public static void main(String[] args) throws Exception
{
Point p = new Point(3,4);
Object retVal = getProperty(p,"x");
System.out.println(retVal);
setProperty(p,"x",7);
System.out.println(p.getX());
}
private static Object getProperty(Object obj,String propertyName)throws Exception
{//通过任一JavaBean类中getter方法获得指定字段的值
//获得属性描述对象PropertyDescriptor，可以通过属性得到setter、getter方法
PropertyDescriptor dp = new PropertyDescriptor(propertyName,obj.getClass());
Method methodGetX = dp.getReadMethod();
Object retVal = methodGetX.invoke(obj);
return retVal;
}
private static void setProperty(Object obj,String propertyName,Object value)throws Exception
{//通过任一JavaBean类中setter来设置指定字段的值
//替我们完成了x-->X-->setX-->在目标类中查找对应函数名的Method对象，这一系列动作
PropertyDescriptor dp = new PropertyDescriptor(propertyName,obj.getClass());
Method methodSetX = dp.getWriteMethod();
methodSetX.invoke(obj,value);
}
}
class Point
{
private int x;
private int y;
Point(int x,int y){this.x = x;this.y = y;}
//注意：这里的public是必须加的。。。
public void setX(int x){this.x = x;}
public void setY(int y){this.y = y;}
public int getX(){return x;}
public int getY(){return y;}
} - 通过java.beans包中的Introspector内省(内窥镜)类，得到BeanInfo，可以获得所有满足JavaBean条件的字段的PropertyDescriptor对象数组。进而也可以通过遍历这些PropertyDescriptor对象来完成上面的功能。
private static Object getProperty(Object obj,String propertyName)throws Exception{//通过任一JavaBean类的getter方法获取指定字段的值BeanInfo beaninfo = Introspector.getBeanInfo(obj.getClass());PropertyDescriptor[] pds = beaninfo.getPropertyDescriptors();Object retVal=null;//遍历所有满足JavaBean规则的属性描述对象for (PropertyDescriptor pd:pds){if(pd.getName().equals(propertyName)){Method methodGetX = pd.getReadMethod();retVal = methodGetX.invoke(obj);}}return retVal;} - 张孝祥老师视频中还介绍了JavaBeanUtils工具包的应用等。