Java 反射

package com.vgbh.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;


import com.vgbh.ReflectDemo;

/*
 * 1.所有类的对象都是Class
 * 2.
 */

public class ReflectTest {
	
	public static void main(String[] args) {
		/*
		 * 1.获取对象完整的包名和类名
		 */
		System.out.println("1:");
		ReflectDemo rt = new ReflectDemo();
		System.out.println("完整的包名和类名：" + rt.getClass().getName());
		System.out.println("==========================");
		
		/*
		 * 2.实例化Class类对象，共有三种方法
		 */
		System.out.println("2:");
		Class<?> c1 = null;
		Class<? extends ReflectDemo> c2 = null;
		Class<ReflectDemo> c3 = null;
		try {
			c1 = Class.forName("com.vgbh.ReflectDemo"); //经常使用这种
			c2 = new ReflectDemo().getClass();
			c3 = ReflectDemo.class;
			//获取Class类对象，有三种方法，但也有许多不同
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		System.out.println("ClassName : " + c1.getName());
		System.out.println("ClassName : " + c2.getName());
		System.out.println("ClassName : " + c3.getName());
		System.out.println("============================");
		
		/*
		 * 3.获取类的属性方法及其参数信息
		 */
		System.out.println("3:");
		try {
			Class c4 = Class.forName("com.vgbh.ReflectDemo"); //获取一个类的类类型
			Method[] m1 = c4.getDeclaredMethods(); //通过类类型获取他的所有方法     getDeclaredMethod(String name)  获取特定名称的属性方法
 			for (int i = 0; i < m1.length; i++) {
				System.out.print(m1[i] + " "); //输出这个类的方法
				Class<?> returnType = m1[i].getReturnType(); //返回值类型
				Class<?>[] paramsType = m1[i].getParameterTypes(); //参数类型
				System.out.print(returnType.getName() + "  "); //获取返回值的类型
				for (int j = 0; j < paramsType.length; j++) {
					System.out.print(paramsType[j].getName() + "  "); //获取当前方法参数的类型
				}
				System.out.println();
			}
			System.out.println("=====================");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		/*
		 * 获取类的构造函数
		 */
		System.out.println("4:");
		Class<?> c5 = null;
		try {
			c5 = Class.forName("com.vgbh.ReflectDemo");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Constructor<?> con[] = c5.getConstructors(); //获取类的全部构造方法
		for (int i = 0; i < con.length; i++) {
			System.out.print(con[i].getName() + "  ");
			Class<?> paramType[] = con[i].getParameterTypes(); //获取构造方法的参数属性
			for (int j = 0; j < paramType.length; j++) {
				System.out.print(paramType[j].getName() + "  ");
			}
			System.out.println();
 		}
		System.out.println("=======================");
 		
		/*
		 * 获取该类的属性参数
		 */
		System.out.println("5:");
		Class<?> c6 = null;
		try {
			c6 = Class.forName("com.vgbh.ReflectDemo");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Field[] f = c6.getDeclaredFields(); //获取本类的全部属性   getDeclaredField(String name)  获取特定的属性参数
		for (int i = 0; i < f.length; i++) {
			//System.out.print(f[i].getName() + "  ");
			int p = f[i].getModifiers(); //获取本类属性的权限(public/protected/private)
			String priv = Modifier.toString(p);
			Class<?> type = f[i].getType();
			System.out.println(priv + " " + type.getName() + " " + f[i].getName());
		}
		System.out.println("=======================");
		
		/*
		 * 通过反射机制，调用类的方法
		 */
		System.out.println("6:");
		Class<?> c7 = null;
		try {
			c7 = Class.forName("com.vgbh.ReflectDemo"); //获取类的类类型
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		try {
			Method method = c7.getMethod("print", int.class, int.class); //获取类中方法和要赋值的参数
			method.invoke(c7.newInstance(), 4, 56); //通过反射机制调用该方法，并传入参数
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("====================");
		
		/*
		 * 实例：在泛型为Integer的ArrayList中加入一个String对象
		 */
		System.out.println("7:");
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(new Integer(132));
		try {
			Method method = list.getClass().getMethod("add", Object.class);//通过反射机制，绕过编译阶段，直接在运行阶段插入数据。
			method.invoke(list, "hello");
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(list);
		
		/*
		 * 实例：将反射机制应用于工厂模式
		 * 
		 * 测试详见ReflectDemo
		 */	
	}
}

package com.vgbh;

public class ReflectDemo {
	
	private int x = 0;
	
	public ReflectDemo () {//默认构造无参
		
	}
	
	public ReflectDemo (int x) {//自己定义的构造方法
		this.x = x;
	}
	
	public void print(int x, int y) {
		System.out.println(x+y);
	}
	
	public void print(String x, String y) {
		System.out.println(x.toUpperCase() + y.toLowerCase());
	}
	
	public static void main(String[] args) {
		Fruit f = Factory.getInstance("com.vgbh.Apple");
		if (f != null) {
			f.eat();
		}
	}
	
	
}

/**
 * 反射机制应用于工厂模式
 */
interface Fruit {
	
	public abstract void eat() ;
	
}

class Apple implements Fruit {
	@Override
	public void eat() {
		System.out.println("eating Apple .....");
	}
}
class Orange implements Fruit {
	@Override
	public void eat() {
		System.out.println("eating Orange ....");
	}
}


class Factory {
	
	public static Fruit getInstance (String ClassName) {
		Fruit f = null;
		try {
			f = (Fruit) Class.forName(ClassName).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return f;
	}
	
	public static void main(String[] args) {
		Fruit o = Factory.getInstance("com.vgbh.Orange");
		o.eat();
	}
}