反射技术；其实就是动态加载一个指定的类，并获取该类中的所有内容。
而且将字节码文件与内容都封装成了对象。
这样便于操作这些成员，简单说；反射技术可以对一个类进行解刨。
反射的好处；大大的增强了程序的扩展性。
反射的基本步骤；
获得Class对象。就是获取到指定的名称的字节码文件对象。
实例化对象，获得类的属性，方法或构造函数。
访问属性，调用方法，调用构造函数创建对象。
获取Class对象有三种方法。
每个类都具备getClass();方法，弊端；必须要创建该类对象，才可以调用该方法。
每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。
前两种方式不利于程序的扩展，因为都需要在程序中使用具体的类来完成。
使用Class类中的静态方法forName。
指定什么类名，就获取什么类的字节码文件对象，输入类名字符串即可，扩展性强。
有八个基本数据类型。每一个基本数据类型都对应着Class字节码文件对象，void.class等等--
import java.lang.reflect.*;
class most1{
public static void main(String[] args)throws ClassNotFoundException{
String s1="abc";
Class c1=s1.getClass();
Class c2=String.class;
Class c3=Class.forName("java.lang.String");
System.out.println(c1==c2);
System.out.println(c1==c3);
System.out.println(c1.isPrimitive());
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());
}
}
反射；就是把java类中的各个成分映射成相应的类，反射比较消耗资源。
得到类的所有构造方法。
Constructor[] tts=Class.forName("java.lang.String").getConstructors();
得到类的一个构造方法。
Constructor tts=Class.forName("java.lang.String").getConstructor(StringBuffer.class);
import java.lang.reflect.*;
class ReflectDemo{
public static void main(String[] args)throws NoSuchMethodException,InstantiationException,IllegalAccessException,InvocationTargetException{
Constructor tts=String.class.getConstructor(StringBuffer.class);
String s1=(String)tts.newInstance(new StringBuffer("abc"));
System.out.println(s1.charAt(2));
}
}
获取类的变量：ReflectPoint pt=new ReflectPoint(3,5);
Field fieldY=pt.getClass().getField("y");
System.out.println(field.get(pt));
获取类的私有变量：Field fieldX=pt.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt));
import java.lang.reflect.*;
class ReflectPoint{
public int x;
private int y;
ReflectPoint(int x,int y){
this.x=x;
this.y=y;
}
}
class ReflectDemo{
public static void main(String[] args)throws NoSuchFieldException,IllegalAccessException{
ReflectPoint pt=new ReflectPoint(3,3);
Field fieldX=pt.getClass().getField("x");
System.out.println(fieldX.get(pt));
Field fieldY=pt.getClass().getDeclaredField("y");
fieldY.setAccessible(true);
System.out.println(fieldX.get(pt));
}
}
获取类的方法；// Class c1=obj.getClass();
Method method=Object.class.getMethod("charAt",int.class);
System.out.println(method.invoke(obj,index));
import java.lang.reflect.*;
class ReflectDemo{
public static void main(String[] args)throws NoSuchMethodException,IllegalAccessException,InvocationTargetException{
String s="abc";
Class c1=s.getClass();
Method method=String.class.getMethod("charAt",int.class);
System.out.println(method.invoke(s,1));
System.out.println(method.invoke(s,new Object[]{2}));
}
}
反射的用法；首先需要提供类的Class对象，获得Class对象的三种方式。
Class.forName() 用于做类加载。
obj.getClass()
用于获得对象的类型。
类名.class()
用于获得指定的类型，传参用。
获取了字节码文件对象后，最终都需要创建指定类的对象。
创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)
调用空参数的构造函数；使用了Class类中的newInstance方法。
调用带参数的构造函数；先要获取指定参数列表的构造函数对象。
然后通过该构造函数对象的newInstance进行对象的初始化。
替换一个类的变量内容；
import java.lang.reflect.*;
class ReflectPoint{
String s1="abll";
String s2="base";
String s3="itcast";
public String toString(){
return s1+"--"+s2+"--"+s3;
}
}
class ReflectDemo{
public static void main(String[] args)throws IllegalAccessException{
ReflectPoint pt=new ReflectPoint();
Field[] fields=pt.getClass().getDeclaredFields();
for(Field field:fields){
if(field.getType()==String.class){
String str=(String)field.get(pt);
String value=str.replace('b','a');
field.set(pt,value);
}
}
System.out.println(pt);
}
}
写一个程序；这个程序能够根据用户提供的类名去执行该类中的main方法。
启动java程序的main方法是一个字符数组，public static void main(String[] args){}
通过反射方式来调用这个main方法，按照jdk1.5的语法给invoke传递参数。
整个数组就是一个参数，而jdk1.4的语法数组中的每一个元素都对应一个参数。
当把一个字符串数组作为参数传递给invoke方法时，1.5兼容1.4的语法。
会按照1.4的语法进行处理，就将数组打散成若干个元素。
所以在给main方法传递参数时，不能使用代码。
method.invoke(null,new String[]{"","",""});java只把他当做1.4的语法处理。
而不把他当做1.5的语法处理，因此会出现参数类型不对的问题。
method.invoke(null,new Object[]{new String[]{"","",""}});
method.invoke(null,(Object)new String{}{"","",""});
编译器会作特殊处理；编译时不把参数当做数组看待，也就不会将数组打散。
import java.lang.reflect.*;
class ReflectPoint{
public static void main(String[] args)throws InvocationTargetException,ClassNotFoundException,NoSuchMethodException,IllegalAccessException{
for(String str: args){
System.out.println(str);
}
}
}
class ReflectDemo{
public static void main(String[] args)throws InvocationTargetException,ClassNotFoundException,NoSuchMethodException,IllegalAccessException{
String startName=args[0];
Method mainMethod=Class.forName(startName).getMethod("main",String[].class);
mainMethod.invoke(null,(Object)new String[]{"111","222","333"});
}
}
具有相同维数和元素类型的数组属于同一类型，具有相同Class实例对象。
代表数组的Class实例化对象的getSuperclass方法返回的是父类对应的Class。
基本类型的一维数组可以被当做Object类型使用，不能当做Object[]类型使用。
非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList方法处理int[]和String[]时的差异。
Array工具类用于完成数组的反射操作。
思考题；怎么得到数组中的元素类型？
import java.lang.reflect.*;
class ReflectDemo{
public static void main(String[] args){
String[] arr={"x","y","z"};
printObject(arr);
printObject("xyz");
}
public static void printObject(Object obj){
Class c=obj.getClass();
if(c.isArray()){
int len=Array.getLength(obj);
for(int x=0; x<len; x++){
System.out.println(Array.get(obj,x));
}
}else{
System.out.println(obj);
}
}
}
package pack;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
class ReflectPoint{
<span style="white-space: pre;"> </span>private int x;
<span style="white-space: pre;"> </span>private int y;
<span style="white-space: pre;"> </span>ReflectPoint(int x,int y){
<span style="white-space: pre;"> </span>this.x=x;
<span style="white-space: pre;"> </span>this.y=y;
<span style="white-space: pre;"> </span>}
<span style="white-space: pre;"> </span>public boolean equals(Object obj){
<span style="white-space: pre;"> </span>if(!(obj instanceof ReflectPoint))
<span style="white-space: pre;"> </span>throw new RuntimeException("类型不匹配");
<span style="white-space: pre;"> </span>ReflectPoint r=(ReflectPoint)obj;
<span style="white-space: pre;"> </span>return this.x==(r.x)&&this.y==r.y;
<span style="white-space: pre;"> </span>}
}
class ReflectDemo{
<span style="white-space: pre;"> </span>public static void main(String[] args){
<span style="white-space: pre;"> </span>Collection coll=new ArrayList();
<span style="white-space: pre;"> </span>ReflectPoint pt1=new ReflectPoint(3,3);
<span style="white-space: pre;"> </span>ReflectPoint pt2=new ReflectPoint(5,5);
<span style="white-space: pre;"> </span>ReflectPoint pt3=new ReflectPoint(3,3);
<span style="white-space: pre;"> </span>coll.add(pt1);
<span style="white-space: pre;"> </span>coll.add(pt2);
<span style="white-space: pre;"> </span>coll.add(pt3);
<span style="white-space: pre;"> </span>coll.add(pt1);
<span style="white-space: pre;"> </span>System.out.println(coll.size());
<span style="white-space: pre;"> </span>}
}