第十六章总结

最新推荐文章于 2024-09-11 19:28:50 发布

yyjy12

最新推荐文章于 2024-09-11 19:28:50 发布

阅读量35

点赞数

文章标签： eclipse java

本文链接：https://blog.csdn.net/yyjy12/article/details/134185856

版权

一、反射

通过Java反射机制，可以在程序中访问已经装载到JVM中的Java对象的描述，实现访问、检测和修改描述Java对象本身信息的功能。Java反射机制的功能十分强大，在Java.lang.reflect包中提供了对该功能的支持。

众所周知，所有Java类均继承Object类，在Object类中定义了一个getClass()方法，该方法返回一个类型为Class的对象。例如下面的代码：

JTextField textField=new JTextField();//创建JTextField对象

Class textFieldC =textField.getClass();//获取Class对象

利用Class类的对象textFieldC，可以访问用来返回该对象的textField对象的描述信息。可以访问的主要描述信息如下表

1、访问构造方法

在通过下列一组方法访问构造方法时，将返回Constructor类型的对象或数组。每个Constructor对象代表一个构造方法，利用Constructor对象可以操纵相应的构造方法：

getConstructors()。

getConstructor(Class<?>...parameterTypes)。

getDeclaredConstructors()。

getDeclaredConstructor(Class<?>...parameterTypes)。

如果是访问指定的构造方法，需要根据该构造方法的入口参数的类型来访问。例如，访问一个入口参数类型依次为String型和int型的构造方法，通过下面两种方法均可实现：

objectClass.getDeclaredConstructor(String.class,int.class);
objectClass.getDeclaredConstructor(new Class[]{String.class,int.class});

判断对象Constructor所代表的构造方法是否被private修饰，以及以字符串形式获得该构造方法的所有修饰符的典型代码如下：

int modifiers = constructor.getModifiers();
boolean isEmbellishByPrivate = Modifier.isPrivate(modifiers);
String embellishment = Modifier.toString(modifiers);

例题


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);
	}
}


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();
			}
		}
 
	}
}

2、访问成员变量

在通过下列一组方法访问成员变量时，将返回Field类型的对象或数组。每个Field对象代表每一个成员变量，利用Field对象可以操纵相应的成员变量：

getFields()。

getField(String name)。

getDeclaredFields()。

getDeclaredField(String name)。

如果是访问指定的成员变量，可以通过该成员变量的名称来访问。例如，访问一个名称为birthday的成员变量，访问方法如下：

object.getDeclaredField("birthday");

package com.mr;
 
public class Demo2 {
	int i;
	public float f;
	protected boolean b;
	private String s;
}


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();
		}
	}
}

3、访问成员方法

在通过下列一组方法访问成员方法时，将返回Method类型的对象或数组。每个Method对象代表一个方法，利用Method对象可以操纵相应的方法：

getMethods()。

getMethod(String name ,Class<?>...parameterTypes)。

getDeclaredMethods()。

getDeclaredMethods(String name,Class<?>...parameterTypes)。

如果是访问指定的方法，需要根据该方法的名称和入口参数的类型来访问。例如，访问一个名称为print、入口参数类型依次为String型和int型的方法，通过下面两种方式均可实现：

objectClass.getDeclaredMethod("print",String.class,int.class);
objectClass.getDeclaredMethod("print",new Class[]{String.class,int.class});


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();
	}
}

二、Annotation注解功能

1、定义Annotation注释功能

在定义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() degault"<默认值>";
Class type() default void.class;
}

在定义Annotation类型时，还可以通过Annotation类型@Target来设置Annotation类型适用的程序元素种类。如果未设置@Target，则表示适用所有程序元素。枚举类ElementType中的枚举常量用来设置@Targer，如下表：

通过Annotation类型@Retention可以设置Annotation的有效范围。枚举类RetentionPolicy中的枚举常量用来设置@Retention，如下表。如果设置@Retention，Annotation的有效范围为枚举常量CLASS表示的范围。

2、访问Annotaiton信息

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();
		}
	}
}

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;
	}
}