Java-反射总结

//作为反射点的类
public class ReflectPoint {
private Date birthday = new Date();

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;
final ReflectPoint other = (ReflectPoint) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
//反射练习类
public class ReflectTest {


/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
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());//原始类型包括byte short int long char float double void ，字符串不是原始类型
System.out.println(int.class.isPrimitive());
System.out.println(int.class == Integer.class);
System.out.println(int.class == Integer.TYPE);//int.class 和Ingeger.class 不同， int.class == Integer.TYPE相同
System.out.println(int[].class.isPrimitive());
System.out.println(int[].class.isArray());

//new String(new StringBuffer("abc"));
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);//通过类字节码获取构造方法对象
String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
System.out.println(str2.charAt(2));

ReflectPoint pt1 = new ReflectPoint(3,5);
Field fieldY = pt1.getClass().getField("y");//通过类字节码获取字段对象
//fieldY的值是多少？是5,错！fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值
System.out.println(fieldY.get(pt1));
Field fieldX = pt1.getClass().getDeclaredField("x");//获取私有化的字段
fieldX.setAccessible(true);//将私有话得字段设置为可访问的：称之为暴力反射
System.out.println(fieldX.get(pt1));

changeStringValue(pt1);
System.out.println(pt1);

Method methodCharAt = String.class.getMethod("charAt", int.class);//获取方法对象
System.out.println(methodCharAt.invoke(str1, 1));
System.out.println(methodCharAt.invoke(str1, new Object[]{2}));//方法调用自己，须传入对象参数和其他参数，静态方法对象为空（null）

//TestArguments.main(new String[]{"111","222","333"});
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
//mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}});//通过反射获取TestArgument类的main方法，然后调用， 对象参数为空
mainMethod.invoke(null, (Object)new String[]{"111","222","333"});//object 的作用是不让java 吧string数组拆成三个参数

//数组的反射

//java规定元素类型相同且维数相同的数组 拥有相同的字节码.

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"};
System.out.println(a1.getClass() == a2.getClass());//true
System.out.println(a1.getClass() == a4.getClass());//false
System.out.println(a1.getClass() == a3.getClass());//false
System.out.println(a1.getClass().getName());
System.out.println(a1.getClass().getSuperclass().getName())//数组类的父类是object类，补充：基本元素类的父类不是object
System.out.println(a4.getClass().getSuperclass().getName());

Object aObj1 = a1;
Object aObj2 = a4;
//Object[] aObj3 = a1;  报错，原因：基本元素类的父类不是object
Object[] aObj4 = a3;
Object[] aObj5 = a4;

System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));//基本数据类型的数组，转化为list集合中的一个元素
System.out.println(Arrays.asList(a4));////string数据类型的数组中的每一个元素，转化为list集合中的一个元素

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);
}

}


private static void changeStringValue(Object obj) throws Exception {
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//if(field.getType().equals(String.class)){//字段类的方法获取字段的类型
if(field.getType() == String.class){
String oldValue = (String)field.get(obj);//字段对象通过get方法获取obj对象中的字段
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}

}


}

class TestArguments{
public static void main(String[] args){
for(String arg : args){
System.out.println(arg);
}
}
}