学习java中的反射(一)
程序员文章站
2024-01-20 11:56:52
...
说明:一下代码是参考网上一份代码,结合自己的分析进行学习的。这篇文章的内容后续会进行相应的修改
package com.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
/**
*/
interface GenericInterface {
};
class GenericSuperClass {
};
interface IClassTestA<A, B> extends GenericInterface {
String printA(A a);
}
interface IClassTestB<A, B> extends GenericInterface {
String printB(B b);
}
interface IClassTestC extends GenericInterface {
String printC();
}
class ClassTestC<A, B> extends GenericSuperClass implements IClassTestA<A, B> {
@Override
public String printA(A a) {
System.out.println("this is A:" + a);
return null;
}
}
public class ClassTest<A, B> extends ClassTestC<A, B> implements
IClassTestB<A, B>, IClassTestC {
private A a;
private B b;
private String c;
private ClassTest() {
}
public ClassTest(A a, B b) {
this.a = a;
this.b = b;
System.out.println("constructor :" + a.toString() + b.toString());
}
@Override
public String printB(B b) {
System.out.println("this is B:" + b);
return null;
}
@SuppressWarnings("unchecked")
public static void main(String[] args) {
try {
Class<ClassTest> classTest = ClassTest.class;
/** 类所实现的接口 */
Class[] intf = classTest.getInterfaces();
System.out.print("类实现的接口:");
for (Class c : intf) {
System.out.print(c.toString() + " ");
}
System.out
.println("\n------------------------------------------------------------------------");
/**
* 取得接口Type[] getGenericInterfaces public Type[]
* getGenericInterfaces()返回表示某些接口的 Type,这些接口由此对象所表示的类或接口直接实现。
* 如果超接口是参数化类型,则为它返回的 Type
* 对象必须准确反映源代码中所使用的实际类型参数。如果以前未曾创建表示每个超接口的参数化类型
* ,则创建这个类型。有关参数化类型创建过程的语义,请参阅 ParameterizedType 声明。
*
* 如果此对象表示一个类,则返回一个包含这样一些对象的数组,这些对象表示该类实现的所有接口。
* 数组中接口对象顺序与此对象所表示的类的声明的 implements 子句中接口名顺序一致。对于数组类,接口 Cloneable 和
* Serializable 以该顺序返回。
*
* 如果此对象表示一个接口,则该数组包含表示该接口直接扩展的所有接口的对象。数组中接口对象顺序与此对象所表示的接口的声明的
* extends 子句中接口名顺序一致。
*
* 如果此对象表示一个不实现任何接口的类或接口,则此方法返回一个长度为 0 的数组。
*
* 如果此对象表示一个基本类型或 void,则此方法返回一个长度为 0 的数组。
*
*
* 返回: 此类所实现的接口的一个数组
*/
Type[] types = classTest.getGenericInterfaces();
System.out.print("Type[] getGenericInterfaces:");
// IClassTestC不属于以下四种子类
for (Type type : types) {
// ParameterizedType 表示参数化类型也就是泛型 ,如 Collection<String>。
if (type instanceof ParameterizedType) {
System.out.print(" ParameterizedType:" + type.toString());
// ParameterizedType:complex.java.lang.IClassTestB<A, B>
// 取该type的实际类型 Type[] (泛型的实际类型)
Type[] ts = ((ParameterizedType) type)
.getActualTypeArguments();
System.out.print(" ts的长度是:" + ts.length);
for (Type t : ts) {
if (t instanceof ParameterizedType) {
// 循环了--------------------
System.out.print("ParameterizedType:"
+ t.toString() + " ");
}
// GenericArrayType 表示一种数组类型,其组件类型为参数化类型或类型变量
if (t instanceof GenericArrayType) {
System.out
.print("GenericArrayType:" + t.toString());
}
/**
* TypeVariable 是各种类型变量的公共高级接口。
* 类型变量在反射方法首次需要时创建(在此包中指定)。 如果类型变量 t 由类型(即类、接口或注释类型)T
* 引用, 而且 T 由 T 的第 n 个封闭类声明(请参见 JLS 8.1.2) ,那么创建 t
* 需要解析(请参见 JVMS 5)T 的第 i 个封闭类,其中 i = 0 到 n(包含)。
* 创建某个类型变量决不能导致创建其边界。重复创建类型变量没有效果。
* 可以在运行时将多个对象实例化,以表示一个给定的类型变量。
* 尽管类型变量仅创建一次,这并不意味着任何缓存实例的要求都表示类型变量。
* 不过,表示类型变量的所有实例彼此必须相等 (equal())。
* 因此,使用类型变量的用户决不能依靠实现此接口的类实例的身份。
*/
// A,B就属于此类型
if (t instanceof TypeVariable) {
System.out.print(" TypeVariable:" + t.toString());
}
}
}
// ####################################
if (type instanceof GenericArrayType) {
System.out.print("属于GenericArrayType类型:" + type.toString());
}
if (type instanceof TypeVariable) {
System.out.print("属于TypeVariable类型:" + type.toString());
}
if (type instanceof WildcardType) {
System.out.print("属于WildcardType类型:" + type.toString());
}
}
System.out
.println("\n--------------------------------------------------------------------------------");
/** 取得父类Type */
Type type = classTest.getGenericSuperclass();
System.out.println("父类的type:" + type.toString());
System.out
.println("---------------------------------------------------------------------------------");
/** ############################################# */
/** 取得属性 */
ClassTest ct = new ClassTest();
// public属性
Field[] fields = classTest.getFields();
// 所有声明的属性
fields = classTest.getDeclaredFields();
for (Field field : fields) {
// field.get(ct)为ct对象的各field值
System.out.println("ct's " + field.toGenericString() + ":"
+ field.get(ct));
}
System.out
.println("-----------------------------------------------------------------");
/** 取得构造方法 */
// 取得public的构造方法
Constructor[] constructors = classTest.getConstructors();
// 取得所有声明的构造方法
constructors = classTest.getDeclaredConstructors();
for (Constructor constructor : constructors) {
// 构造方法的名称
System.out.println(constructor.getName());
// 构造方法的 Java 语言修饰符
System.out.println(constructor.getModifiers());
Class<?>[] cs = constructor.getParameterTypes();
for (Class c : cs) {
System.out.println("constructor.getParameterTypes"
+ c.toString());
}
System.out.println(constructor.toGenericString());
}
/** 取得方法 */
// public方法
Method[] methods = classTest.getMethods();
// 所有声明的方法
methods = classTest.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.toGenericString());
}
// 取得某个具体方法
Method method = classTest.getMethod("getTest", String.class);
// 调用ct对象的该方法
method.invoke(ct, "++++++++++++++this getTest");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public String printC() {
// TODO Auto-generated method stub
return "classTest printC()";
}
public String getTest(String a) {
System.out.println(a);
return "来自classTest getTest(String a)";
}
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}
}
上一篇: 设计模式的应用场景(15)--状态模式
下一篇: python算法100题002