Java反射机制

Java反射机制

---

前言：

• 反射库（reflect library）提供了一个非常丰富且精心设计的工具集，以便于编写能够动态操纵Java代码的程序。这项功能被大量的应用于JavaBean中，它是Java组件的体系结构。
• 使用反射，在设计或者是运行时添加新的类，能够快速的应用开发工具动态的查询新添加类的功能。
• Class类：可以通过Class这个专门的Java类访问类的信息。Class类实际上是泛型类，例如Class<?> perClazz = null;。在大多数情况下，可以忽略类型参数，而使用原始的Class类。

一.什么是反射？

能够分析类能力的程序称为反射。反射机制是在运行状态中：对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。

二、反射提供的功能？

• 在运行时判断任意一个对象所属的类。
• 在运行时构造任意一个类的对象。
• 在运行时判断任意一个类所具有的成员变量和方法。
• 在运行时调用任意一个对象的方法。
• 生成动态代理。

三、获取Class类对象的三种方法:

1. Class.forName(“全类名”);
2. XX.class;
3. 对象.getClass();

package com.uzz.test;

import com.uzz.entity.Person;

public class ReflectDemo01 {
	// 通过反射获取类
	public static void demo01() {
		/**
		 * 获取反射对象（反射入口） 1.Class.forName(全类名) 2.XX.class 3.对象.getClass()
		 */

		// 第一种：通过字符串拿到类
		Class<?> perClazz = null;
		try {
			perClazz = Class.forName("com.uzz.entity.Person");
			System.out.println(perClazz);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		// 第二种：类名.class
		Class<?> perClazz2 = Person.class;
		System.out.println(perClazz2);

		// 第三种：对象.getClass()
		Person person = new Person();
		System.out.println(person.getClass());

	}

	public static void main(String[] args) {
		demo01();
	}
}

四、通过反射获取所有的公共方法(1.本类 以及 父类 2.符合访问修饰符规律)以及获取当前类的所有方法

package com.uzz.test;

import java.lang.reflect.Method;

public class ReflectDemo02 {

	/**
	 * 获取方法
	 * 
	 */
	public static void demo02() {
		// Class入口
		Class<?> perClazz = null;
		try {
			perClazz = Class.forName("com.uzz.entity.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		// 获取所有的公共的方法(1.本类 以及 父类、接口中的所有方法 2.符合访问修饰符规律)
		Method[] methods = perClazz.getMethods();
		for (Method method : methods) {
			System.out.println(method);
		}

		System.out.println("=================获取所有方法=====================");
		// 获取当前类的所有方法(1.只能是当前类 2.忽略访问修饰符限制)
		Method[] declaredMethods = perClazz.getDeclaredMethods();
		for (Method method : declaredMethods) {
			System.out.println(method);
		}
	}
	public static void main(String[] args) {
		demo02();
	}
}

五、通过反射获取当前类的所有接口

package com.uzz.test;

public class ReflectDemo03 {

	// 获取所有的接口
	public static void demo03() {
		Class<?> perClazz = null;
		try {
			perClazz = Class.forName("com.uzz.entity.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		// 拿到当前类的接口
		Class<?>[] interfaces = perClazz.getInterfaces();
		// 遍历
		for (Class<?> inter : interfaces) {
			System.out.println(inter);
		}
	}

	public static void main(String[] args) {
		demo03();
	}
}

六、通过反射获取当前类的父类

package com.uzz.test;

public class ReflectDemo04 {

	// 通过反射获取当前类的父类
	public static void demo04() {
		Class<?> perClazz = null;
		try {
			perClazz = Class.forName("com.uzz.entity.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		Class<?> superclass = perClazz.getSuperclass();
		System.out.println(superclass);
	}

	public static void main(String[] args) {
		demo04();
	}
}

七、通过反射获取所有的构造方法

package com.uzz.test;

import java.lang.reflect.Constructor;

public class ReflectDemo05 {

	// 通过反射获取所有的构造方法
	public static void demo04() {
		Class<?> perClazz = null;
		try {
			perClazz = Class.forName("com.uzz.entity.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Constructor<?>[] constructors = perClazz.getConstructors();
		for (Constructor<?> constructor : constructors) {
			System.out.println(constructor);
		}
	}

	public static void main(String[] args) {
		demo04();
	}
}

八、通过反射获取所有的公共属性

package com.uzz.test;

import java.lang.reflect.Field;

public class ReflectDemo06 {

	// 通过反射获取所有的公共属性
	public static void demo06() {
		Class<?> perClazz = null;
		try {
			perClazz = Class.forName("com.uzz.entity.Person");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		Field[] fields = perClazz.getFields();
		for (Field field : fields) {
			System.out.println(field);
		}
	}

	public static void main(String[] args) {
		demo06();
	}
}