学到spring框架的时候，发现反射思想很重要，故特此写下此文，以加深理解。

文章目录

• 1：反射概述
• 2：Class对象特点
• 3：反射的使用
• * 1:获取类对象
  • 2 利用反射机制创建对象
  • 3: 获取成员变量并使用
  • 4: 获取成员方法并使用
  • 5: 获取main方法并使用
• 4 : 关于反射的用法举例
• * 1:通过反射运行配置文件内容
  • 2:通过反射越过泛型检查

1：反射概述

  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
  实际上，我们创建的每一个类也都是对象，即类本身是java.lang.Class类的实例对象。这个实例对象称之为类对象，也就是Class对象。那么，Class对象又是什么对象呢？

2：Class对象特点

  下图是Class类的api（图片来自于Java基础之—反射（非常重要））

   从图中可以得出以下几点：

1. Class 类的实例对象表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有很多的实例，每个类都有唯一的Class对象。
2. Class 类没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机自动构造的。也就是说我们不需要创建，JVM已经帮我们创建了。
3. Class 对象用于提供类本身的信息，比如有几种构造方法， 有多少属性，有哪些普通方法

3：反射的使用

  假设我们现在有一个Hero类

package pojo;
public class Hero {
    public String name; //姓名
    public float hp; //血量
    public float armor; //护甲
    public int moveSpeed; //移动速度
}

1:获取类对象

获取类对象有3种方式

1. Class.forName（）（常用）
2. Hero.class
3. new Hero().getClass()

在一个JVM中，一种类，只会有一个类对象存在。所以以上三种方式取出来的类对象，都是一样。（此处准确是在ClassLoader下,只有一个类对象）

示例：

package pojo;
public class ObjectTest {

    public static void main(String[] args) {
        String className = "pogo.Hero";
        try {
            //获取类对象的第一种方式
            Class pClass1 = Class.forName(className);
            //获取类对象的第二种方式
            Class pClass2 = Hero.class;
            //获取类对象的第三种方式
            Class pClass3 = new Hero().getClass();
            System.out.println(pClass1==pClass2);//输出true
            System.out.println(pClass1==pClass3);//输出true
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 }
}

  三种方式中，常用第一种，第二种需要导入类的包，依赖太强，不导包就抛编译错误。第三种对象都有了还要反射干什么。一般都第一种，一个字符串可以传入也可写在配置文件中等多种方法。

2 利用反射机制创建对象

基本步骤
  与传统的通过new 来获取对象的方式不同反射机制，反射会先拿到Hero的“类对象”,然后通过类对象获取“构造器对象”再通过构造器对象创建一个对象，具体步骤：

1.获取类对象 Class class = Class.forName("pojo.Hero");
2.获取构造器对象 Constructor con = clazz.getConstructor(形参.class);
3 获取对象 Hero hero =con.newInstance(实参);

上面是最简单的获取方法，当Hero的构造方法不是无参构造方法时，获取构造器对象略有不同，见下面测试：

构造方法不同时，获取构造器对象的方法

示例：

1. Hero类添加6种构造方法

   //---------------构造方法-------------------
   //（默认的构造方法）
   Hero(String str){
   System.out.println("(默认)的构造方法 s = " + str);
   }

   //无参构造方法
   public Hero(){
       System.out.println("调用了公有、无参构造方法执行了。。。");
   }
   
   //有一个参数的构造方法
   public Hero(char name){
       System.out.println("姓名：" + name);
   }
   
   //有多个参数的构造方法
   public Hero(String name ,float hp){
       System.out.println("姓名："+name+"血量："+ hp);
   }
   
   //受保护的构造方法
   protected Hero(boolean n){
       System.out.println("受保护的构造方法 n = " + n);
   }
   
   //私有构造方法
   private Hero(float hp){
       System.out.println("私有的构造方法   血量："+ hp);
   }

2. 通过反射机制获取对象

   package test;
   public class ConstructorTest {

