Java反射示例

Java反射示例

1. 创建数据类型ReflectPoint.java

package com.reflection;

import java.util.Date;

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 = "itany";

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getStr1() {
		return str1;
	}

	public void setStr1(String str1) {
		this.str1 = str1;
	}

	public String getStr2() {
		return str2;
	}

	public void setStr2(String str2) {
		this.str2 = str2;
	}

	public String getStr3() {
		return str3;
	}

	public void setStr3(String str3) {
		this.str3 = str3;
	}

	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}

	@Override
	public String toString() {
		return str1+"\t"+str2+"\t"+str3+"\t"+birthday;
	}
}

2. 创建测试类

package com.reflection;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectTest {
    
	public static void main(String[] args) throws Exception {
		//3种方法获得字节码文件
        String str1="abc";
        Class cls1=str1.getClass();//通过对象得到该对象在内存中的字节码文件
        Class cls2=String.class;//通过数据类型得到字节码文件
        /**
         * 如果内存中有该字符串指定的字节码，就直接用，如果没有就创建一个。
         */
        Class cls3=Class.forName("java.lang.String");//通过forName方法获得
        //注意：所有相同类型的对象都共享一个class对象
        //class称为类的类型
        System.out.println(cls1==cls2);
        System.out.println(cls1==cls3);
        //判断下面的数据类型是否是基本数据类型
        System.out.println(cls1.isPrimitive());
        System.out.println(int.class.isPrimitive());
        /**
         * Integer是基本数据类型int的包装类,里面有方法。
         * Integer 类在对象中包装了一个基本类型 int 的值。
         */
        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());
        System.out.println(void.class.isPrimitive());
        //把一个字符串转成整型的方法
        String s1="123";
        int s11=Integer.parseInt(s1);
        
        //反射开始
         //String str2=new String(new StringBuffer("abc")); //正常的构建一个字符串对象
          // String s3=new String("abc");
         //用反射去构建str2
        //通过String类型的字节码得到了一个构造方法，构造方法的区别是通过参数的类型进行甄别，
        //constructor1就是一个构造方法
        Constructor constructor1=String.class.getConstructor(String.class);
        //根据取得的构造方法创建实例，需要传入相应的参数
        String str2=(String)constructor1.newInstance(/*new StringBuffer("abc")*/"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);        
        //用反射来实现str2.charAt(2)方法
        Method methodcharAt=String.class.getMethod("charAt", int.class);//通过反射得到了charAt方法
        System.out.println(methodcharAt.invoke(str2, 2));//第一个参数是对象，第二个参数是具体的值
        
        //调用一下别的类的main方法
        //TestArguments.main(new String[]{"111","222","333"});//传统调用
        String startingClass=args[0];//约定在该类运行时传递的第一个参数是要调用类的名字。
        Method methodMain=Class.forName(startingClass).getMethod("main", String[].class);//通过字节码得到main方法
       // methodMain.invoke(null, new Object[]{new String[]{"111","222","333"}});//由于invoke要做解包动作，所有外面再打一个对象数组包
        methodMain.invoke(null, (Object)new String[]{"111","222","333"});//告诉编译器，把后面的数组当成一个对象看待，不需要解包。
        
        
        //数组反射
        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","d"};
        System.out.println(a1.getClass()==a2.getClass());
        //System.out.pritnln(a1.getClass()==a3.getClass());//唯数不一样
        //System.out.println(a1.getClass()==a4.getClass());//类型不一样
        System.out.println(a1.getClass().getName());//得到字节码的名字
        System.out.println(a3.getClass().getName());
        System.out.println(a4.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;
        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(a1);
        printObject(a4);
        printObject("xyz");
        
        //加载配置
        InputStream in = ReflectionTest.class.getClassLoader().getResourceAsStream("config.properties");
        Properties props = new Properties();
        props.load(in);
        in.close();
        String className = props.getProperty("className");
        Collection c=(Collection)Class.forName(className).newInstance();
		ReflectPoint pt1=new ReflectPoint(3,3);
		ReflectPoint pt2=new ReflectPoint(5,5);
		ReflectPoint pt3=new ReflectPoint(3,3);
		c.add(pt1);
		c.add(pt2);
		c.add(pt3);
		c.add(pt1);
		System.out.println(c.size());
	}

	private static void printObject(Object obj) {
		// TODO Auto-generated method stub
		Class clazz=obj.getClass();//得到传进来对象的字节码
		if(clazz.isArray()){//如果传进来的是数组，需要使用Array类
			//得到数组的长度
			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 {
		// TODO Auto-generated method stub
		Field[] fields=obj.getClass().getFields();//得到该对象字节码上的所有方法
		for(Field field:fields){//遍历字段数组
			//if(field.getType().equals(String.class)){//判断字段的类型是否是String
			if(field.getType()==String.class){//字节码在内存中只有一份，所有用==去比较	
				String oldValue=(String)field.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);
		}		        
	}	
}