Java反射 书籍推荐_Java反射（完结）

import java.lang.reflect.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Parameter;

import java.lang.reflect.Type;

/**

* Member

* java.lang.reflect.Field ：对应类变量

* java.lang.reflect.Method ：对应类方法

* java.lang.reflect.Constructor ：对应类构造函数

*

*

* AccessibleObject

* java.lang.reflect.Method :成员方法,静态方法

* java.lang.reflect.Constructor :构造方法

*/

public class TestReflect {

public static void main(String[] args) {

Class c = null;

Object obj = null;

try {

c = Class.forName("com.example.wifi.Reflect.Cat");

obj = c.getConstructor(String.class, int.class).newInstance("短歌短歌", 1);

/**

* 1,属性:变量,静态变量,静态常量

* getDeclaredField(String name)

* 获取指定的变量(只要是声明的变量都能获得，包括private)

* getField(String name)

* 获取指定的变量(只能获得public的)

* getDeclaredFields()

* 获取所有声明的变量(包括private)

* getFields()

* 获取所有的public变量

*/

//name

Field fieldName = c.getDeclaredField("name");

fieldName.setAccessible(true);//可以访问private修改的变量

String name = (String) fieldName.get(obj);

System.out.println("name : " + name);

fieldName.set(obj, "富力东方");

String name2 = (String) fieldName.get(obj);

System.out.println("name : " + name2);

//TAG1

Field fieldTAG1 = c.getDeclaredField("TAG1");

fieldTAG1.setAccessible(true);

String TAG1 = (String) fieldTAG1.get(null);

System.out.println("TAG1 : " + TAG1);

//TAG2

Field fieldTAG2 = c.getDeclaredField("TAG2");

fieldTAG2.setAccessible(true);

String TAG2 = (String) fieldTAG2.get(obj);

System.out.println("TAG2 : " + TAG2);

/**

* 2,Method

* getDeclaredMethod(String name, Class>... parameterTypes)

* 根据方法名获得指定的方法， 参数name为方法名，参数parameterTypes为方法的参数类型，如 getDeclaredMethod(“eat”, String.class)

* getMethod(String name, Class>... parameterTypes)

* 根据方法名获取指定的public方法，其它同上

* getDeclaredMethods()

* 获取所有声明的方法

* getMethods()

* 获取所有的public方法

*/

//静态方法

Method methodGetTAG = c.getDeclaredMethod("getTAG");

methodGetTAG.setAccessible(true);

String result = (String) methodGetTAG.invoke(null);

System.out.println("getTAG : " + result);

//成员方法

Method methodSetName = c.getDeclaredMethod("setName", String.class);

methodSetName.invoke(obj, "猜猜我是谁");

Method methodGetName = c.getDeclaredMethod("getName");

String getName = (String) methodGetName.invoke(obj);

System.out.println("getName : " + getName);

//3,获取方法的返回值的class和taype

Class classReturnType = methodGetName.getReturnType();

Type getGenericReturnType = methodGetName.getGenericReturnType();

//方法参数的class和type的数组.

Class[] getDeclaringClass = methodSetName.getParameterTypes();

Type[] getParameterTypes = methodSetName.getGenericParameterTypes();

//获取方法参数相关信息

Parameter[] getParameters = methodSetName.getParameters();

for (int i = 0; i < getParameters.length; i++) {

Parameter p = getParameters[i];

p.getType(); //获取参数类型

p.getName(); //获取参数名称，如果编译时未加上`-parameters`，返回的名称形如`argX`, X为参数在方法声明中的位置，从0开始

p.getModifiers(); //获取参数修饰符

p.isNamePresent(); //.class文件中是否保存参数名称, 编译时加上`-parameters`返回true,反之flase

}

System.out.println("是否是可变参数"+methodSetName.isVarArgs()); //判断方法参数是否是可变参数

System.out.println("是否是复合方法"+methodSetName.isSynthetic()); //判断是否是复合方法，个人理解复合方法是编译期间编译器生成的方法，并不是源代码中有的方法

System.out.println("是否是桥接方法"+methodSetName.isBridge()); //判断是否是桥接方法，桥接方法是 JDK 1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法。可以参考

//调用定项参数方法

Method eat = c.getDeclaredMethod("eat", String.class);

eat.invoke(obj, "grass");

//调用不定项参数方法

//不定项参数可以当成数组来处理

Class[] argTypes = new Class[] { String[].class };

Method varargsEat = c.getDeclaredMethod("eat", argTypes);

String[] foods = new String[]{

"grass", "meat","苹果","白菜"

};

varargsEat.invoke(obj, (Object)foods);

/**

* 3,构造方法

* getDeclaredConstructor(Class>... parameterTypes)

* 获取指定构造函数，参数parameterTypes为构造方法的参数类型

* getConstructor(Class>... parameterTypes)

* 获取指定public构造函数，参数parameterTypes为构造方法的参数类型

* getDeclaredConstructors()

* 获取所有声明的构造方法

* getConstructors()

* 获取所有的public构造方法

*/

Constructor constructor = c.getDeclaredConstructor(String.class);//获取私有构造方法

constructor.setAccessible(true);

Animal cat = (Cat) constructor.newInstance("只有一个");

System.out.println("获取名字"+cat.toString());

/**

* 4,数组

*/

Field field = c.getDeclaredField("arryInt");

field.setAccessible(true);

//获取一个变量的类型

Class> cArray = field.getType();

//判断该变量是否为数组

if (cArray.isArray()) {

//获取数组的元素类型

int[] array = (int[]) field.get(obj);

for (int i = 0; i < array.length; i++) {

System.out.println(Array.get(array, i));//读取下标bai2数组du元素zhi

}

}

/**

* 5,枚举

*/

Class classEnum = Class.forName("com.example.wifi.Reflect.StatuEnum");

if (classEnum.isEnum()) {

Object[] objectEnum = classEnum.getEnumConstants();

for (int i = 0; i < objectEnum.length; i++) {

System.out.println("枚举="+objectEnum[i]);

System.out.println("枚举值="+((StatuEnum)objectEnum[i]).s);

}

}

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (NoSuchFieldException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

} catch (NoSuchMethodException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

}

}

//父类

public class Animal {

private String name;

private int age;

public Animal(String name, int age) {

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "Animal : name = " + name + " age = " + age;

}

}

//反射获取的对象类

import java.io.Serializable;

class Cat extends Animal implements Serializable {

private static final String TAG = Cat.class.getSimpleName();

private static String TAG1 = Cat.class.getName();

private final String TAG2 = "lalala";

private int[] arryInt = {1, 2, 3, 4, 5, 6};

private String name;

private int i = new Integer(10);

@Deprecated

public int age;

public Cat() {

super("", 0);

}

private Cat(String name) {

super(name, 0);

this.name = name;

}

public Cat(String name, int age) {

super(name, age);

this.name = name;

this.age = age;

}

public void setName(String names) {

this.name = names;

}

public String getName() {

return name;

}

public void eat(String food) {

System.out.println(TAG + "eat food " + food);

}

public void eat(String... foods) {

StringBuilder s = new StringBuilder();

for (String food : foods) {

s.append(food);

s.append(" ");

}

System.out.println(TAG + "eat food " + s.toString());

}

public void sleep() {

System.out.println(TAG + "sleep");

}

private static String getTAG() {

return TAG;

}

@Override

public String toString() {

return "name = " + name + " age = " + age;

}

}

//枚举

public enum StatuEnum {

START("start"), STOP("stop"), DESTROY("destroy");

StatuEnum(String s) {

this.s = s;

}

String s;

}