1.基本类的反射
package senssic.demo;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
* 反射,实例化Class是反射的源头,然后可以反射各个部分
*
* @author Administrator
*
*/
@Retention(RetentionPolicy.RUNTIME)
@interface What {
String description();
}
interface B {
public void location();
}
class C {
public String place = "安徽阜阳";
public void nativePlace() {
System.out.println("中国安徽阜阳!");
}
}
@What(description = "annotation反射的一个例子")
class A extends C implements B {
private String name;
private int age;
public A() {
}
public A(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void pp(String name, int age) {
System.out.println("普通方法,方法名字:" + name + "方法年龄:" + age);
}
@Override
public String toString() {
return "姓名:" + this.name + "年龄:" + this.age;
}
@Override
public void location() {
System.out.println("中国安徽池州!");
}
}
public class ReflectClass {
public static void main(String[] args) throws Exception {
// 实例化Class类的三种方法
// 1.使用Class类的静态方法forName(),抛异常
Class cl = null;
try {
cl = Class.forName("senssic.demo.A");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 2.使用类.class实例化Class类
// / Class cla = A.class;
// 3.使用对象.getClass()方法实例化Class类
// / A a = new A();
// / Class class1 = a.getClass();
System.out.println(cl.getName());
// 通过反射实例化对象,但被实例化类必须有无参构造方法
A a = (A) cl.newInstance();
a.setName("senssic");
a.setAge(20);
System.out.println(a.toString());
// 通过反射实例化有参构造类,还可以调用返回Constructor数组的重载函数然后指定那个构造函数,此方法使用的是可变参数的函数指定的构造函数
A a2 = (A) cl.getConstructor(String.class, int.class).newInstance(
"senssic2", 21);
System.out.println(a2.toString());
// 通过反射获得一个类的结构
// 1.获得全部接口
for (Class ssalc : cl.getInterfaces()) {
System.out.println(ssalc.getName());// 输出接口名字
}
// 2.获得所有继承的父类
System.out.println(cl.getSuperclass());// 输出父类类名
// 3.反射获得所有的Annotation
for (Annotation ann : cl.getAnnotations()) {
System.out.println(ann.toString());
}
// 反射得到一个类的结构
// 获取所有类属性
System.out.println("-------反射得到一个类的结构--------");
System.out.println("类中的所有属性:");
System.out.println("<---公共属性(实现的接口或者父类中的公共属性)--->");
for (Field field : cl.getFields()) {// getFields获得公共属性
System.out.print(Modifier.toString(field.getModifiers()));
System.out.print(" " + field.getType().getName());
System.out.print(" " + field.getName() + "\n");
}
System.out.println("<---自己类中的属性--->");
for (Field field : cl.getDeclaredFields()) {// 获得本类属性
System.out.print(Modifier.toString(field.getModifiers()));
System.out.print(" " + field.getType().getName());
System.out.print(" " + field.getName() + "\n");
}
// 获取所有构造函数
System.out.println("类中所有构造方法:");
for (Constructor<A> con : cl.getConstructors()) {// 获得所有类中构造函数
System.out.print(Modifier.toString(con.getModifiers()) + " ");// 获得修饰符并转换为String类型
System.out.print(con.getName() + "(");
StringBuilder sb = new StringBuilder();
for (Class ssalc : con.getParameterTypes()) {
sb.append(ssalc.getName() + ",");// 获得参数类型
}
if (sb.length() != 0) {
System.out.print(sb.substring(0, sb.length() - 1));// 如果不为空参数除去最后一个“,”字符
}
System.out.print("){}\n");
}
// 获取所有方法
System.out.println("类中全部方法:");
for (Method method : cl.getMethods()) {
System.out.print(Modifier.toString(method.getModifiers()));// 获得修饰符并转换为String类型
System.out.print(" " + method.getReturnType().getName());// 获得返回类型
System.out.print(" " + method.getName() + "(");
StringBuilder sbBuilder = new StringBuilder();
for (Class ssalc : method.getParameterTypes()) {// 获取参数类型
sbBuilder.append(ssalc.getName() + ",");
}
if (sbBuilder.length() != 0) {
System.out
.print(sbBuilder.substring(0, sbBuilder.length() - 1));
}
if (method.getExceptionTypes().length > 0) {// 判断是否有抛出异常
System.out.print(")throws");
} else {
System.out.print(")");
}
StringBuilder sBuilder = new StringBuilder();
for (Class ssalc : method.getExceptionTypes()) {// 获得异常类型
sBuilder.append(ssalc.getName() + ",");
}
if (sBuilder.length() != 0) {
System.out.print(sBuilder.substring(0, sBuilder.length() - 1));
}
System.out.print("{ }\n");
}
// 通过反射调用方法(无参)
Method method = cl.getMethod("nativePlace");// 获得无参函数
method.invoke(cl.newInstance());// 调用
// 通过反射调用方法(有参)
Method method2 = cl.getMethod("pp", String.class, int.class);// 获得有参函数
method2.invoke(cl.newInstance(), "senssic", 22);// 调用
// 通过反射调用属性
Field nameField = cl.getDeclaredField("name");// 获得本类属性
Field ageField = cl.getDeclaredField("age");
nameField.setAccessible(true);// 设置私有属(private)性可见
ageField.setAccessible(true);
Object obj = cl.newInstance();
nameField.set(obj, "senssic");// 设置属性
ageField.set(obj, 23);
System.out.println("通过反射设置属性值:得到的返回的属性值为--->name:" + nameField.get(obj)
+ " age:"// 获得属性值
+ ageField.get(obj));
// 当然数组也可以被反射,通过Class类结合java.lang.reflect.Array就可以操作了,基本操作都差不多的就不再累赘
}
}
运行结果:
senssic.demo.A
姓名:senssic年龄:20
姓名:senssic2年龄:21
senssic.demo.B
class senssic.demo.C
@senssic.demo.What(description=annotation反射的一个例子)
-------反射得到一个类的结构--------
类中的所有属性:
<---公共属性(实现的接口或者父类中的公共属性)--->
public java.lang.String place
<---自己类中的属性--->
private java.lang.String name
private int age
类中所有构造方法:
public senssic.demo.A(){}
public senssic.demo.A(java.lang.String,int){}
类中全部方法:
public void pp(java.lang.String,int){ }
public void setAge(int){ }
public int getAge(){ }
public java.lang.String toString(){ }
public java.lang.String getName(){ }
public void setName(java.lang.String){ }
public void location(){ }
public void nativePlace(){ }
public final native java.lang.Class getClass(){ }
public native int hashCode(){ }
public boolean equals(java.lang.Object){ }
public final native void notify(){ }
public final native void notifyAll(){ }
public final void wait(long,int)throwsjava.lang.InterruptedException{ }
public final void wait()throwsjava.lang.InterruptedException{ }
public final native void wait(long)throwsjava.lang.InterruptedException{ }
中国安徽阜阳!
普通方法,方法名字:senssic方法年龄:22
通过反射设置属性值:得到的返回的属性值为--->name:senssic age:23
2.泛型类的反射
package senssic.server.base;
public class MyclassSuper<Date, Timer> {
}
package senssic.server.base;
/**
* 其实这里的泛型只是标注,内有任何实在意义,发挥其意义的是在他的实现类,必须指明
*
* @author qiss
*
* @param <Timer>
* @param <T>
*/
public interface MyclassInter<Timer, T> {
}
package senssic.server.base;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.sql.Time;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
class Person {
}
class Pro {
}
/**
* 其实现类,当继承父类或实现接口时候,他们的泛型必须指明类型,或者也使用泛型,让下一个子类指明,比如此处的J并未指明而是本类也指明泛型
*
* @author qiss
*
* @param <T>
* @param <K>
*/
@SuppressWarnings("rawtypes")
public class MyClass<J, K> extends MyclassSuper<Date, K> implements
MyclassInter<String, J> {
private Map<K, Map<List<Person>, Time>> stringList = new HashMap<K, Map<List<Person>, Time>>();
private List<Date> list = new ArrayList<Date>();
public Set<String> set = new TreeSet<String>();
public List<K> lisk = new ArrayList<K>();
public Set<J> setj = new TreeSet<J>();
public Map<K, Map<List<Person>, Time>> getStringList(List<String> list,
Set<List<Pro>> set) {
return this.stringList;
}
public static void main(String[] args) throws Exception {
System.out.println("===获取父类的泛型类型===");
Type genersupertype = MyClass.class.getGenericSuperclass();
if (genersupertype instanceof ParameterizedType) {
Type type[] = ((ParameterizedType) genersupertype)
.getActualTypeArguments();
for (int i = 0; i < type.length; i++) {
// 如果还是泛型
if (type[i] instanceof TypeVariable) {
System.out.println(((TypeVariable) type[i]).getName());
} else {
System.out.println((Class) type[i]);
}
}
}
System.out.println("===获取父接口的泛型类型===");
// 父接口可能有多个
Type genersuperintertype[] = MyClass.class.getGenericInterfaces();
for (int i = 0; i < genersuperintertype.length; i++) {
if (genersuperintertype[i] instanceof ParameterizedType) {
Type type[] = ((ParameterizedType) genersuperintertype[i])
.getActualTypeArguments();
for (int j = 0; j < type.length; j++) {
// 如果还是泛型
if (type[j] instanceof TypeVariable) {
System.out.println(((TypeVariable) type[j]).getName());
} else {
System.out.println((Class) type[j]);
}
}
}
}
System.out.println("===获取方法返回的泛型类型===");
Method method = MyClass.class.getMethod("getStringList", List.class,
Set.class);
Type genericMethodReturn = method.getGenericReturnType();
if (genericMethodReturn instanceof ParameterizedType) {
Type type[] = ((ParameterizedType) genericMethodReturn)
.getActualTypeArguments();
for (int i = 0; i < type.length; i++) {
// 如果还是泛型
if (type[i] instanceof TypeVariable) {
System.out.println(((TypeVariable) type[i]).getName());
} else {
// 如果泛型参数还带泛型参数
if (type[i] instanceof ParameterizedType) {
Type type2[] = ((ParameterizedType) type[i])
.getActualTypeArguments();
for (int j = 0; j < type2.length; j++) {
// 如果泛型参数的参数的参数仍是泛型
if (type2[j] instanceof ParameterizedType) {
Type type3[] = ((ParameterizedType) type2[j])
.getActualTypeArguments();
for (int k = 0; k < type3.length; k++) {
// 如果还是泛型^^^可以无限循环下去
if (type3[k] instanceof TypeVariable) {
System.out
.println(((TypeVariable) type3[k])
.getName());
} else {
System.out.println((Class) type3[k]);
}
}
} else {
System.out.println((Class) type2[j]);
}
}
}
}
}
}
System.out.println("===获取方法参数的泛型类型===");
Method methGengraPramem = MyClass.class.getMethod("getStringList",
List.class, Set.class);
Type[] types = methGengraPramem.getGenericParameterTypes();
for (int l = 0; l < types.length; l++) {
if (types[l] instanceof ParameterizedType) {
Type type[] = ((ParameterizedType) types[l])
.getActualTypeArguments();
for (int i = 0; i < type.length; i++) {
// 如果还是泛型
if (type[i] instanceof TypeVariable) {
System.out.println(((TypeVariable) type[i]).getName());
} else {
// 如果泛型参数还带泛型参数
if (type[i] instanceof ParameterizedType) {
Type type2[] = ((ParameterizedType) type[i])
.getActualTypeArguments();
for (int j = 0; j < type2.length; j++) {
// 如果泛型参数的参数的参数仍是泛型
if (type2[j] instanceof ParameterizedType) {
Type type3[] = ((ParameterizedType) type2[j])
.getActualTypeArguments();
for (int k = 0; k < type3.length; k++) {
// 如果还是泛型^^^可以无限循环下去
if (type3[k] instanceof TypeVariable) {
System.out
.println(((TypeVariable) type3[k])
.getName());
} else {
System.out
.println((Class) type3[k]);
}
}
} else {
System.out.println((Class) type2[j]);
}
}
} else {
System.out.println((Class) type[i]);
}
}
}
} else {
System.out.println((Class) types[l]);
}
}
System.out.println("===获取保护字段的泛型参数类型===");
Field field[] = MyClass.class.getDeclaredFields();
for (int i = 0; i < field.length; i++) {
Type type = field[i].getGenericType();
// 如果是泛型参数
if (type instanceof ParameterizedType) {
Type type2[] = ((ParameterizedType) type)
.getActualTypeArguments();
for (int j = 0; j < type2.length; j++) {
if (type2[j] instanceof TypeVariable) {
System.out.println(((TypeVariable) type2[j]).getName());
} else {
if (type2[j] instanceof ParameterizedType) {
Type type3[] = ((ParameterizedType) type2[j])
.getActualTypeArguments();
for (int k = 0; k < type3.length; k++) {
if (type3[k] instanceof TypeVariable) {
System.out
.println(((TypeVariable) type3[k])
.getName());
} else {
if (type3[k] instanceof ParameterizedType) {
Type type4[] = ((ParameterizedType) type3[k])
.getActualTypeArguments();
for (int m = 0; m < type4.length; m++) {
// ^^^可以无限循环下去
if (type4[m] instanceof TypeVariable) {
System.out
.println(((TypeVariable) type4[m])
.getName());
} else {
System.out
.println((Class) type4[m]);
}
}
} else {
System.out.println((Class) type3[k]);
}
}
}
} else {
System.out.println((Class) type2[j]);
}
}
}
}
}
System.out.println("===获取公共字段的泛型参数类型===");
Field fields[] = MyClass.class.getFields();
for (int i = 0; i < fields.length; i++) {
Type pubfilegenera = fields[i].getGenericType();
if (pubfilegenera instanceof ParameterizedType) {
Type type[] = ((ParameterizedType) pubfilegenera)
.getActualTypeArguments();
for (int j = 0; j < type.length; j++) {
if (type[j] instanceof TypeVariable) {
System.out.println(((TypeVariable) type[j]).getName());
} else {
System.out.println((Class) type[j]);
}
}
}
}
}
}
运行结果:
class java.util.Date
K
===获取父接口的泛型类型===
class java.lang.String
J
===获取方法返回的泛型类型===
K
class senssic.server.base.Person
class java.sql.Time
===获取方法参数的泛型类型===
class java.lang.String
class senssic.server.base.Pro
===获取保护字段的泛型参数类型===
K
class senssic.server.base.Person
class java.sql.Time
class java.util.Date
class java.lang.String
K
J
===获取公共字段的泛型参数类型===
class java.lang.String
K
J