反射的基石---->Class类
Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class
如何得到各个字节码对象的事例对象（Class类型）,提供下面三种方法(第三种用的比较多)
1:类名.class 例如System.class
2:对象.getClass() 例如 new Date().getClass()
3:Class.forName("类名"); 例如 Class.forName("java.lang.String");
九个预定义Class实例对象：
八个基本数据类型（boolean,char,byte,short,int,lang,float,double）加void
数组类型的Class实例对象：
class.isArray()
总之，只要在源程序中出现的类型，都有各自的Class实例对象，例如int[],void---
下面用代码演示下：
public class ReflectTest {
/**
* @param args
*/
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
String str1 = "abc";
Class cla1 = str1.getClass();
Class cla2 = String.class;
Class cla3 = Class.forName("java.lang.String");
//验证三种方法是不是同一份字节码，答案都是true
System.out.println(cla1==cla2);
System.out.println(cla1==cla3);
System.out.println(cla1.isPrimitive());//判断是否是一个基本数据类型
System.out.println(int.class==Integer.class);//int和Integer是不同类型，各自有自己的字节码
System.out.println(int.class==Integer.TYPE);//TYPE用来表示所包装的那份基本类型的字节码
//数组出现的类型也有自己的字节码，用isArray()判断
System.out.println(int[].class.isPrimitive());
System.out.println(int[].class.isArray());
}
}
反射
概念：就是把JAVA类中的各种成分映射成相应的JAVA类
例如：
一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的JAVA类来表示，就像汽车是一个类，
汽车的发动机，变速箱等等也是一个个类。表示java类的Class类显然就是提供一系列方法，来获得其中的变量，方法和构造方法，修饰符，包等等信息，这个
信息就是用相应类的事例对象来表示，它们是Field。Method。Constructor。Package等等
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么作用呢？
怎么用？这正是学习反射的要点。。
Constructor类
1、概述：Constructor代表某个类的构造方法
2、获取构造方法：
1）如何得到某个类的所有构造方法：如得到String类的所有构造方法
Constructor[] cons = Class.forName(“java.lang.String”).getConstructors()；
2）获取某一个构造方法：
Constructor con =String.class.getConstructor(StringBuffer.class);①
调用获得的方法时要用到上面相同类型的实例对象，即两个StringBuffer()要对应相等。
3）NewInstance()：构造出一个实例对象，每调用一次就构造一个对象。
String str = (String)con.newInstance(new StringBuffer(“abc”));②
下面用代码获取String类中带StringBuffer的构造函数进行设值然后获取，
演示下：
//下面用反射方式
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);//得到String类中的构造方法，构造方法必须有StringBuffer参数，详情可看api
String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));//用类中的构造方法
System.out.println(str2.charAt(2));//打印结果 cField类
1、概述：Field类代表成员变量（字段）的反射。
下面对这个Field类进行一些反射的基本操作。
（1）创建一个类，对这个类进行操作。
package com.csii.test;
public class ReflectTest {
private int x;
public int y;
public String str1="abcabc";
public String str2 = "bbccdd";
public ReflectTest() {
super();
}
public ReflectTest(int x, int y) {
super();
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "ReflectTest [str1=" + str1 + ", str2=" + str2 + "]";
}
}
（2）通过反射对这个类的成员变量进行取值，，暴力反射取值。
public class FieldTest(){
public static void main(String[] args) {
ReflectTest reflect = new ReflectTest(5, 10);
//普通反射
Field fieldY = reflect.getClass().getField("y");
System.out.println(fieldY.get(reflect));
//暴力反射取值
Field fieldx = reflect.getClass().getDeclaredField("x");
fieldx.setAccessible(true);//强制取值
System.out.println(fieldx.get(reflect));
}
//打印结果10, 5
}public class ReflectField {
public static void main(String[] args) throws Exception{
changeStringValue();
}
//为了代码清晰直观，异常暂时抛出
public static void changeStringValue()throws Exception{
ReflectTest reflect = new ReflectTest(5,10);
Field[] fields = reflect.getClass().getFields();
//获取类里面所有方法，然后进行判断
for (Field field :fields) {
if(field.getType()==String.class){//，进行字节码对比，方法里面类型是String进行操作
String oldValue = (String) field.get(reflect);//获取对象方法强转String
String newValue = oldValue.replace('b', 'a');//修改里面内容
field.set(reflect, newValue);//修改以后设置回去
System.out.println(reflect.toString());
//打印结果如下，对数据进行了修改
// ReflectTest [str1=aacaac, str2=bbccdd]
// ReflectTest [str1=aacaac, str2=aaccdd]
}
}
}
}Method类
1、概述：Method类代表某个类中的一个成员方法。
调用某个对象身上的方法，要先得到方法，再针对某个对象调用。
2、专家模式：谁调用这个数据，就是谁在调用它的专家。
如人关门：
调用者：是门调用管的动作，对象是门，因为门知道如何执行关的动作，通过门轴之类的细节实现。
指挥者：是人在指挥门做关的动作，只是给门发出了关的信号，让门执行。
总结：变量使用方法，是方法本身知道如何实现执行的过程，也就是“方法对象”调用方法，才执行了方法的每个细节的。
3、获取某个类中的某个方法：（如String str = ”abc”）
1）通常方式：str.charAt(1)
2）反射方式：
Method charAtMethod =
Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);
charAtMethod.invoke(str,1);
说明：如果传递给Method对象的invoke()方法的第一个参数为null，说明Method对象对应的是一个静态方法
4、用反射方式执行某个main方法：
首先要明确为何要用反射：在写源程序时，并不知道使用者传入的类名是什么，但是虽然传入的类名不知道，而知道的是这个类中的方法有main这个方法，所以可以通过反射的方式，通过使用者传入的类名（可定义字符串型变量作为传入类名的入口，通过这个变量代表类名），内部通过传入的类名获取其main方法，然后执行相应的内容。
- //Method类演示
- private static void methodTest(String [] args) throws Exception {
- String str1 = "abc";
- //一般方法：
- System.out.println(str1.charAt(1));
- //反射方法 ：
- Method methodCharAt =
- Class.forName("java.lang.String").getMethod("charAt",int.class);
- System.out.println(methodCharAt.invoke(str1,1));
- //用反射方式执行某个main方法
- //一般方式：
- Test.main(new String[]{"111","222","333"});
- System.out.println("-------");
- //反射方式：
- String startingClassName = args[0];
- Method methodMain =
- Class.forName(startingClassName).getMethod("main",String[].class);
- //方案一：强制转换为超类Object，不用拆包
- methodMain.invoke(null,(Object)new String[]{"111","222","333"});
- //方案二：将数组打包，编译器拆包后就是一个String[]类型的整体
- methodMain.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);
- }
- }
- }
数组的反射
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作。
思考题：怎么得到数组中的元素类型？
int [] a1 = new int[]{1,2,3};
int [] a2 = new int[5];
int [][] a3 = new int[2][3];
String [] a4 = new String[]{"a","b","c"};
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 aObj1 = a1;
Object aObj2 = a4;
//Object[] aObj3 = a1;//int这样的基本数据类型不是Object数组
Object[] aObj4 = a3;
Object[] aObj5 = a4;
System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));
System.out.println(Arrays.asList(a4));
printObject(a4);
printObject("azc");
}
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);
}
}
ArrayList和HashSet和Hashcode分析
package cn.itcast.day1;
public class ReflectPoint {
/**
* @param args
*/
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;
}
@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;
}
package cn.itcast.day1;
import java.util.Collection;
import java.util.HashSet;
public class RefkectTest2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection collections = new HashSet();//用Hashcode比较
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);
//collections.remove(pt1);//删除一个的话就剩下一个
System.out.println(collections.size());//打印结果是2个
}
}反射的作用。实现框架功能
框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
综合案例
先直接用new 语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
引入了elipse对资源文件的管理方式的讲解。
代码演示：
用字节输入流输入config.properties文件的框架className=java.util.ArrayList
//InputStream ips = new FileInputStream("D:/eclipse/eclipse/staticimport/staticimport/src/cn/itcast/day1/config.properties");
//搞类加载器然后加载资源
InputStream ips =RefkectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");
//InputStream ips =RefkectTest2.class.getResourceAsStream("config.properties");
Properties props = new Properties();
props.load(ips);
ips.close();
String className = props.getProperty("className");
Collection collections = (Collection)Class.forName(className).newInstance();
730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
