第16章反射和注解

于 2023-11-02 21:22:55 发布
阅读量46 收藏
点赞数
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kankan2_233/article/details/134167793
版权

 反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

通过反射获取构造方法


 1.获取构造方法：
  1).批量的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
            public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
     
  2).获取单个的方法，并调用：
public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；

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

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

 

 
 

 
 
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

Annotation注释功能


1、定义Annotation注释功能


定义Annotation类型包含多个成员

public @interface NoMemberAnnotation{String describe（）；Class type（）；

}

可用成员类型：String 、Class、primitive、enumerated和annotation

在定义Annotation类型时可通过@Target来设置Annotation类型适用的程序元素种类

创建自定义的注解

首先定义一个用来注释构造方法的Annotation类型@Constructor_Annotation，有效范围为在运行时加载Annotation到JVM中。完整代码如下：

import java.lang.annotation.*;
 
@Target(ElementType.CONSTRUCTOR)
// 用于构造方法
@Retention(RetentionPolicy.RUNTIME)
// 在运行时加载Annotation到JVM中
public @interface Constructor_Annotation {
	String value() default "默认构造方法"; // 定义一个具有默认值的String型成员
}

然后定义一个用来注释字段、方法和参数的Annotation类型@Field_Method_Parameter_Annotation,有效范围为在运行时加载Annotation到JVM中。 

import java.lang.annotation.*;
 
// 用于字段、方法和参数
@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_Parmeter_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;
	}
}

2、访问Annotaiton信息 


如果在定义Annotaiton类型时将@Retention设置为RetentionPolicy.RUNTIME,那么在运行程序时通过反射就可以获取到相关的Annotaiton信息，如获取构造方法、字段和方法的Annotaiton信息。

Constructor类、Field类和Method类均继承了AccessibleObject类，在AccessibleObject类中定义了三个关于Annotaiton的方法。其中，方法isAnnotaitonPresent(Class<? extends Annotaiton>annotaitonClass)用来查看是否添加了指定类型的Annotaiton，如果是则返回true，否则返回false；方法getAnnotaiton(Class<T>annotaitonClass)用来获得指定类型的Annotaiton，如果存在则返回相应的对象，否则返回null；方法getAnnotaiton()用来获得所有Annotaiton，该方法将返回一个Annotaiton数组。

在Constructor类和Method类中还定义了方法getParameterAnnotaitons()，用来获得为所有参数添加的Annotaiton，将以Annotaiton类型的二维数组返回，在数组中的顺序与声明的顺序相同。如果没有参数返回一个长度为0的数组；如果存在未添加Annotaiton的参数，将用一个长度为0的嵌套数组占位。

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

内置注解

@Override介绍：只能用在构造方法和成员变量上，表示修饰一个方法。

@SuppressWarnings作用：抑制编译器警告 作用范围类、成员属性、成员方法

@Deprecated作用：标识已过时 

kankan2_233
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值