1.了解反射的基本原理
2.掌握class类的使用
3.使用Class类并结合java.lang.reflect包取得一个类的完整结构
4.通过反射机制动态的调用类中指定的方法，并能向这些方法中传递参数

核心概念：一切的操作都将使用object进行完成，包括类，数组的应用都可以用object进行接收。

正常方式：引入包.类–通过new实例化对象–获取实例化对象
反射方式：获得实例化对象–getClass（）方法获得Class实例–得到完整的包.类名称

java.lang.Class是java.lang.Object的派生类，前者继承自后者。
在java中Object类是一切类的父类，那么所有对象实际上
也就是java.lang.Class类的实例，所以所有对象都可以转变为java.lang.Class类型表示。

实例化Class类对象：Class.forName（），类.class，对象.getClass（）;

用Class类对象本身实例化其他对象:
对象无参:用newInstance方法;
对象有参数:Constructor<?> con[] =Class.forName(“com.evan.reflect.Person2”).getConstructors();
调用Class实例的getConstrcuctors获得一个Constructor数组，再使用Constructor对象的newInstance()方法
实例化其他对象。得到的Object再进行向下转型。

取得类结构：
Constuctors表示类中的构造方法；
Field表示类中的属性；
Method表示类中的方法；
这三个都是AccessibleObject的子类它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力

得到接口：Class<?>[] f = c.getInterfaces();
得到构造方法：Constructor<?>[] cons = c.getConstructors();（可直接打印出来）
构造方法拆分获得：
···
Constructor<?>[] cons = c.getConstructors();
for (int i = 0; i < cons.length; i++) {
System.out.println(Modifier.toString(cons[i].getModifiers()));//把int变为权限修饰符
System.out.println(cons[i].getName());//获得方法名
Class<?>[] b = cons[i].getParameterTypes();//获得参数
for (int j = 0; j < b.length; j++) {
System.out.print(b[j].getName() + “ arg” + i);
if (j < b.length - 1) {
System.out.print(“,”);
} else {
System.out.println(“){}”);
}
}
} ···

得到父类：getSuperclass();
得到方法：Method[] m = c.getMethods();（可直接打印出来）
得到方法的返回值类型,异常类型： m[i].getReturnType().getName();
Class<?>[] ex =m[i].getExceptionTypes();
ex[i].getName();
得到实现的接口或父类中的公共属性：public Field[] getFileds();
f[i].getModifiers(访问权限)/getName(属性名)/getType(属性类型);
得到本类中的全部属性： public Filed[] getDeclaredFields();
f[i].getModifiers(访问权限)/getName(属性名)/getType(属性类型);

通过反射访问类中的方法。
···
Class<?> c=Class.forName(“……”);
Object obj = c.newInstance();
Method med = c.getMethod(“setCountry”,String.class);
med.invoke(obj,”haha”);

setter getter 反射实现：
class GetClassDemo6 {
public static void main(String[] args) {
Object per = null;
try {
per =Class.forName(“com.evan.reflect.Person4”).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {

e.printStackTrace();
} catch (ClassNotFoundException e) {

e.printStackTrace();
}
setter(per, “name”, “sb”, String.class);
setter(per, “age”, 30, int.class);
getter(per, “name”);
getter(per, “age”);
}

public static void setter(Object obj, String arr, Object value, Class<?> type) {

try {
String s =”set”+up(arr);
Method met = obj.getClass().getMethod(s, type);
met.invoke(obj, value);
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void getter(Object obj, String arr) {
try {
String s =”get”+up(arr);
Method met = obj.getClass().getMethod(s);
System.out.println(met.invoke(obj));
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

public static String up(String arr) {
String s = arr.substring(0, 1).toUpperCase() + arr.substring(1);
return s;
}
} ···

反射操作数组：
得到数组Class类型：Class<?> c = temp.getClass().getComponentType();
修改数组大小：
···
public static void main(String[] args) {
int temp[] = { 1, 2, 3 };
// Class<?> c = temp.getClass().getComponentType();//获得数组组件类型的 Class
// System.out.println(c.getName());//返回数组类型
int temp1[] = (int[]) arrayinc(temp, 5);
for (int i = 0; i < temp1.length; i++) {
System.out.println(temp1[i]);
}
} ···
···
public static Object arrayinc(Object obj, int len) {
Class<?> c = obj.getClass();
Class<?> a = c.getComponentType();
Object Onew = Array.newInstance(a, len);
int co = Array.getLength(obj);
System.arraycopy(obj, 0, Onew, 0, co);
//源数组对象，从源下标位置开始，新数字，从新下标位置开始，复制源数组长度
return Onew;
} ···

Array类反射操作包中表示一个数组
Array.newInstance(a, len);新建一个数组，a表示任意数组组件类型的 Class对象
Array.getLength(obj);得到数组长度
Array.set(Object array，int index，int value);修改制定下标的内容