JAVA基础--反射

 

创建Class对象的方式：

//创建Class对象的方式一。   全类名
		Class clazz =Class.forName("com.fs.Animal");
		//创建Class对象的方式二：
		Class clazz2 =Animal.class;
		//创建Class对象的方式三：
//		Animal animal =new Animal();
//		Class clazz3 =animal.getClass();

反射获取方法：

	public static void main(String[] args) throws Exception {
		//通过反射获取对象
		Class clazz = Class.forName("day_2.Person");
		//获取类中的所有方法
		Method[] methods = clazz.getDeclaredMethods();
		
		for(int i=0;i<methods.length;i++){
			//设置权限，让私有也可以访问。
			methods[i].setAccessible(true);
			//获取方法中的参数
			Class[] pa = methods[i].getParameterTypes();
			//获取参数的权限修饰符
			int N = methods[i].getModifiers();
			String s = Modifier.toString(N);
			//打印参数的权限修饰符
			System.out.println(s);
			//打印方法的名字
			System.out.println(methods[i].getName());
			
			for(int j=0;j<pa.length;j++){
				//参数的名字
				String Name = pa[j].getName();
				//获取参数的权限修饰符
				int N1 = pa[j].getModifiers();
				String Namemod = Modifier.toString(N1);
				
				System.out.println(Name + " " + Namemod);
			}
			//通过反射的方式去调用类中的方法。。。
			methods[i].invoke(clazz.newInstance(),12);			
		}		
	}

反射获取值：

	public static void main(String[] args) throws Exception {		
		Class clazz = Class.forName("day_2.Person");		
		//变量值，装入field数组里面
		Field[] fies = clazz.getDeclaredFields();
		
		for(int i=0;i<fies.length;i++){
			//释放安全权限，让私有成员变得可以访问。
			fies[i].setAccessible(true);
			//获取当前变量的名字
			String numFies = fies[i].getName();
			//获取变量的修饰符，并转换
			int ModFies = fies[i].getModifiers();
			String Namemod = Modifier.toString(ModFies);
			//打印变量名和修饰符
			System.out.println(numFies + "  "+Namemod);
			//或取变量对应的值
			System.out.println(fies[i].get(clazz.newInstance()));
		}
	}

通过反射获取构造器：

	public static void main(String[] args) throws Exception {		
		//通过反射的方式，获取类
		Class clazz = Class.forName("day_2.Person");
		//通过反射获取所有的构造器
		Constructor[] cons =  clazz.getDeclaredConstructors();
		
		for(int i=0;i<cons.length;i++){
			//获取构造器里面的所有参数类型。
			Class[] pa = cons[i].getParameterTypes();
			//查看构造器的权限修饰符。
			int Namecon = cons[i].getModifiers();
			String NameMod = Modifier.toString(Namecon);
			System.out.println(NameMod);
			
			for(int j=0;j<pa.length;j++){
				//打印参数类型的名字。
				System.out.print(pa[j].getName() +" ");
				//获取参数类型的的修饰符并转换为String类型
				int NamePa = pa[j].getModifiers();
				String Namemod = Modifier.toString(NamePa);
				System.out.print(Namemod+" ");
			}
			System.out.println();
		}		
	}

反射应用的一个实例：

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test {
	public static void main(String[] args) throws Exception {
		//对象序列化
//		oos();
		//对象反序列化
		Person p = ois();		
		//对象序列化和反序列化
//		Person p = JavaBSerializable();
		// 构造器
		 consMethod(p);
		// 变量
//		 FiesMethod(p);
		// 方法
//		 MMthod(p);
	}

	public static void MMthod(Person p) {
		Class clazz = p.getClass();//反射获取对象
		//将获取的方法存入method数组中。
		Method[] method = clazz.getDeclaredMethods();

		for (int i = 0; i < method.length; i++) {
			//获取方法中的形参，放入Class数组中。
			Class[] para = method[i].getParameterTypes();
			//method[i].getName() 获取方法的名称
			System.out.print("方法名：" + method[i].getName() + " 参数有：");

			for (int j = 0; j < para.length; j++) {
				//para[j].getName()获取参数值的名称。
				System.out.print(para[j].getName() + "  ");
			}
			//获取权限修饰符。
			int mod = method[i].getModifiers();
			String NameMod = Modifier.toString(mod);

			System.out.println("权限修饰符为：" + NameMod);
		}

	}

	public static void FiesMethod(Person p) throws Exception {
		Class clazz = p.getClass();//反射获取对象
		//将获取的成员变量放入Field数组中。
		Field[] fies = clazz.getDeclaredFields();

		for (int i = 0; i < fies.length; i++) {
			//获取成员变量的权限修饰符
			int mod = fies[i].getModifiers();
			String NameMod = Modifier.toString(mod);
			//设置安全权限，让类中的私有成员也可以获取。
			fies[i].setAccessible(true);
			//获取成员变量的初始值
			Object o = fies[i].get(clazz.newInstance());
			//fies[i].getName() 获取变量名称
			System.out.println(fies[i].getName() + " 变量的权限修饰符：" + NameMod + " 对

应的值为：" + o);

		}
	}

	public static void consMethod(Person p) {
		//建立反射对象
		Class clazz = p.getClass();
		//获取对象的构造器，存入构造器数组中
		Constructor[] cons = clazz.getDeclaredConstructors();

		for (int i = 0; i < cons.length; i++) {
			//得到构造器中的参数，将参数存入class数组中。
			Class[] para = cons[i].getParameterTypes();
			//取出构造器的权限修饰符，再将权限修饰符转为字符串类型输出。
			int mod = cons[i].getModifiers();
			String NameMod = Modifier.toString(mod);
			System.out.print("构造器的权限修饰符：" + NameMod + "   ");

			for (int j = 0; j < para.length; j++) {
				//通过getName的方式，得到参数的名称
				System.out.print("形式参数名：" + para[j].getName() + "  ");
			}
			System.out.println();
		}
	}

	// 对象序列化和反序列化
	public static Person JavaBSerializable() throws Exception {
		FileOutputStream fileout = new FileOutputStream("F:\\Person.txt");
		ObjectOutputStream oOut = new ObjectOutputStream(fileout);

		oOut.writeObject(new Person());

		FileInputStream fileIn = new FileInputStream("F:\\Person.txt");
		ObjectInputStream in = new ObjectInputStream(fileIn);
		Person p = (Person) in.readObject();

		return p;
	}

	//对象序列化
	public static void oos() throws IOException{
		FileOutputStream fileout = new FileOutputStream("F:\\Person.txt");
		ObjectOutputStream oOut = new ObjectOutputStream(fileout);

		oOut.writeObject(new Person());
	}
	
	//对象反序列化
	public static Person ois() throws Exception{
		FileInputStream fileIn = new FileInputStream("F:\\Person.txt");
		ObjectInputStream in = new ObjectInputStream(fileIn);
		Person p = (Person) in.readObject();
		return p;
	}
}