手写反射方法

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.Test;

public class ReflectDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
	}
	@Test
	public void test() throws Exception{
		User u = new User();
		//通过Class的forName方法，注意使用目标类的全路径（文件所在包以下路径）
		Class clazz = Class.forName("reflect.User");
		
		//反射类的构造方法
		//通过无参构造器得到该类的对象
		//User user = (User)clazz.newInstance();
		Constructor c = clazz.getConstructor(null);
		User user = (User)c.newInstance(null);
		//通过带参构造器获得该类对象
		Constructor c1 = clazz.getConstructor(String.class);
		User user1 = (User)c1.newInstance("nick");
		
		//获得方法名为login但是没有参数的method对象
		Method method = clazz.getMethod("login",null);
		//第一个参数为哪个user对象，第二个参数就是这个方法的参数
		method.invoke(u,null);
		//获取有参数返回值的方法eat
		Method method1 = clazz.getMethod("eat",String.class);
		String args = (String)method1.invoke(u,"超人");
		//获取带有参数无返回值的静态方法sleep
		Method method2 = clazz.getMethod("sleep",String.class);
		method2.invoke(null, "蝙蝠侠");
		
		/**************反射类的字段*******************/
		//注意需要用getDeclareField方法，getField只能获取到public的字段
		Field f = clazz.getDeclaredField("name");
		Class type = f.getType();
		System.out.println(type);
		f.setAccessible(true);
		f.set(u, "wang");
		String name = (String)f.get(u);
		System.out.println(name);
	}
}
class User{
	private String name;
	private String password;
	
	public User() {
		System.out.println("无参构造方法");
	}
	public User(String name) {
		System.out.println("带参数的构造方法"+name);
	}
	//无参无返回值的方法login
	public void login() {
		System.out.println("用户登陆");
	}
	//带参数有返回值的方法eat
	public String eat(String name) {
		System.out.println("用户"+name+"登陆了");
		return "eat";
	}
	//带有参数无返回值的静态方法
	public static void sleep(String name) {
		System.out.println(name+"去睡觉了");
	}
}

public class Stu {
	private int age;
	private String name;
	public String addr;
	
	public Stu(int age, String name, String addr) {
		this.age = age;
		this.name = name;
		this.addr = addr;
	}
 
	public Stu(int age, String name) {
		this.age = age;
		this.name = name;
	}
 
	private Stu(int age) {
		this.age = age;
	}
 
	public Stu() {
	}
	
	private int method1(){
		return 0;
	}
	private int method2(int age){
		return age;
	}
	public void print(String name,int age){
		System.out.println("hello："+name+"年龄："+age);
	}
	
	public String print2(String name,int age){
		System.out.println("hello："+name+"年龄："+age);
		return null;
	}
 
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + ", addr=" + addr
				+ "]";
	}	
}
public class TestStu {
	@Test
	public void getMsthods() {
		Stu student = new Stu();
		Class studentClass = student.getClass();
		// getDeclaredMethods得到本类中所有方法
		Method[] studentMethods = studentClass.getMethods();
		Method[] studentMethods2 = studentClass.getDeclaredMethods();
		System.out.println("方法个数："+studentMethods.length);
		System.out.println("方法个数："+studentMethods2.length);
		for (Method method : studentMethods) {
			//得到返回类型
			System.out.print("方法名称和参数："+method.getName()+"(");
			//取得某个方法对应的参数类型数组
			Class[] paramsType =  method.getParameterTypes();
			for (Class paramType : paramsType) {
				System.out.print(paramType.getTypeName()+" ");
			}
			System.out.print(")");
			Class returnType = method.getReturnType();
			System.out.println("返回类型："+returnType.getTypeName());
		}
		for (Method method : studentMethods2) {
			//得到返回类型
			System.out.print("private类型的方法名称和参数："+method.getName()+"(");
			//取得某个方法对应的参数类型数组
			Class[] paramsType =  method.getParameterTypes();
			for (Class paramType : paramsType) {
				System.out.print(paramType.getTypeName()+" ");
			}
			System.out.print(")");
			Class returnType = method.getReturnType();
			System.out.println("返回类型："+returnType.getTypeName());
		}
	}
	@Test
	public void getConstructors() {
		Constructor[] cs2 = Stu.class.getConstructors();
		Constructor[] cs22 = Stu.class.getDeclaredConstructors();
		System.out.println("构造方法个数："+cs2.length);
		System.out.println("构造方法个数："+cs22.length);
		for (Constructor constructor : cs2) {
			String printstr = "(";
			//获取某个构造方法中的参数数组
			Class[] paramsType = constructor.getParameterTypes();
			for (Class parameter : paramsType) {
				printstr = printstr+parameter.getTypeName()+",";
			}
			if(printstr.length()>2){
			printstr = printstr.substring(0, printstr.length()-1);
			}
			System.out.println(printstr+")");
		}
		for (Constructor constructor : cs22) {
			String printstr = "(";
			//获取某个构造方法中的参数数组
			Class[] paramsType = constructor.getParameterTypes();
			for (Class parameter : paramsType) {
				printstr = printstr+parameter.getTypeName()+",";
			}
			if(printstr.length()>2){
			printstr = printstr.substring(0, printstr.length()-1);
			}
			System.out.println(printstr+")");
		}
	}
	@Test
	public void getfields() {
		//getFields()方法获取的是所有的public的信息
				//getDeclaredFields()获取的是该类自己声明的成员变量信息
				Class stuClass = Stu.class;
				Field[] fs = stuClass.getDeclaredFields();
				Field[] fs2 = stuClass.getFields();//仅能获得public类型的变量
				for(Field field : fs){
					//得到类的变量的类型的类类型
					Class fieldType = field.getType();
				String fieldTypeStr = fieldType.getName();
				//得到成员变量的名称
				String fieldname = field.getName();
				System.out.println("类型："+fieldTypeStr+"名称："+fieldname);
				}
				for(Field field : fs2){
					//得到类的变量的类型的类类型
					Class fieldType = field.getType();
				String fieldTypeStr = fieldType.getName();
				//得到成员变量的名称
				String fieldname = field.getName();
				System.out.println("类型："+fieldTypeStr+"名称："+fieldname);
				}
	}
}