写在前面的话:今天把张孝祥老师的关于反射的部分看完了,首先敬老师传授给我知识!谢谢老师深入、生动、透彻的讲解,好了闲言少叙,反射提高了java程序的灵活性,尤其是在框架开发中的应用,通过一个对象引用我们可以获取这个类的构造方法、方法、成员(包括私有成员)。
反射:就是把java类的各种成分映射成相应的类。
第一讲 反射的基石——》Class类
Class 类:众多的java类属于同一事物,描述这类事物的java类名就是Class、
比如 众多的人用一个Person类来表示,众多的java类用Class表示
每一个类在内存中都会有一份字节码,每一份字节码就是一个Class类的实例对象。
例如:Person p1 = new Person();
Person p2 = new Person();
Date d = new Date();
对Class实例化:Class cls1 = Date.class;//字节码
Class cls2 = Person.class;
1. 对象.getClass();
p1.getClass();//获取p1对应的字节码
2. Class.forName("类包");
Class.forName("java.lang.String");
forName();的作用:1,返回已加载类的字节码。2,对于还未加载到java虚拟机中的类,用类加载器去加载,把加载的字节码放到缓存区然后返回。
3. 类名.class,
例如System.class.
九个预定义的Class对象中,包括八个基本类型加一个void
int .class == Integer.TYPE
数组类型的Class实例对象,用Class.isArray();来判断是不是数组类型的;
总之,只要在源程序中出现的类型,都有各自的Class实例对象
第二讲 理解反射的概念 (类中的方法可以映射成反射中的Method类)
反射就是把java类的各种成分(包 构造方法 方法 成员变量)映射成相应的java类
例如System中有:System.exit、System.getProperties,System中的这些方法都可以用一个类Method来表示,
方法 对象 指向具体的方法
Method——》methodobj1——》exit
Method——》methodobj2——》getProperties
第三讲 构造方法的反射应用 (类中的一个构造方法可以映射成放射中的Constructor类)
Constructor类代表某个类中的一个构造方法。
1.得到某个类的所有构造方法。
Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
2.得到某一个构造方法,
Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
3.创建实例对象,
通常方式:String str = new String(new StringBuffer("abc"));
反射方式:String str = (String)constructor.newInstance(new StringBuffer("abc"));
调用获得的方法,要用到上面相同类型(String)的实例对象,
4. Class.newInstance();获取不带参数的构造方法,然后用该方法创建实例对象,
例子:String obj = (String) Class.forName("java.lang.String").newInstance();
第四讲 成员变量的反射
1.Field类:代表某个类中的一个成员变量。
2.演示反射获取成员变量的方法
获取公有的方法:
ReflectPoint pt1 = new ReflectPoint(3, 5);
Field fieldY = pt1.getClass().getField("y");
此时的fieldY还没有具体值,代表了一个变量。下面取出pt1下的y的具体值
//fieldY不是对象上的变量,而是类的变量,要用它去取对象上的对应的值。
System.out.println(fieldY.get(pt1));
获取私有成员变量的方法:暴力反射,获取类中的私有成员的方法。
Step1.使定义的成员(无论公有还是私有)处于可见
Field fieldX = pt1.getClass().getDeclaredField("x");
Step2.使成员处于可被取状态
fieldX.setAccessible(true);
Step3.取出并打印。
System.out.println(fieldX.get(pt1));
第五讲 成员变量反射的综合案例
1.代码演示。将所有成员变量的某个字母修改。
/*
* 步骤:
* 1.得到所有的字段
* 2.扫描字段,找出String类型的字段。
* 3.修改String类型字段的值,并保存
* */
代码:
private static void changeStringValue(Object obj)throws Exception {
//step 1获取对象obj中的所有成员
Field[] fields = obj.getClass().getFields();
//step 2 对获取到的成员进行遍历,并判断是否是某一类型(String类型)
//根据字节码是否相等来进行判断是不是同一类型成员。
for(Field field : fields)
{
//判断字节码相等用==号,而不用equals.
//if(field.getType().equals(String.class)))
if(field.getType()==String.class)
{
//step 3 对String类型的成员进行获取值的获取,并替换保存。
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}
}
第六讲 成员方法的反射
Method类:代表某个类中的一个成员方法。(Constructor代表构造方法)
1.得到类中的某个方法。
Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);
2.调用方法。
通常方式:System.out.println(str.charAt(1));
反射方式:System.out.println(charAt.invoke(str,1));
注意:如果传递给Method对象的invoke()方法的第一个参数为null,这就说明
该Method对象对应的是一个静态方法。
实例:获取charAt()方法,并进行调用。
//str1.charAt(1);
用反射的方式得到这个字节码上的方法。在用该方法作用于某个对象,在这里作用于对象str1。
Method methodCharAt = String.class.getMethod("charAt", int.class);
调用获取的方法,并打印
System.out.println(methodCharAt.invoke(str1, 1));
//调用方式jdk1.4
System.out.println(methodCharAt.invoke(str1, new Object[] {2}));
第七讲 对接收数组参数的成员方法进行反射
1.根据用户提供的类名(类中有静态代码)调用该类中的main方法。
//调用主函数的main方法语句。
TestArguments.main(new String[]{"hehe","123"});
//定义用户类
class TestArguments{
//定义一个静态方法,调用主函数的main方法
public static void main(String[] args){
for(String arg : args)
{
System.out.println(arg);
}
}
2.用反射调用主函数的main方法
如何给invoke方法传递参数呢?
按照jdk1.4的语法,数组中的每一个元素对应一个参数,jdk1.5兼容了1.4版本,
当把数组传递给invoke方法时,javac会把数组打散成若干个单独的参数。所以有
以下两种解决办法
解决方法:
1.给要传递的数组添加一个包装,即使打散后还是一个整体的数组
mainMethod.invoke(null, new Object[]{new String[]{"hehe","123"}});
2.将这个数组封装成一个对象,告诉javac,不可以拆
mainMethod.invoke(null, (Object)new String[]{"hehe","123"});
第八讲 数组与Object的关系及其反射类型
1.具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。
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());//字节码相等
2.基本类型的一维数组可以被当做Object类型使用,不可以被当做Object[]类型使用。
非基本类型的一维数组,既可以 又可以 你懂得
3.Arrays.asList()方法在处理int[]和String[]时的差异。
第九讲 数组的反射应用
1.Array工具类完成对数组的反射操作。
//数组反射应用(主函数中的语句)
Object obj = null;
printObject(a4);
printObject("xyz");
private 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);
}
}
代码实例:这是第一讲到第九讲所有的代码具体实现。
package Reflect;
public class ReflectPoint {
<span style="white-space:pre"> </span>//定义两个成员公有和私有
private int x;
public int y;
//定义String类型成员
public String str1 = "ball";
public String str2 = "basketball";
public String str3 = "itcast";
//通过构造方法给x和y赋值,创建构造函数(快捷键)
public ReflectPoint(int x, int y) {
super();
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;
ReflectPoint other = (ReflectPoint) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
@Override
<span style="white-space:pre"> </span>//复写toString方法
public String toString(){
return str1+"****"+str2+"******"+str3;
}
}
代码实例:
<pre name="code" class="java">package Reflect;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class reflectTest1 {
public static void main(String[] args)throws Exception {
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);
System.out.println(cls1.isPrimitive());//是否是基本类型,false
System.out.println(int.class.isPrimitive());
System.out.println(int.class==Integer.class);//基本类型跟包装类
System.out.println(int.class==Integer.TYPE);//定义了一个基本类型的变量
System.out.println(int[].class.isPrimitive());//定义了一个数组,不是基本类型
System.out.println(int[].class.isArray());//判断是不是数组
//new String(new StringBuffer("abc"));
//第一个StringBuffer表示选择哪个构造方法,第二个用来传参数进去
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2.charAt(2));
<span style="white-space:pre"> </span>//获取公有成员
ReflectPoint pt1 = new ReflectPoint(3, 5);
Field fieldY = pt1.getClass().getField("y");
//此时的fieldY还没有具体值,代表了一个变量。下面取出pt1下的y的具体值
//fieldY不是对象上的变量,而是类的变量,要用它去取对象上的对应的值。
System.out.println(fieldY.get(pt1));
//暴力反射,获取类中的私有成员的方法。
Field fieldX = pt1.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
<span style="white-space:pre"> </span>//改变String类型成员变量的值
changeStringValue(pt1);
System.out.println(pt1);
//str1.charAt(1);
//用反射的方式得到这个字节码上的方法。在用该方法作用于某个对象,
Method methodCharAt = String.class.getMethod("charAt", int.class);
System.out.println(methodCharAt.invoke(str1, 1));
//JDK1.4版本的调用方法
System.out.println(methodCharAt.invoke(str1, new Object[] {2}));
//静态代码调用main方法。
TestArguments.main(new String[]{"hehe","123"});
//用反射调用main方法。
/*String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod("mian", String[].class);
//mainMethod.invoke(null, new Object[]{new String[]{"hehe","123"}});
mainMethod.invoke(null, (Object)new String[]{"hehe","123"});*/
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"};
//维数相同的基本类型数组,判断其字节码是否相同。
<span style="white-space:pre"> </span>System.out.println(a1.getClass() == a2.getClass());
//System.out.println(a1.getClass() == a3.getClass());
//System.out.println(a1.getClass() == a4.getClass());
System.out.println(a1.getClass().getName());
System.out.println(a1.getClass().getSuperclass().getName());
System.out.println(a4.getClass().getSuperclass().getName());
//数组反射应用
Object obj = null;
printObject(a4);
printObject("xyz");
}
private static void printObject(Object obj) {
<span style="white-space:pre"> </span>//获取传进来的对象的内容。
Class clazz = obj.getClass();
<span style="white-space:pre"> //判断是不是一个数组</span>
if(clazz.isArray())
{
<span style="white-space:pre"> //获取数组长度并遍历打印</span>
int len = Array.getLength(obj);
for(int i=0;i<len;i++)
{
System.out.println(Array.get(obj, i));
}
}
else
{
System.out.println(obj);
}
}
private static void changeStringValue(Object obj)throws Exception {
//扫描类的对象中所有String类型的变量
/*
* 步骤:
* 1.得到所有的字段
* 2.扫描字段,找出String类型的字段。
* 3.修改String类型字段的值,并保存
* */
//step 1 得到所有的字段
Field[] fields = obj.getClass().getFields();
//step 2 扫描字段,找出String类型的字段
for(Field field : fields)
{
//判断字节码相等用==号
//if(field.getType().equals(String.class)))
if(field.getType()==String.class)
{
//step 3 修改String类型字段的值,并保存
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}
}
}
class TestArguments{
//定义一个静态方法,调用主函数的main方法
public static void main(String[] args)throws Exception{
for(String arg : args)
{
System.out.println(arg);
}
}
}
第十讲 ArrayList_HashSet的比较及Hashcode分析 1.ArrayList和HashSet的不同 ArrayList集合允许重复的元素存在,而HashSet一旦发现要存 入的元素跟已有元素的哈希值相同就不进行存入操作。 默认的equals方法比较的是哈希值,以下的这种情况中,pt1!=pt3的 ReflectPoint pt1 = new ReflectPoint(3, 3); ReflectPoint pt2 = new ReflectPoint(5, 5); ReflectPoint pt3 = new ReflectPoint(3, 3); HashCode方法的作用:可以防止内存泄露。 方便查询,根据哈希值。 防止重复元素。 第十一讲 框架的概念及用反射技术开发框架的原理 1.框架开发中反射的应用。 框架开发中我们往往不知道将来要调用的类的具体名字,我们可以将类名写在配置文件中 然后再代码中利用反射技术获取配置文件中的类名,然后实例化即可 配置文件信息:className=java.util.HashSet
代码实例:
package Reflect;
import java.io.FileInputStream;
import java.util.Collection;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest2 {
public static void main(String[] args) throws Exception{
//首先要加载配置文件。
FileInputStream ips = new FileInputStream("config.properties");
Properties prop = new Properties();
prop.load(ips);
<span style="white-space:pre"> </span>//切记关闭资源
ips.close();
<span style="white-space:pre"> </span>//获取配置文件中的类名并实例化
String className = prop.getProperty("className");
Collection collections = (Collection) Class.forName(className).newInstance();
//此处可以比较HashSet和ArrayList
Collection collections = new HashSet();
//Collection collections = new ArrayList();
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);
//内存泄露。
//pt1.y = 7;
//collections.remove(pt1);
System.out.println(collections.size());
}
}
水平有限,不足之处请指教,谢谢