Heim > Artikel > Java > Beispielanalyse der Java-Reflexion

Beispielanalyse der Java-Reflexion

WBOYnach vorne: 2023-04-29 21:10:051200Durchsuche

1. Klassenklasse und Java-Reflexion

Klasse textFieldC=tetxField.getClass(); tetxField ist die Hauptbeschreibung des JTextField-Klassenobjekts 🎜#
Jedes Constructor-Objekt stellt eine Konstruktionsmethode dar, und die entsprechende Konstruktionsmethode kann mithilfe des Constructor-Objekts manipuliert werden.

getConstructors() //Get public Beispielanalyse der Java-Reflexion

`getConstructor (Class>... parameterTypes)` //Holen Sie sich die angegebene öffentliche

getDeclaredConstructors() //Get alle

getDeclaredConstructor(Class>... parameterTypes) //Holen Sie sich die angegebene Methode getConstructors() //获取公有
getConstructor(Class>... parameterTypes) //获取指定公有
getDeclaredConstructors() //获取所有
getDeclaredConstructor(Class>... parameterTypes) //获取指定方法

创建Demo1类，声明String类型成员变量和3个int类型成员变量，并提供3个构造方法。

package bao;
 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[0]);
			}
			if(2<strings.length) {
				i3=Integer.valueOf(strings[0]);
			}
		}
 		public  void print() {
			System.out.println("s="+s);
			System.out.println("i="+i);
			System.out.println("i2="+i2);
			System.out.println("i3="+i3);
		}
 }

编写Main类，在该类对Demo1进行反射访问的所有构造方法，并将该构造方法是否允许带有可变数量的参数、入口参数和可能抛出的异常类型信息输出。

