反射

反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
Person p = new Person();
p.show();
要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。
Class类：
  成员变量 Field
  构造方法 Constructor
  成员方法 Method
获取class文件对象的方式：
 A:Object类的getClass()方法：对象.getClass();
 B:数据类型的静态属性class：类名.class;
 C:Class类中的静态方法：class.forName("类的全名");public static Class forName(String className)
一般我们使用的情况
   A:自己玩 任选一种，第二种比较方便
   B:开发 第三种（因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中）
Class类中的方法
 1.public Constructor[] getConstructors():获取所有公共构造方法返回到数组中
 2.public Constructor[] getDeclaredConstructors():获取所有构造方法返回到数组中
 3.public Constructor<T> getConstructor(Class<?>... parameterTypes)
 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
 4.public Field[] fields = c.getFields();返回所有的公共成员变量
 5.public Field[] fields = c.getDeclaredFields();返回所有的成员变量
 6.public Field getField(String name);返回单个公共成员变量
 7.public Field getDeclaredField(String name) ：返回单个成员变量（变量名）
 8.public Method[] methods = c.getMethods(); 获取自己的包括父亲的公共方法
 9.public Method[] methods = c.getDeclaredMethods();  获取自己的所有的方法
 10.public Method getMethod(String name,Class<?>... parameterTypes)第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
Constructor类中的方法
 1.public T newInstance(Object... initargs)
 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
 2. （父类中的方法） void setAccessible(boolean flag)：将此对象的 accessible 标志设置为指示的布尔值。
Field类中的方法
 1.public  void set(Object obj, Object value)  // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
Method类中的方法
 1.public Object invoke(Object obj,Object... args)返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
案例一：获取Class文件对象的三种方式

public class ReflectDemoOne {
 public static void main(String[] args) throws ClassNotFoundException {
  Person p = new Person();
  // 方式1
  Class c1 = p.getClass();
  // 方式2
  Class c2 = Person.class;
  // 方式3
  Class c3 = Class.forName("cn.itcast.Person");
 }
}
public class Person{
 ...标准Person类
}

案例二：通过反射获取构空造方法并使用

<pre class="java" name="code">public class ReflectDemoTwo {
 public static void main(String[] args) throws Exception {
  // 获取字节码文件对象
  Class c = Class.forName("cn.itcast.Person");
  //获取构造方法
  Constructor[] conPublic =c.getConstructors()://所有公共构造方
  for (Constructor con : conPublic) {
    System.out.println(con);
   }
  Constructor[] conAll = c.getDeclaredConstructors()://所有构造方法
  for (Constructor con : conAll) {
    System.out.println(con);
   }
  Constructor con = c.getConstrutor();//返回的是单个空参数的构造方法对象
  Object obj = con.newInstance();//创建该构造方法的声明类的新实例
  System.out.println(obj);
 }
}
public class Person{
 ...标准Person类
}

案例三：通过反射获取代餐构造方法并使用

<pre class="java" name="code">public class ReflectDemoThree {
 public static void main(String[] args) throws Exception {
  // 获取字节码文件对象
  Class c = Class.forName("cn.itcast.Person");
  // 获取带参构造方法对象
  Constructor con = c.getConstructor(String.class, int.class);
  // 通过带参构造方法对象创建对象
  Object obj = con.newInstance("赵云", 27);
  System.out.println(obj);
 }
}
public class Person{
 ...标准Person类
}

案例四：通过反射获取私有带参构造方法并使用

<pre class="java" name="code">public class ReflectDemoFour {
 public static void main(String[] args) throws Exception {
  // 获取字节码文件对象
  Class c = Class.forName("cn.itcast.Person");
  // 获取私有带参构造方法对象
  Constructor con = c.getDeclaredConstructor(String.class);
  // 用该私有构造方法创建对象
  con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
  Object obj = con.newInstance("张飞");
  System.out.println(obj);
 }
}
public class Person{
 ...标准Person类
}

案例五：通过反射获取成员变量并使用

<pre class="java" name="code">public class ReflectDemoFive {
 public static void main(String[] args) throws Exception {
  // 获取字节码文件对象
  Class c = Class.forName("cn.itcast.Person");
  // 获取所有的成员变量
  Field[] fieldPublic = c.getFields();
  for (Field field : fieldPublic) {
  System.out.println(field);
  }
  Field[] fieldAll = c.getDeclaredFields();
  for (Field field : fieldAll) {
  System.out.prlintln(field);
  }
  // 通过无参构造方法创建对象
  Constructor con = c.getConstructor();
  Object obj = con.newInstance();
  System.out.println(obj);
  // 获取单个的成员变
  Field addressField = c.getField("address");
  addressField.set(ojb,"重庆");//给obj对象的addressField字段设置值为"重庆"
  // 获取name并对其赋值(可访问设置为true)
  Field nameField = c.getDeclaredField("name");
  nameField.setAccessible(true);
  nameField.set(obj, "马超");
  System.out.println(obj);
  // 获取age并对其赋值(可访问设置为true)
  Field nameField = c.getDeclaredField("age");
  nameField.setAccessible(true);
  nameField.set(obj, 30);
  System.out.println(obj);
 }
}
public class Person{
 ...标准Person类
}

案例六：通过反射获取成员方法并使用

<pre class="java" name="code">public class ReflectDemoSix {
 public static void main(String[] args) throws Exception {
  // 获取字节码文件对象
  Class c = Class.forName("cn.itcast.Person");
  // 获取所有的方法
  Method[] methodPublic = c.getMethods(); // 获取自己的包括父亲的公共方法
  for (Method method : methodPublic) {
  System.out.println(method);
  }
  Method[] methodAll = c.getDeclaredMethods(); // 获取自己的所有的方法
  for (Method method : methodAll) {
  System.out.println(method);
  }
  // 通过无参构造方法创建对象
  Constructor con = c.getConstructor();
  Object obj = con.newInstance();
  System.out.println(obj);
  // 获取单个方法并使用
  Method m1 = c.getMethod("show");
  m1.invoke(obj); // 调用obj对象的m1方法
  // 获取单个有参数的方法并使用
  Method m2 = c.getMethod("method", String.class);
  m2.invoke(obj, "hello");
  // 获取单个有参数的有返回值的方法并使用
  Method m3 = c.getMethod("getString", String.class, int.class);
  Object objString = m3.invoke(obj, "hello", 100);
  System.out.println(objString);
  // 获取单个私有的方法并使用
  Method m4 = c.getDeclaredMethod("function");
  m4.setAccessible(true);
  m4.invoke(obj);
 }
}
public class Person{
 ...标准Person类
}

案例七：我给你ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据

<pre class="java" name="code">public class ArrayListDemo {
 public static void main(String[] args) throws Exception {
  // 创建集合对象
  ArrayList<Integer> array = new ArrayList<Integer>();
  Class c = array.getClass(); // 集合ArrayList的class文件对象
  Method m = c.getMethod("add", Object.class);//获取集合ArrayList的add方法对象
  m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
  System.out.println(array);
 }
}