1.反射机制
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制（注意关键词：运行状态）。
也就是说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

反射机制主要提供的功能：
①在运行时判断任意一个对象所属的类；
②在运行时构造任意一个类的对象；
③在运行时判断任意一个类所具有的成员变量和方法；
④在运行时调用任意一个对象的方法；

2.Class介绍：
Class 类十分特殊，它没有共有的构造方法被jvm调用的（简单的理解：new对象或者被类加载器加载的时候），在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。

java中的Class三种获取方式：
①利用对象调用getClass()方法获取该对象的Class实例；
②使用Class类的静态方法forName()，用类的名字获取一个Class实例 ；
③运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的Class实例；
说明：在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象。
//方式一
Person person = new Person();
Class<? extends Person> personClazz01 = person.getClass();
//方式二
try {
Class<?> personClazz02 = Class.forName(“Person”);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//方式三
Class<? extends Person> personClazz03 = Person.class;

java中的Class中一些重要的方法:
①public Annotation[] getAnnotations () 获取这个类中所有注解
②getClassLoader() 获取加载这个类的类加载器
③getDeclaredMethods() 获取这个类中的所有方法
④getReturnType() 获取方法的返回类型
⑤getParameterTypes() 获取方法的传入参数类型
⑥isAnnotation() 测试这类是否是一个注解类
⑦getDeclaredConstructors() 获取所有的构造方法
⑧getDeclaredMethod(String name, Class… parameterTypes) 获取指定的构造方法（参数：参数类型.class）
⑨getSuperclass() 获取这个类的父类
⑩getInterfaces() 获取这个类实现的所有接口
⑩getFields() 获取这个类中所有被public修饰的成员变量
⑩getField(String name) 获取指定名字的被public修饰的成员变量
⑩newInstance() 返回此Class所表示的类，通过调用默认的（即无参数）构造函数创建的一个新实例

3.通过反射获取私有成员变量和私有方法
Person类：
public class Person {
private String name = “zhangsan”;
private String age;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

Person person = new Person();
//打印没有改变属性之前的name值
System.out.println(“before：” + getPrivateValue(person, “name”));
person.setName(“lisi”);
//打印修改之后的name值
System.out.println(“after：” + getPrivateValue(person, “name”));

//通过反射获取私有的成员变量
private Object getPrivateValue(Person person, String fieldName) {
try {
Field field = person.getClass().getDeclaredField(fieldName);
// 参数值为true，打开禁用访问控制检查
//setAccessible(true) 并不是将方法的访问权限改成了public，而是取消java的权限控制检查。所以即使是public方法，其accessible 属相默认也是false
field.setAccessible(true);
return field.get(person);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
运行结果：

4.举例演示反射
Person类：
public class Person {
private int age;
private String name;
public Person(){
}
public Person(int age, String name){
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

SuperPerson类:
public class SuperPerson extends Person implements Smoke.Smoking{
private boolean isMan;
public void fly(){
System.out.println(“走你~~”);
}
public boolean isMan() {
return isMan;
}
public void setMan(boolean iaMan) {
isMan = iaMan;
}
@Override
public void smoke(int count) {
}
}

Smoke接口类:
public class Smoke {
public interface Smoking {
public void smoke(int count);
}
}

MainActivity类:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Tests();
}

private void Tests() {
try {
//通过Java反射机制得到类的包名和类名
Test1();
System.out.println("");
//验证所有的类都是Class类的实例对象
Test2();
System.out.println("=");
//通过Java反射机制，用Class 创建类对象[这也就是反射存在的意义所在]，无参构造
Test3();
System.out.println("=");
//通过Java反射机制得到一个类的构造函数，并实现构造带参实例对象
Test4();
System.out.println("=");
//通过Java反射机制操作成员变量, set 和 get
Test5();
System.out.println("=");
//通过Java反射机制得到类的一些属性： 继承的接口，父类，函数信息，成员信息，类型等
Test6();
System.out.println("=");
//通过Java反射机制调用类中方法
Test7();
System.out.println("=");
//通过Java反射机制获得类加载器
Test8();
System.out.println("====");
} catch (Exception e) {
e.printStackTrace();
}
}

/**

• Demo1: 通过Java反射机制得到类的包名和类名
  */
  public static void Test1() {
  Person person = new Person();
  System.out.println("Test1: 包名: " + person.getClass().getPackage().getName() + “，” + "完整类名: " + person.getClass().getName());
  }

/**

• Demo2: 验证所有的类都是Class类的实例对象
  */
  public static void Test2() throws ClassNotFoundException {
  //定义两个类型都未知的Class , 设置初值为null, 看看如何给它们赋值成Person类
  Class<?> class1 = null;
  Class<?> class2 = null;

  //写法1, 可能抛出 ClassNotFoundException [多用这个写法]
  class1 = Class.forName(“com.tuba.yuanyc.audiomanagerdemo.Person”);
  System.out.println("Test2:(写法1) 包名: " + class1.getPackage().getName() + “，” + "完整类名: " + class1.getName());

  //写法2
  class2 = Person.class;
  System.out.println("Test2:(写法2) 包名: " + class2.getPackage().getName() + “，” + "完整类名: " + class2.getName());
  }

/**

• Demo3: 通过Java反射机制，用Class 创建类对象[这也就是反射存在的意义所在]
  */
  public static void Test3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  Class<?> class1 = null;
  class1 = Class.forName(“com.android.reflect.Person”);
  //由于这里不能带参数，所以你要实例化的这个类Person，一定要有无参构造函数
  Person person = (Person) class1.newInstance();
  person.setAge(26);
  person.setName(“kaiven”);
  System.out.println("Test3: " + person.getName() + " : " + person.getAge());
  }

/**
*Demo4: 通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象
*/
public static void Test4() throws ClassNotFoundException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
Class<?> class1 = null;
Person person1 = null;
Person person2 = null;

class1 = Class.forName(“com.android.reflect.Person”);
//得到一系列构造函数集合
Constructor<?>[] constructors = class1.getConstructors();

try {
person1 = (Person) constructors[0].newInstance();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
person1.setAge(28);
person1.setName(“zhuk”);

person2 = (Person) constructors[1].newInstance(29, “zhuk”);

System.out.println("Test4: " + person1.getName() + " : " + person1.getAge() + " , " + person2.getName() + " : " + person2.getAge());
}

/**

• Demo5: 通过Java反射机制操作成员变量, set 和 get
  */
  public static void Test5() throws IllegalArgumentException, IllegalAccessException, SecurityException, NoSuchFieldException, InstantiationException, ClassNotFoundException {
  Class<?> class1 = null;
  class1 = Class.forName(“com.android.reflect.Person”);
  Object obj = class1.newInstance();

  Field nameField = class1.getDeclaredField(“name”);
  nameField.setAccessible(true);
  nameField.set(obj, “cyy”);

  System.out.println(“Test5: 修改属性之后得到属性变量的值：” + nameField.get(obj));
  }

/**

• Demo6: 通过Java反射机制得到类的一些属性： 继承的接口，父类，函数信息，成员信息，类型等
  */
  public static void Test6() throws ClassNotFoundException {
  Class<?> class1 = null;
  class1 = Class.forName(“com.android.reflect.Person”);

  //取得父类名称
  Class<?> superClass = class1.getSuperclass();
  System.out.println(“Test6: SuperMan类的父类名: " + superClass.getName());
  System.out.println(”");
  Field[] fields = class1.getDeclaredFields();
  for (int i = 0; i < fields.length; i++) {
  System.out.println(“类中的成员: " + fields[i]);
  }
  System.out.println(”=");
  //取得类方法
  Method[] methods = class1.getDeclaredMethods();
  for (int i = 0; i < methods.length; i++) {
  System.out.println(“Test6,取得SuperMan类的方法：”);
  System.out.println(“函数名：” + methods[i].getName());
  System.out.println(“函数返回类型：” + methods[i].getReturnType());
  System.out.println(“函数访问修饰符：” + Modifier.toString(methods[i].getModifiers()));
  System.out.println(“函数代码写法： " + methods[i]);
  }
  System.out.println(”======");
  Class<?> interfaces[] = class1.getInterfaces();
  for (int i = 0; i < interfaces.length; i++) {
  System.out.println("实现的接口类名: " + interfaces[i].getName());
  }
  }

/**

• Demo7: 通过Java反射机制调用类方法
  */
  public static void Test7() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException {
  Class<?> class1 = null;
  class1 = Class.forName(“com.android.reflect.SuperPerson”);

  System.out.println(“Test7: \n调用无参方法fly()：”);
  Method method = class1.getMethod(“fly”);
  method.invoke(class1.newInstance());

  System.out.println(“调用有参方法smoke(int m)：”);
  method = class1.getMethod(“smoke”, int.class);
  method.invoke(class1.newInstance(), 100);
  }

/**

• Demo8: 通过Java反射机制得到类加载器信息

• 在java中有三种类类加载器。

• 1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。

• 2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类

• 3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。

• @throws ClassNotFoundException
  */
  public static void Test8() throws ClassNotFoundException {
  Class<?> class1 = null;
  class1 = Class.forName(“com.android.reflect.SuperPerson”);
  String name = class1.getClassLoader().getClass().getName();

  System.out.println("Test8: 类加载器类名: " + name);
  }
  }