Java反射示例

 

package com.reflection;

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

/**
 * 反射调用一般分为3个步骤：
 * 
 * 1.得到要调用类的class 
 * 2.得到要调用的类中的方法(Method) 
 * 3.方法调用(invoke)
 * 
 * 一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。
 * 从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。
 */
public class MainRefelection {

	public static void main(String args[]) {

		User user = new User();
		try {
			new MainRefelection().showRefelection(user);
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	@SuppressWarnings("rawtypes")
	public void showRefelection(Object object) throws Exception {
		//-------------生成class--------------
//		Class cls = object.getClass();     
		Class cls =Class.forName("com.reflection.User");  //二者都可以
		System.out.println("该对象的类型是:" + cls.toString()); // com.reflection.User

		//----------调用方法-----------------
		Method m = cls.getDeclaredMethod("hello", new Class[] { String.class,int.class }); // 调用方法 参数类型保持一致
		//----------方法调用----------------
		m.invoke(cls, "spark", 20);   //name:spark,age:20
//		m.invoke(cls.newInstance(), "spark",20); // 静态方法调用不需要newInstance()
		
		/**
		 * 向成员变量赋值
		 */
		//1.直接操作成员变量，需要设置访问权限
		Object user = cls.newInstance();
		Field field = cls.getDeclaredField("age");
		field.setAccessible(true); // 向private成员变量赋值时 不加这句话会抛异常 Class
									// com.reflection.MainRefelection can not
									// access a member of class
									// com.reflection.User with modifiers
									// "private"
		field.set(user, 21);
		System.out.println("age：" + field.get(user));  //age：21

		//2.操作成员变量对应的方法，不需要设置访问权限
		Method setMethod = cls.getDeclaredMethod("setAge", int.class); //不是Integer.class
		setMethod.invoke(user, 23); // 调用set方法
		Method getMethod = cls.getDeclaredMethod("getAge");
		System.out.println("age：" + getMethod.invoke(user));  //age：23			调用get方法 
		
		//-----------获得所有的方法--------------
		Method[] methods=cls.getDeclaredMethods();
		System.out.println("方法有：");
		for(int i=0;i<methods.length;i++){
			System.out.print(methods[i].getName()+" ");
		}
		
		//--------获得所有的变量
		Field[] fields=cls.getDeclaredFields();  //cls.getFields() 不对
		System.out.println("变量有：");
		for(int j=0;j<fields.length;j++){
			System.out.print(fields[j].getName()+" ");
		}
		
		// -----生成对象实体------
		// 一种是针对无参数的构造方法，直接cls.newInstance()
		// 另一种是针对有参数的构造方法，比较麻烦。需要先调用cls.getConstructor()获得一个专属的Costructor对象
		// 然后调用Constructor类中的newInstance()

		// 只有两个类拥有newInstance（）方法，分别是Class类和Constructor类
		// Class类中的newInstance（）方法是不带参数的，而Constructro类中的newInstance（）方法是带参数的
		Class clsb = Class.forName("com.reflection.User");
		Class[] prams = new Class[] { int.class, int.class }; // 作为Constructor的参数类型
		Constructor cons = clsb.getConstructor(prams);
		Object[] obj = new Object[] { 11, 22 };
		Object objb = cons.newInstance(obj);
		System.out.println(objb); // com.reflection.User@d9f9c3
	}
	/**
	 * JAVA反射机制主要提供了以下功能： 
	 * 注：前提都是在运行时，而不是在编译时！ 
	 * 1.在运行时判断任意一个对象所属的类
	 * 2.在运行时构造任意一个类的对象 
	 * 3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
	 * 4.在运行时调用任意一个对象的方法
	 */
}

 

public class User {

	private String name;
	private int age;
	private int id;

	public User(){
		
	}
	public User(int id,int age){
		this.id=id;
		this.age=age;
	}
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public static void hello(String name, int age) {  //参数类型必须保持一致 是Integer都是Integer
		System.out.println("name:" + name + ",age:" + age);
	}
}