   /*
    * 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
    * 
    * 1.获取构造方法：
    *      1).批量的方法：
    *          public Constructor[] getConstructors()：所有"公有的"构造方法
               public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
   
    *      2).获取单个的方法，并调用：
    *          public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
    *          public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
    *      
    * 2.创建对象
    *      Constructor对象调用newInstance(Object... initargs)
    */
   
   
   public static void main(String[] args) throws Exception {
       //1.加载Class对象
       Class clazz = Class.forName("pojo.Hero");
   //2.获取所有公有构造方法
   System.out.println("**********************所有公有构造方法*********************************");
   Constructor[] conArray = clazz.getConstructors();
   for(Constructor c : conArray){
       System.out.println(c);
   }
   
   
   System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
   conArray = clazz.getDeclaredConstructors();
   for(Constructor c : conArray){
       System.out.println(c);
   }
   
   System.out.println("*****************获取公有、无参的构造方法*******************************");
   Constructor con = clazz.getConstructor(null);
   //1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
   //2>、返回的是描述这个无参构造函数的类对象。
   System.out.println("con = " + con);
   //调用构造方法
   Object obj = con.newInstance();
   
   
   System.out.println("******************获取私有构造方法，并调用*******************************");
   con = clazz.getDeclaredConstructor(float.class);
   System.out.println(con);
   //调用构造方法
   con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
   obj = con.newInstance(100);
   }

   }

输出：

**********************所有公有构造方法*********************************
public pojo.Hero(java.lang.String,float)
public pojo.Hero(char)
public pojo.Hero()
************所有的构造方法(包括：私有、受保护、默认、公有)***************
private pojo.Hero(float)
protected pojo.Hero(boolean)
public pojo.Hero(java.lang.String,float)
public pojo.Hero(char)
public pojo.Hero()
pojo.Hero(java.lang.String)
*****************获取公有、无参的构造方法*******************************
con = public pojo.Hero()
调用了公有、无参构造方法执行了。。。
******************获取私有构造方法，并调用*******************************
private pojo.Hero(float)
私有的构造方法   血量：100.0

总结：

1.获取构造器对象方法：
  1).批量的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
  2).获取单个的方法:
public Constructor getConstructor(Class… parameterTypes): 获取单个的"公有的"构造方法
public Constructor getDeclaredConstructor(Class…parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；

3: 获取成员变量并使用

基本步骤

1.获取HeroPlus类的对象 new方法/第2章中的方法 h
2. 获取属性 Field f1 = h.getDeclaredField("属性名")
3. 修改属性 f1.set(h，实参)，注意这里的h是对象，不是类对象

示例：

1. 新增HeroPlus类

   package pojo;
   public class HeroPlus {
   public String name;
   public float hp;
   public int damage;
   public int id;

   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }
   public HeroPlus(){
   
   }
   public HeroPlus(String string) {
       name =string;
   }
   
   @Override
   public String toString() {
       return "Hero [name=" + name + "]";
   }
   public boolean isDead() {
       // TODO Auto-generated method stub
       return false;
   }
   public void attackHero(HeroPlus h2) {
       System.out.println(this.name+ " 正在攻击 " + h2.getName());
   }

   }

2. 获取属性并修改

   package test;
   public class ParaTest {
   public static void main(String[] args) {
   HeroPlus h =new HeroPlus();
   //使用传统方式修改name的值为garen
   h.name = "garen";

        try {
            //获取类HeroPlus的名字叫做name的字段
            Field f1= h.getClass().getDeclaredField("name");
            //修改这个字段的值
            f1.set(h, "teemo");
            //打印被修改后的值
            System.out.println(h.name);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }</code></pre>
   }
   
   }

package test;
public class MethodTest {
    public static void main(String[] args) {

     HeroPlus h = new HeroPlus();

     try {
         // 获取这个名字叫做setName，参数类型是String的方法
         Method m = h.getClass().getMethod("setName", String.class);
         // 对h对象，调用这个方法
         m.invoke(h, "盖伦");
         // 使用传统的方式，调用getName方法
         System.out.println(h.getName());

     } catch (Exception e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }

 }
}

class=reflection.Service1
method=doService1

package service;
public class ReflectTest {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) throws Exception {

        //从spring.txt中获取类名称和方法名称
        File springConfigFile = new File("H:\\eclpise-workspace\\reflect-demo\\src\\spring.txt");
        Properties springConfig= new Properties();
        springConfig.load(new FileInputStream(springConfigFile));
        String className = (String) springConfig.get("class");
        String methodName = (String) springConfig.get("method");

        //根据类名称获取类对象
        Class clazz = Class.forName(className);
        //根据方法名称，获取方法对象
        Method m = clazz.getMethod(methodName);
        //获取构造器
        Constructor c = clazz.getConstructor();
        //根据构造器，实例化出对象
        Object service = c.newInstance();
        //调用对象的指定方法
        m.invoke(service);

    }
}

package test;
public class GenericityTest {
    public static void main(String[] args) throws Exception{

    ArrayList<String> list = new ArrayList<>();
    list.add("this");
    list.add("is");

    //  strList.add(5);报错

    /********** 越过泛型检查    **************/

    //获取ArrayList的Class对象，反向的调用add()方法，添加数据
    Class listClass = list.getClass(); 
    //获取add()方法
    Method m = listClass.getMethod("add", Object.class);
    //调用add()方法
    m.invoke(list, 5);

    //遍历集合
    for(Object obj : list){
        System.out.println(obj);
        }
    }

}