package bao;
 import java.lang.reflect.Constructor;
 public class Main {
	public static void main(String[] args) {
		Demo1 demo=new Demo1("10","20","30");
		Class<? extends Demo1>demoC=demo.getClass();  
		//获得所有构造方法
		Constructor[] declaredConstryctors=demoC.getDeclaredConstructors();
		for(int i=0;i<declaredConstryctors.length;i++) {
			Constructor<?> constructor=declaredConstryctors[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 example2=null;
			while(example2==null) {
				try {           
					if(i==2) {
						example2=(Demo1)constructor.newInstance();
				}else if(i==1) {
					example2=(Demo1)constructor.newInstance("7",5);
				}else {
					Object[] parameters=new Object[] {new String[] {"100","200","300"}};
					example2=(Demo1)constructor.newInstance(parameters);		
				}	
				}catch(Exception e){
				System.out.println("在创建对象时抛出异常，下面执行setAccessible()方法");
				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=100
i3=100
查看是否允许带有可变数量的参数：false
该构造方法的入口参数类型依次为：
 class java.lang.String
 int
该构造方法的入口可能抛出异常类型为：
s=7
i=5
i2=0
i3=0
查看是否允许带有可变数量的参数：false
该构造方法的入口参数类型依次为：
该构造方法的入口可能抛出异常类型为：
在创建对象时抛出异常，下面执行setAccessible()方法
s=null
i=0
i2=0
i3=0
 */

2、访问成员变量

每个Field对象代表一个成员变量，利用Field对象可以操纵相应的成员变量。

getFields()
getField(String name)
getDeclaredFields()
getDeclaredField(String name)

创建Demo1类依次声明int、fioat、boolean和String类型的成员变量，并设置不同的访问权。

package bao;
 public class Demo1{
	int i;
	public float f;
	protected boolean b;
	private String s;
}

通过反射访问Demo1类中的所有成员变量，将成成员变量的名称和类型信息输出。

package bao;
 import java.lang.reflect.Field;
public class Main {
	public static void main(String[] args) {
		Demo1 demo=new Demo1();
		Class demoC=demo.getClass();
		//获得所有成员变量
		Field[] declaredField=demoC.getDeclaredFields();
		for(int i=0;i<declaredField.length;i++) {
			Field field=declaredField[i];
			System.out.println("名称为："+field.getName());   //获取成员变量名称
 			Class fieldType=field.getType();   ///获取成员变量类型
			System.out.println("类型为："+fieldType);
			boolean isTurn=true;
			while(isTurn) {
				try {
					isTurn=false;
					System.out.println("修改前的值为："+field.get(demo));
					if(fieldType.equals(int.class)) {     //判断成员变量的类型是否为int类型
						System.out.println("利用方法setInt()修改成员变量的值");
						field.setInt(demo, 168);      //为int类型成员变量赋值
					}else if(fieldType.equals(float.class)){     //判断成员变量的类型是否为float类型
						System.out.println("利用方法 setFloat()修改成员变量的值");      
						field.setFloat(demo, 99.9F);      //为float类型成员变量赋值
					}else if(fieldType.equals(boolean.class)){      //判断成员变量的类型是否为boolean类型
						System.out.println("利用方法 setBoolean()修改成员变量的值");
						field.setBoolean(demo, true);      //为boolean类型成员变量赋值
					}else {
						System.out.println("利用方法 set()修改成员变量的值");
						field.set(demo, "MWQ");            //可以为各种类型的成员变量赋值
					}
					//获得成员变量值
					System.out.println("修改后的值为："+field.get(demo));
				}catch(Exception e) {
					System.out.println("在设置成员变量值时抛出异常，"+"下面执行setAccesssible()方法！");
 					field.setAccessible(true);       //设置为允许访问
					isTurn=true;
				}
			}
			System.out.println();
		}
	}
}

/*输出结果：
名称为：i
类型为：int
修改前的值为：0
利用方法setInt()修改成员变量的值
修改后的值为：168
名称为：f
类型为：float
修改前的值为：0.0
利用方法 setFloat()修改成员变量的值
修改后的值为：99.9
名称为：b
类型为：boolean
修改前的值为：false
利用方法 setBoolean()修改成员变量的值
修改后的值为：true
名称为：s
类型为：class java.lang.String
在设置成员变量值时抛出异常，下面执行setAccesssible()方法！
修改前的值为：null
利用方法 set()修改成员变量的值
修改后的值为：MWQ
*/

3、访问方法

每个Method对象代表一个方法，利用Method对象可以操纵相应的方法。

getMethods()
getMethod(String name, Class>... parameterTypes)
getDeclaredMethods()
getDeclaredMethod(String name, Class>... parameterTypes)

创建Demo1类，编写4个典型方法。

package bao;
 public class Demo1{
    static void staitcMethod() {
    	System.out.println("执行staitcMethod()方法");
    }
    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<stringBuffer.length();i++) {
    		stringBuffer.append(strings[i]);
    	}
    	return stringBuffer.toString();
    }
 }

反射访问Demm1类中的所有方法，将方法的名称、入口参数类型、返回值类型等信息输出

package bao;
 import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Main {
	public static void main(String[] args) {
	Demo1 demo = new Demo1();
	Class demoC = demo.getClass();
	// 获得所有方法
	Method[] declaredMethods = demoC.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 {
				isTurn = false;
				if("staitcMethod".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 {
					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();
	}
	}
}

/*输出结果：
名称为：publicMethod
是否允许带有可变数量的参数：false
入口参数类型依次为：
int
返回值类型为：int
可能抛出的异常类型有：
执行publicMethod()方法
返回值为：16800
名称为：staitcMethod
是否允许带有可变数量的参数：false
入口参数类型依次为：
返回值类型为：void
可能抛出的异常类型有：
执行staitcMethod()方法
名称为：protectedMethod
是否允许带有可变数量的参数：false
入口参数类型依次为：
class java.lang.String
int
返回值类型为：int
可能抛出的异常类型有：
class java.lang.NumberFormatException
执行protectedMethod()方法
返回值为：12
名称为：privateMethod
是否允许带有可变数量的参数：true
入口参数类型依次为：
class [Ljava.lang.String;
返回值类型为：class java.lang.String
可能抛出的异常类型有：
在执行方法时抛出异常，下面执行setAccessible()方法！
执行privateMethod()方法
返回值为：
*/

二、使用Annotation功能

1、定义Annotation类型

在定义Annotation类型时，也需要用到用来定义接口的interface关键字，不过需要在interface关键字前加一个“@”符号，即定义Annotation类型的关键字为@interface，这个关键字的隐含意思是继承了java.lang.annotation.Annotation接口。

public @interface NoMemberAnnotation{

String value();

}

@interface：声明关键字。

NoMemberAnnotation：注解名称。

String：成员类型。

value #🎜 🎜#

Erstellen Sie die Klasse Demo1, deklarieren Sie Mitgliedsvariablen vom Typ String und 3 Mitgliedsvariablen vom Typ int und stellen Sie 3 Konstruktoren bereit. #🎜🎜#

package annotationbao;
 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型成员
}

#🎜🎜#Schreiben Sie die Hauptklasse, in der reflektierend auf alle Konstruktoren von Demo1 zugegriffen wird und ob der Konstruktor eine variable Anzahl von Parametern, Eingabeparametern und Ausnahmetypen haben darf, die möglicherweise ausgelöst werden . #🎜🎜#

package annotationbao;
 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 descrblic();     // 定义一个没有默认值的String型成员
	Class type() default void.class;    // 定义一个具有默认值的Class型成员
}

#🎜🎜#2. Zugriff auf Mitgliedsvariablen#🎜🎜##🎜🎜#Jedes Feldobjekt stellt eine Mitgliedsvariable dar, und das Feldobjekt kann zum Bearbeiten der entsprechenden Mitgliedsvariablen verwendet werden. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#getFields()#🎜🎜##🎜🎜##🎜🎜#getField(String name)#🎜🎜##🎜 🎜##🎜🎜#getDeclaredFields()#🎜🎜##🎜🎜##🎜🎜#getDeclaredField(String name)#🎜🎜##🎜🎜##🎜🎜#Erstellen Sie die Demo1-Klasse Deklarieren Sie nacheinander Mitgliedsvariablen vom Typ int, fioat, boolean und String und legen Sie unterschiedliche Zugriffsrechte fest. #🎜🎜#

package annotationbao;
 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 = "设置编号")
	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;
	}
 }

#🎜🎜#Greifen Sie durch Reflektion auf alle Mitgliedsvariablen in der Demo1-Klasse zu und geben Sie die Namens- und Typinformationen der Mitgliedsvariablen aus. #🎜🎜#

package annotationbao;
import java.lang.annotation.*;
import java.lang.reflect.*;
 public class Main_05 {
 	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();
		}
 	}
}

