16.1 反射:
1.class类
2.获取构造方法
3.获取成员属性
4.获取成员方法
注解
1.内置注解
2.反射注解
创建Class对象的三种方式
1.使用getClass()方法
object str = new object();
class c = str.getClass()
Demo1 d1 = new Demo1();
Class c1 = d1.getClass();
2.使用.class属性
class c = object.class
Class c2 = Demo1.class;
3.使用class类的forname方法
class c = class.forname("全路径")
Class c3 = Class.forName("com.mr.Demo1");
创建class,包会自动创建
众所周知,所有Java 类均继承了 Object 类,在Object 类中定义了一个 getClassO方法,该方法返
回一个类型为Class 的对象。例如下面的代码:
-
JTextField textField = new JTextFieldO); //创建 JTextField 对象
-
Class textFieldC = textField.getClass(); //获取Class对象
利用Class 类的对象 textFieldC,可以访问用来返回该对象的textField对象的描述信息。可以访问
的主要描述信息如表 16.1所示。
16.1.1 访问构造方法
在通过下列一组方法访问构造方法时,将返回Constructor 类型的对象或数组。每个Constuctor 对象代表一个构造方法,利用Constructor 对象可以操纵相应的构造方法:
- getConstructors()
- getConstructor(Class<?>...parameterTypes)
- getDeclaredConstructors()
- getDeclaredConstructor(Class<?>..parameterTypes)
如果是访问指定的构造方法,需要根据该构造方法的入口参数的类型来访问。例如,访问一个入口参数类型依次为String型和 int型的构造方法,通过下面两种方式均可实现:
objeciClass.getDeclaredConstructor(String.class, int.class);
objectClass.getDeclaredConstructor(new Classil { String.class, int.class });
Constructor 类中提供的常用方法如表16.2所示。
Modifier 类中的常用解析方法如下:
例如,判断对象 constructor 所代表的构造方法是否被 private 修饰,以及以字符串形式获得该构造
方法的所有修饰符的典型代码如下:
-
int modifiers = constructor.getModifiers();
-
boolean isEmbellishByPrivate = Modifier.isPrivate(modifiers);
-
String embelishment = Modifier.toString(modifiers);
例题16.1
-
package com.mr;
-
public class Demo1 {
-
String s;
-
int i, i2, i3;
-
private Demo1() {
-
}
-
protected Demo1(String s, int i) {
-
this.s = s;
-
this.i = i;
-
}
-
public Demo1(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() {
-
// TODO Auto-generated method stub
-
System.out.println("s=" + s);
-
System.out.println("i=" + i);
-
System.out.println("i2=" + i2);
-
System.out.println("i3=" + i3);
-
}
-
}
-
//例题16.1
-
import java.lang.reflect.Constructor;
-
import com.mr.Demo1;
-
public class ConstructorDemo1 {
-
public static void main(String[] args) {
-
Demo1 d1 = new Demo1("10", "20", "30");
-
Class<? extends Demo1> demoClass = d1.getClass();
-
// 获得所有构造方法
-
Constructor[] declaredConstructors = demoClass.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]);
-
}
-
Demo1 d2 = null;
-
try { // 如果该成员变量的访问权限为private,则抛出异常,即不允许访问
-
if (i == 2) // 通过执行默认没有参数的构造方法创建对象
-
d2 = (Demo1) constructor.newInstance();
-
else if (i == 1)
-
// 通过执行具有两个参数的构造方法创建对象
-
d2 = (Demo1) constructor.newInstance("7", 5);
-
else { // 通过执行具有可变数量参数的构造方法创建对象
-
Object[] parameters = new Object[] { new String[] { "100", "200", "300" } };
-
d2 = (Demo1) constructor.newInstance(parameters);
-
}
-
} catch (Exception e) {
-
System.out.println("在创建对象时抛出异常,下面执行setAccessible()方法");
-
constructor.setAccessible(true); // 设置为允许访问
-
}
-
if (d2 != null) {
-
d2.print();
-
System.out.println();
-
}
-
}
-
}
-
}
-
//例题16.1
运行结果如下:
16.1.2 访问成员变量
在通过下列一组方法访问成员变量时,将返回Field 类型的对象或数组。每个Field对象代表一个成员变量,利用Ficld 对象可以操纵相应的成员变量:
- getFields()
- getField(String name)
- getDeclaredFields()
- getDeclaredField(String name)
如果是访问指定的成员变量,可以通过该成员变量的名称来访问。例如,访问一个名称为birthday的成员变量,访问方法如下:
object. getDeclaredField("birthday");
Field 类中提供的常用方法如表16.4所示。
例题16.2
-
package com.mr;
-
public class Demo2 {
-
int i;
-
public float f;
-
protected boolean b;
-
private String s;
-
}
-
//例题16.2
-
import java.lang.reflect.Field;
-
import com.mr.Demo2;
-
public class FieldDemo {
-
public static void main(String[] args) {
-
Demo2 example = new Demo2();
-
Class exampleC = example.getClass();
-
// 获得所有成员变量
-
Field[] declaredFields = exampleC.getDeclaredFields();
-
for (int i = 0; i < declaredFields.length; i++) { // 遍历成员变量
-
Field field = declaredFields[i];
-
System.out.println("名称为:" + field.getName()); // 获得成员变量名称
-
Class fieldType = field.getType(); // 获得成员变量类型
-
System.out.println("类型为:" + fieldType);
-
boolean isTurn = true;
-
while (isTurn) {
-
// 如果该成员变量的访问权限为private,则抛出异常,即不允许访问
-
try {
-
isTurn = false;
-
// 获得成员变量值
-
System.out.println("修改前的值为:" + field.get(example));
-
if (fieldType.equals(int.class)) { // 判断成员变量的类型是否为int型
-
System.out.println("利用方法setInt()修改成员变量的值");
-
field.setInt(example, 168); // 为int型成员变量赋值
-
} else if (fieldType.equals(float.class)) { // 判断成员变量的类型是否为float型
-
System.out.println("利用方法setFloat()修改成员变量的值");
-
field.setFloat(example, 99.9F); // 为float型成员变量赋值
-
// 判断成员变量的类型是否为boolean型
-
} else if (fieldType.equals(boolean.class)) {
-
System.out.println("利用方法setBoolean()修改成员变量的值");
-
field.setBoolean(example, true); // 为boolean型成员变量赋值
-
} else {
-
System.out.println("利用方法set()修改成员变量的值");
-
field.set(example, "MWQ"); // 可以为各种类型的成员变量赋值
-
}
-
// 获得成员变量值
-
System.out.println("修改后的值为:" + field.get(example));
-
} catch (Exception e) {
-
System.out.println("在设置成员变量值时抛出异常," + "下面执行setAccessible()方法!");
-
field.setAccessible(true); // 设置为允许访问
-
isTurn = true;
-
}
-
}
-
System.out.println();
-
}
-
}
-
}
-
//例题16.2
运行结果如下:
16.1.3 访问成员方法
在通过下列一组方法访问成员方法时,将返回Method类型的对象或数组。每个Method对象代表-个方法,利用Method 对象可以操纵相应的方法:
- getMethods()
- getMethod(String name, Class<?>...parameterTypes)
- getDeclaredMethods()
- getDeclaredMethod(String name, Class<?>...parameterTypes)
如果是访问指定的方法,需要根据该方法的名称和入口参数的类型来访问。例如,访问一个名称为print、入口参数类型依次为String型和int型的方法,通过下面两种方式均可实现:
objectClass.getDeclaredMethod("print",String.class, int.class);
objectClass.getDeclaredMethod("print", new Class[] {String.class, int.class });
Method 类中提供的常用方法如表16.5所示。
例题16.3
-
package com.mr;
-
public class Demo3 {
-
static void staticMethod() {
-
System.out.println("执行staticMethod()方法");
-
}
-
public int publicMethod(int i) {
-
System.out.println("执行publicMethod()方法");
-
return i * 100;
-
}
-
protected int protectedMethod(String s, int i) throws NumberFormatException {
-
System.out.println("执行protectedMethod()方法");
-
return Integer.valueOf(s) + i;
-
}
-
private String privateMethod(String... strings) {
-
System.out.println("执行privateMethod()方法");
-
StringBuffer stringBuffer = new StringBuffer();
-
for (int i = 0; i < strings.length; i++) {
-
stringBuffer.append(strings[i]);
-
}
-
return stringBuffer.toString();
-
}
-
}
-
//例题16.3
-
import java.lang.reflect.*;
-
import com.mr.Demo3;
-
public class MethondDemo {
-
public static void main(String[] args) {
-
Demo3 demo = new Demo3();
-
Class demoClass = demo.getClass();
-
// 获得所有方法
-
Method[] declaredMethods = demoClass.getDeclaredMethods();
-
for (int i = 0; i < declaredMethods.length; i++) {
-
Method method = declaredMethods[i]; // 遍历方法
-
System.out.println("名称为:" + method.getName()); // 获得方法名称
-
System.out.println("是否允许带有可变数量的参数:" + method.isVarArgs());
-
System.out.println("入口参数类型依次为:");
-
// 获得所有参数类型
-
Class[] parameterTypes = method.getParameterTypes();
-
for (int j = 0; j < parameterTypes.length; j++) {
-
System.out.println(" " + parameterTypes[j]);
-
}
-
// 获得方法返回值类型
-
System.out.println("返回值类型为:" + method.getReturnType());
-
System.out.println("可能抛出的异常类型有:");
-
// 获得方法可能抛出的所有异常类型
-
Class[] exceptionTypes = method.getExceptionTypes();
-
for (int j = 0; j < exceptionTypes.length; j++) {
-
System.out.println(" " + exceptionTypes[j]);
-
}
-
boolean isTurn = true;
-
while (isTurn) {
-
try {// 如果该方法的访问权限为private,则抛出异常,即不允许访问
-
isTurn = false;
-
if ("staticMethod".equals(method.getName()))
-
method.invoke(demo); // 执行没有入口参数的方法
-
else if ("publicMethod".equals(method.getName()))
-
System.out.println("返回值为:" + method.invoke(demo, 168)); // 执行方法
-
else if ("protectedMethod".equals(method.getName()))
-
System.out.println("返回值为:" + method.invoke(demo, "7", 5)); // 执行方法
-
else if ("privateMethod".equals(method.getName())) {
-
Object[] parameters = new Object[] { new String[] { "M", "W", "Q" } }; // 定义二维数组
-
System.out.println("返回值为:" + method.invoke(demo, parameters));
-
}
-
} catch (Exception e) {
-
System.out.println("在执行方法时抛出异常," + "下面执行setAccessible()方法!");
-
method.setAccessible(true); // 设置为允许访问
-
isTurn = true;
-
}
-
}
-
System.out.println();
-
}
-
}
-
}
-
//例题16.3
运行结果如下:
16.2 Annotation注解功能
该功能可用于类、构造方法、成员变量、成员方法、参数等的声明中。该功能并不会影响程序的运行,但是会对编译器警告等辅助工具产生影响
16.2.1 定义Annotation类型
内置注解:
- @Override :限定重写父类方法作用范围成员方法
- @SuppressWarnings :抑制编译器警告作用范围类、成员属性、成员方法
- @Deprecated :标示已过时作用范围类、成员属性、成员方法
在定义Annotation 类型时,也需要用到用来定义接口的interface 关键字,但需要在interface关键字前加一个“@”符号,即定义Annotation 类型的关键字为@interface,这个关键字的隐含意思是继承了 java.lang.annotation.Annotation 接口。例如,下面的代码就定义了一个 Annotation 类型:
public @interface NoMemberAnnotation{
}
上面定义的Annotation类型@NoMemberAnnotation未包含任何成员,这样的Annotation类型被称为marker annotation。下面的代码定义了一个只包含一个成员的Annotation类型:
public @interface OneMemberAnnotation {
String value();
}
- String:成员类型。可用的成员类型有 String、Class、primitive、enumerated和annotation,以及所列类型的数组
- value:成员名称。如果在所定义的Annotation 类型中只包含一个成员,通常将成员名称命名为value
下面的代码定义了一个包含多个成员的Annotation类型:
public @interface MoreMemberAnnotation {
String describe();
Class type();
}
在为Annotation 类型定义成员时,也可以为成员设置默认值。例如,下面的代码在定义Annotation
型时就为成员设置了默认值:
public @interface DefaultValueAnnotation
String describe() default "<默认值>";
Class type() default void.class;
}
在定义Annotation 类型时,还可以通过 Annotation 类型@Target 来设置Annotation类型适用的程序元素种类。如果未设置@Target,则表示适用于所有程序元素。枚举类 ElementType 中的枚举常量用来设置@Targer,如表16.6所示
通过 Amotaion 类型@Retenion 可以设置Amnotation 的有效范围。枚举类RetentioPolicy 中的枚举常量用来设置@Rctention, 如表 16.7所示。如果未设置@Retention,Annotation 的有效范围为枚举常量CLASS 表示的范围
例题16.4
首先定义一个用来注释构造方法的Annotation类型@Constructor_Annotation,有效范围为在运行时加载Annotation到JVM中。完整代码如下:
-
import java.lang.annotation.ElementType;
-
import java.lang.annotation.Retention;
-
import java.lang.annotation.RetentionPolicy;
-
import java.lang.annotation.Target;
-
@Target(ElementType.CONSTRUCTOR) //用于构造方法
-
@Retention(RetentionPolicy.RUNTIME) //在运行时加载Annotation到JVM中
-
public @interface Constructor_Annotation {
-
String value() default "默认构造方法"; //定义一个具有默认值的String型成员
-
}
然后定义一个用来注释字段、方法和参数的 Annotaion 类型@Field.Method Paranet Anotion
有效范围为在运行时加载 Annotation到JVM中。完整代码如下:
-
import java.lang.annotation.ElementType;
-
import java.lang.annotation.Retention;
-
import java.lang.annotation.RetentionPolicy;
-
import java.lang.annotation.Target;
-
//用于字段,方法和参数
-
@Target({ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER})
-
@Retention(RetentionPolicy.RUNTIME) //在运行时加载Annotation到JVM中
-
public @interface Field_Method_Parameter_Annotation {
-
String describe(); //定义一个没有默认值的String型成员
-
Class type() default void.class; //定义一个具有默认值的Class型成员
-
}
最后编写一个 Record类,在该类中运用前面定义的 Annotation 类型@Constructor_Annotation和
@Field Method Parameter_Annotation 对构造方法、字段、方法和参数进行注释。完整代码如下:
-
public class Record {
-
@Field_Method_Parameter_Annotation(describe = "编号",type = int.class)
-
//注释字段
-
int id;
-
@Field_Method_Parameter_Annotation(describe = "姓名",type = String.class )
-
String name;
-
@Constructor_Annotation()
-
//采用默认值注释构造方法
-
public Record() {
-
}
-
@Constructor_Annotation("立即初始化构造方法")
-
//注释构造方法
-
public Record(@Field_Method_Parameter_Annotation(describe = "编号",type = int.class)int id,
-
@Field_Method_Parameter_Annotation(describe = "姓名",type = String.class)String name) {
-
this.id = id;
-
this.name =name;
-
}
-
@Field_Method_Parameter_Annotation(describe = "获取编号",type = int.class )
-
//注释方法
-
public int getId() {
-
return id;
-
}
-
@Field_Method_Parameter_Annotation(describe = "设置编号")
-
//成员type采用默认值注释方法
-
public void setId(
-
//注释方法的参数
-
@Field_Method_Parameter_Annotation(describe = "编号",type = int.class )int id) {
-
this.id = id;
-
}
-
@Field_Method_Parameter_Annotation(describe = "获取姓名",type = String.class )
-
public String getName() {
-
return name;
-
}
-
@Field_Method_Parameter_Annotation(describe = "设置姓名")
-
public void setName(@Field_Method_Parameter_Annotation(describe = "姓名",type = String.class )String name) {
-
this.name = name;
-
}
-
}
16.2.2 访问Annotation 信息
例题16.5
-
import java.lang.annotation.*;
-
import java.lang.reflect.*;
-
public class AnnotationTest {
-
public static void main(String[] args) {
-
Class recordC = null;
-
try {
-
recordC = Class.forName("Record");
-
} catch (ClassNotFoundException e) {
-
e.printStackTrace();
-
}
-
System.out.println("------ 构造方法的描述如下 ------");
-
Constructor[] declaredConstructors = recordC.getDeclaredConstructors(); // 获得所有构造方法
-
for (int i = 0; i < declaredConstructors.length; i++) {
-
Constructor constructor = declaredConstructors[i]; // 遍历构造方法
-
// 查看是否具有指定类型的注释
-
if (constructor.isAnnotationPresent(Constructor_Annotation.class)) {
-
// 获得指定类型的注释
-
Constructor_Annotation ca = (Constructor_Annotation) constructor
-
.getAnnotation(Constructor_Annotation.class);
-
System.out.println(ca.value()); // 获得注释信息
-
}
-
Annotation[][] parameterAnnotations = constructor.getParameterAnnotations(); // 获得参数的注释
-
for (int j = 0; j < parameterAnnotations.length; j++) {
-
// 获得指定参数注释的长度
-
int length = parameterAnnotations[j].length;
-
if (length == 0) // 如果长度为0则表示没有为该参数添加注释
-
System.out.println(" 未添加Annotation的参数");
-
else
-
for (int k = 0; k < length; k++) {
-
// 获得参数的注释
-
Field_Method_Parameter_Annotation pa = (Field_Method_Parameter_Annotation) parameterAnnotations[j][k];
-
System.out.print(" " + pa.describe()); // 获得参数描述
-
System.out.println(" " + pa.type()); // 获得参数类型
-
}
-
}
-
System.out.println();
-
}
-
System.out.println();
-
System.out.println("-------- 字段的描述如下 --------");
-
Field[] declaredFields = recordC.getDeclaredFields(); // 获得所有字段
-
for (int i = 0; i < declaredFields.length; i++) {
-
Field field = declaredFields[i]; // 遍历字段
-
// 查看是否具有指定类型的注释
-
if (field.isAnnotationPresent(Field_Method_Parameter_Annotation.class)) {
-
// 获得指定类型的注释
-
Field_Method_Parameter_Annotation fa = field.getAnnotation(Field_Method_Parameter_Annotation.class);
-
System.out.print(" " + fa.describe()); // 获得字段的描述
-
System.out.println(" " + fa.type()); // 获得字段的类型
-
}
-
}
-
System.out.println();
-
System.out.println("-------- 方法的描述如下 --------");
-
Method[] methods = recordC.getDeclaredMethods(); // 获得所有方法
-
for (int i = 0; i < methods.length; i++) {
-
Method method = methods[i]; // 遍历方法
-
// 查看是否具有指定类型的注释
-
if (method.isAnnotationPresent(Field_Method_Parameter_Annotation.class)) {
-
// 获得指定类型的注释
-
Field_Method_Parameter_Annotation ma = method.getAnnotation(Field_Method_Parameter_Annotation.class);
-
System.out.println(ma.describe()); // 获得方法的描述
-
System.out.println(ma.type()); // 获得方法的返回值类型
-
}
-
Annotation[][] parameterAnnotations = method.getParameterAnnotations(); // 获得参数的注释
-
for (int j = 0; j < parameterAnnotations.length; j++) {
-
int length = parameterAnnotations[j].length; // 获得指定参数注释的长度
-
if (length == 0) // 如果长度为0表示没有为该参数添加注释
-
System.out.println(" 未添加Annotation的参数");
-
else
-
for (int k = 0; k < length; k++) {
-
// 获得指定类型的注释
-
Field_Method_Parameter_Annotation pa = (Field_Method_Parameter_Annotation) parameterAnnotations[j][k];
-
System.out.print(" " + pa.describe()); // 获得参数的描述
-
System.out.println(" " + pa.type()); // 获得参数的类型
-
}
-
}
-
System.out.println();
-
}
-
}
-
}
-
//例题16.5
运行结果如下: