一、什么是反射
Java反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;并且能改变它的属性。而这也是Java被视为动态(或准动态,为啥要说是准动态,因为一般而言的动态语言定义是程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。)语言的一个关键性质。
二、反射的作用
Java Reflection功能非常强大,并且非常有用,比如:
- 获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等
- 获取任意对象的属性,并且能改变对象的属性
- 调用任意对象的方法
- 判断任意一个对象所属的类
- 实例化任意一个类的对象
- 通过反射我们可以实现动态装配,降低代码的耦合度,动态代理等。
- 动态代理实现
- 代理使用不当会造成大量资源消耗
三、反射类实现的三种方法
//1、通过对象调用 getClass() 方法来获取,通常应用在:比如你传过来一个 Object
// 类型的对象,而我不知道你具体是什么类,用这种方法
Person p1 = new Person();
Class c1 = p1.getClass();
//2、直接通过 类名.class 的方式得到,该方法最为安全可靠,程序性能更高
// 这说明任何一个类都有一个隐含的静态成员变量 class
Class c2 = Person.class;
//3、通过 Class 对象的 forName() 静态方法来获取,参数是类的路径,用的最多。
// 但可能抛出 ClassNotFoundException 异常
Class c3 = Class.forName("com.ys.reflex.Person");
四、与Java反射相关的类如下:
类名 | 用途 |
---|---|
Class类 | 代表类的实体,在运行的Java应用程序中表示类和接口 |
Field类 | 代表类的成员变量(成员变量也称为类的属性) |
Method类 | 代表类的方法 |
Constructor类 | 代表类的构造方法 |
Class类
Class代表类的实体,在运行的Java应用程序中表示类和接口。在这个类中提供了很多有用的方法,这里对他们简单的分类介绍。
- 获得类相关的方法
方法 | 用途 |
---|---|
asSubclass(Class<U> clazz) | 把传递的类的对象转换成代表其子类的对象 |
Cast | 把对象转换成代表类或是接口的对象 |
getClassLoader() | 获得类的加载器 |
getClasses() | 返回一个数组,数组中包含该类中所有公共类和接口类的对象 |
getDeclaredClasses() | 返回一个数组,数组中包含该类中所有类和接口类的对象 |
forName(String className) | 根据类名返回类的对象 |
getName() | 获得类的完整路径名字 |
newInstance() | 创建类的实例 |
getPackage() | 获得类的包 |
getSimpleName() | 获得类的名字 |
getSuperclass() | 获得当前类继承的父类的名字 |
getInterfaces() | 获得当前类实现的类或是接口 |
- 获得类中属性相关的方法
方法 | 用途 |
---|---|
getField(String name) | 获得某个公有的属性对象 |
getFields() | 获得所有公有的属性对象 |
getDeclaredField(String name) | 获得某个属性对象包括private |
getDeclaredFields() | 获得所有属性对象包括private |
- 获得类中注解相关的方法
方法 | 用途 |
---|---|
getAnnotation(Class<A> annotationClass) | 返回该类中与参数类型匹配的公有注解对象 |
getAnnotations() | 返回该类所有的公有注解对象 |
getDeclaredAnnotation(Class<A> annotationClass) | 返回该类中与参数类型匹配的所有注解对象包括private |
getDeclaredAnnotations() | 返回该类所有的注解对象包括private |
- 获得类中构造器相关的方法
方法 | 用途 |
---|---|
getConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的公有构造方法 |
getConstructors() | 获得该类的所有公有构造方法 |
getDeclaredConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的构造方法包括private |
getDeclaredConstructors() | 获得该类所有构造方法包括private |
- 获得类中方法相关的方法
方法 | 用途 |
---|---|
getMethod(String name, Class...<?> parameterTypes) | 获得该类某个公有的方法 |
getMethods() | 获得该类所有公有的方法 |
getDeclaredMethod(String name, Class...<?> parameterTypes) | 获得该类某个方法包括private |
getDeclaredMethods() | 获得该类所有方法包括private |
- 类中其他重要的方法
方法 | 用途 |
---|---|
isAnnotation() | 如果是注解类型则返回true |
isAnnotationPresent(Class<? extends Annotation> annotationClass) | 如果是指定类型注解类型则返回true |
isAnonymousClass() | 如果是匿名类则返回true |
isArray() | 如果是一个数组类则返回true |
isEnum() | 如果是枚举类则返回true |
isInstance(Object obj) | 如果obj是该类的实例则返回true |
isInterface() | 如果是接口类则返回true |
isLocalClass() | 如果是局部类则返回true |
isMemberClass() | 如果是内部类则返回true |
Field类
Field代表类的成员变量(成员变量也称为类的属性)。
方法 | 用途 |
---|---|
equals(Object obj) | 属性与obj相等则返回true |
get(Object obj) | 获得obj中对应的属性值 |
set(Object obj, Object value) | 设置obj中对应属性值 |
Method类
Method代表类的方法。
方法 | 用途 |
---|---|
invoke(Object obj, Object... args) | 传递object对象及参数调用该对象对应的方法 |
Constructor类
Constructor代表类的构造方法。
方法 | 用途 |
---|---|
newInstance(Object... initargs) | 根据传递的参数创建类的对象 |
五、代码演示
首先创建Example_01类,在该类中声明一个String成员变量和3个int成员变量,并提供三个构造方法。
public class Example_01 {
String s;
int i,i2,i3;
private Example_01(){
}
public Example_01(String s,int i){
this.s = s;
this.i = i;
}
public Example_01(String... strings)throws NumberFormatException{
if(0<strings.length){
i = Integer.valueOf(strings[0]);
}
if(1<strings.length){
i2 = Integer.valueOf(strings[1]);
}
if(2<strings.length){
i3 = Integer.valueOf(strings[2]);
}
}
public void print(){
System.out.println("s="+s);
System.out.println("i="+i);
System.out.println("i2="+i2);
System.out.println("i3="+i3);
}
}
便携测试类Main_01,在该类中通过反射访问Example_01中所有构造方法,并将构造方法是否允许带有可变参数类型、入口参数类型、可能抛出的异常输出。
import java.lang.reflect.Constructor;
public class Main_01 {
public static void main(String[] args) throws ClassNotFoundException {
//根据对象获取类反射
// Example_01 example = new Example_01("01", "02", "03");
// Class<? extends Example_01> exampleC = example.getClass();
//根据路径获取类反射
// Class<?> exampleC = Class.forName("Reflection.Example_01");
//根据类名获取反射
Class<Example_01> exampleC = Example_01.class;
//获取所有构造方法
Constructor<?>[] declaredConstructors = exampleC.getDeclaredConstructors();
for (int i = 0; i < declaredConstructors.length; i++) {//遍历构造方法
Constructor<?> constructor = declaredConstructors[i];
System.out.println("查看是否允许带有可变数量的参数"+constructor.isVarArgs());
System.out.println("构造方法入口参数类型依次为");
Class<?>[] parameterTypes = constructor.getParameterTypes();//获取所有参数类型
for (int j = 0; j < parameterTypes.length; j++) {
System.out.println(parameterTypes[j]);
}
System.out.println("构造方法可能抛出的异常");
Class<?>[] exceptionTypes = constructor.getExceptionTypes();
for (int j = 0; j < exceptionTypes.length; j++) {
System.out.println(exceptionTypes[j]);
}
Example_01 example2 = null;
while (example2==null){
try {
if(i==2)
example2 = (Example_01) constructor.newInstance();
else if(i==1)
example2 = (Example_01) constructor.newInstance("7",5);
else{
String[] strings = {"100", "200", "300"};
example2 = (Example_01) constructor.newInstance((Object) strings);
}
}catch (Exception e){
System.out.println("异常出现");
constructor.setAccessible(true);//允许创建实例
}
}
if(example2!=null){
example2.print();
}
System.out.println("-------------------------------------------");
}
}
}
输出结果为
查看是否允许带有可变数量的参数true
构造方法入口参数类型依次为
class [Ljava.lang.String;
构造方法可能抛出的异常
class java.lang.NumberFormatException
s=null
i=100
i2=200
i3=300
-------------------------------------------
查看是否允许带有可变数量的参数false
构造方法入口参数类型依次为
class java.lang.String
int
构造方法可能抛出的异常
s=7
i=5
i2=0
i3=0
-------------------------------------------
查看是否允许带有可变数量的参数false
构造方法入口参数类型依次为
构造方法可能抛出的异常
异常出现
s=null
i=0
i2=0
i3=0
-------------------------------------------