#🎜🎜##🎜🎜#/*Ausgabeergebnis:
Name ist: i
Typ ist: int
Wert vor der Änderung ist: 0
Verwenden Sie The Die Methode setInt() ändert den Wert der Mitgliedsvariablen
Der geänderte Wert ist: 168
Der Name ist: f
Der Typ ist: float
Der geänderte Wert ist: 0,0Verwenden Sie die Methode setFloat(), um den Wert der Mitgliedsvariablen zu ändern
Der geänderte Wert ist: 99,9
Der Name ist: b
Der Typ ist: boolean
The Wert vor der Änderung ist: falseVerwenden Sie die Methode setBoolean(), um den Wert der Mitgliedsvariablen zu ändern
Der geänderte Wert ist: true
Der Name ist: s
Der Typ ist: Klasse java.lang.String
In Beim Festlegen des Werts einer Mitgliedsvariablen wird eine Ausnahme ausgelöst. Führen Sie die unten stehende setAccesssible()-Methode aus!
Der Wert vor der Änderung ist: null
Verwenden Sie die Methode set(), um den Wert der Mitgliedsvariablen zu ändern
Der geänderte Wert ist: MWQ
*/#🎜🎜## 🎜🎜# #🎜🎜#3. Zugriffsmethode #🎜🎜##🎜🎜#Jedes Methodenobjekt stellt eine Methode dar, und die entsprechende Methode kann mithilfe des Methodenobjekts manipuliert werden. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#getMethods()#🎜🎜##🎜🎜##🎜🎜#getMethod(String name, Class>... parameterTypes) #🎜🎜##🎜🎜##🎜🎜#getDeclaredMethods()#🎜🎜##🎜🎜##🎜🎜#getDeclaredMethod(String name, Class>... parameterTypes) #🎜🎜##🎜🎜##🎜🎜#Erstellen Sie die Klasse Demo1 und schreiben Sie 4 typische Methoden. #🎜🎜#rrreee#🎜🎜# Reflektierender Zugriff auf alle Methoden in der Demm1-Klasse, Ausgabe des Methodennamens, des Eingabeparametertyps, des Rückgabewerttyps und anderer Informationen #🎜🎜#rrreee#🎜🎜##🎜🎜#/ *Ausgabeergebnisse:
Der Name lautet: publicMethod
Ob eine variable Anzahl von Parametern zulässig ist: false
Die Eingabeparametertypen sind:
int
Der Rückgabewerttyp ist: intDie Ausnahmetypen, die ausgelöst werden können, sind:
Führen Sie die publicMethod()-Methode aus
Der Rückgabewert ist: 16800
Der Name ist: staitcMethod
Ob Es ist eine variable Anzahl von Parametern zulässig: false
Die Eingabeparametertypen sind:
Der Rückgabewerttyp ist: void
Die Ausnahmetypen, die ausgelöst werden können, sind:
Führen Sie die staitc-Methode aus ()-Methode
Der Name lautet: protectedMethod
Ob eine variable Anzahl von Parametern zulässig ist: false
Die Eintragsparametertypen sind:
class java.lang.String
int
Der Rückgabewerttyp ist: int
Ausnahmetypen, die ausgelöst werden können, sind:
class java.lang.NumberFormatException
Führen Sie die protectedMethod()-Methode aus
Die Rückgabe Wert ist: 12
Der Name ist: privateMethodOb eine variable Anzahl von Parametern zulässig ist: true
Die Eintragsparametertypen sind:
class [Ljava.lang.String;Der Rückgabewerttyp ist: Klasse java.lang
Ausnahmetypen, die ausgelöst werden können, sind:
Eine Ausnahme wird beim Ausführen der Methode ausgelöst. Führen Sie die unten stehende setAccessible()-Methode aus!
Führen Sie die privateMethod()-Methode aus
Der Rückgabewert ist:
*/#🎜🎜##🎜🎜##🎜🎜# 2. Verwenden Sie die Annotation-Funktion #🎜🎜##🎜🎜 #1. Definieren Sie den Annotationstyp#🎜🎜##🎜🎜#Beim Definieren des Annotationstyps müssen Sie auch das zum Definieren der Schnittstelle verwendete Schnittstellenschlüsselwort verwenden, aber Sie müssen vor dem Schnittstellenschlüsselwort ein „@“-Symbol hinzufügen. Das ist der Schlüssel zur Definition des Annotation-Typs. Die implizite Bedeutung dieses Schlüsselworts ist, dass es die java.lang.annotation.Annotation-Schnittstelle erbt. #🎜🎜##🎜🎜##🎜🎜#public @interface NoMemberAnnotation{#🎜🎜##🎜🎜#String value();#🎜🎜##🎜🎜#}#🎜🎜##🎜🎜##🎜🎜 #@interface: Schlüsselwörter deklarieren. #🎜🎜##🎜🎜#NoMemberAnnotation: Anmerkungsname. #🎜🎜##🎜🎜#String: Mitgliedstyp. #🎜🎜##🎜🎜#value: Mitgliedsname. #🎜🎜#

Beispielanalyse der Java-Reflexion

定义并使用Annotation类型

①定义Annotation类型@Constructor_Annotation的有效范围为运行时加载Annotation到JVM中。

package annotationbao;
 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型成员
}

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

