Java反射机制(一)

前言：

反射库（reflect library）提供了一个非常丰富且精心设计的工具集，以便于编写能够动态操纵Java代码的程序。这项功能被大量的应用于JavaBean中，它是Java组件的体系结构。
使用反射，在设计或者是运行时添加新的类，能够快速的应用开发工具动态的查询新添加类的功能。
Class类：可以通过Class这个专门的Java类访问类的信息。Class类实际上是泛型类，例如Class perClazz = null;。在大多数情况下，可以忽略类型参数，而使用原始的Class类。
一.什么是反射？
能够分析类能力的程序称为反射。反射机制是在运行状态中：对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。

二、反射提供的功能？
在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
生成动态代理。
三、获取Class类对象的三种方法:
Class.forName(“全类名”);
XX.class;
对象.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();
}
}