package annotationbao;
 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 descrblic();     // 定义一个没有默认值的String型成员
	Class type() default void.class;    // 定义一个具有默认值的Class型成员
}

③编写一个Record类，在该类中运用前面定义Annotation类型的@Constructor_Annotation和@Field_Method_Parameter_Annotation对构造方法、字段、方法和参数进行注释。

package annotationbao;
 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 = "设置编号")
	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、访问Annotation信息

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

联合以上的定义并使用Annotation类型，通过反射访问Record类中的Annotation信息。

package annotationbao;
import java.lang.annotation.*;
import java.lang.reflect.*;
 public class Main_05 {
 	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();
		}
 	}
}

/*输出结果：
------ 构造方法的描述如下 ------
默认构造方法
立即初始化构造方法
编号 int
姓名 class java.lang.String
-------- 字段的描述如下 --------
编号 int
姓名 class java.lang.String
-------- 方法的描述如下 --------
获得姓名
class java.lang.String
设置姓名
void
姓名 class java.lang.String
获得编号
int
设置编号
void
编号 int

*/

Das obige ist der detaillierte Inhalt vonBeispielanalyse der Java-Reflexion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Java jvm String Float Boolean NULL 成员变量 int void 继承接口 class 值类型 public Interface 对象 constructor

Stellungnahme：

Dieser Artikel ist reproduziert unter:yisu.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen

Vorheriger Artikel：Beispielanalyse für Java-Thread-Sicherheit und SynchronisierungNächster Artikel：Beispielanalyse für Java-Thread-Sicherheit und Synchronisierung

In Verbindung stehende Artikel

Mehr sehen

Beispielanalyse der Java-Reflexion

1. Klassenklasse und Java-Reflexion

getConstructor (Class>... parameterTypes) //Holen Sie sich die angegebene öffentliche

2、访问成员变量

3、访问方法

二、使用Annotation功能

1、定义Annotation类型

2、访问Annotation信息

In Verbindung stehende Artikel

`getConstructor (Class>... parameterTypes)` //Holen Sie sich die angegebene öffentliche