胖哥说反射 上卷

我来学习反射

1.为什么我们要学习反射？

通过反射机制可以获取到一个类的完整信息，例如：所有（包含private修饰）属性和方法，包信息等。

换句话说，Class本身表示一个类的本身，通过Class可以完整获取一个类中的完整结构，包含此类中的方法定义，属性定义等。

反射就是把Java类中的各种成分映射成一个个的Java对象

例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。

2.反射的核心是什么？

我个人认为：一切的操作都是讲使用Object完成，类或者数组的引用是可以用Object进行接收。

也就是我们之前说Java中的我认为很重要的多态，对象的多态：Object object= 任何引用类型的实例对象

3.类的加载过程

类的正常加载过程：反射的原理在与Class对象

Class对象的由来是将class文件读入内存，并为之创建一个Class对象，那么Class对象在反射中起到什么作用？

我们用图片已经说明了很清楚了，我们在来看一下官方的解释

For every type of object, the Java virtual machine instantiates an immutable instance of java.lang.Class which provides methods to examine the runtime properties of the object including its members and type information. Class also provides the ability to create new classes and objects. Most importantly, it is the entry point for all of the Reflection APIs.

对于每一种类，Java虚拟机都会初始化出一个Class类型的实例，每当我们编写并且编译一个新创建的类就会产生一个对应Class对象，并且这个Class对象会被保存在同名.class文件里。当我们new一个新对象或者引用静态成员变量时，Java虚拟机(JVM)中的类加载器系统会将对应Class对象加载到JVM中，然后JVM再根据这个类型信息相关的Class对象创建我们需要实例对象或者提供静态变量的引用值。

如上图所示，比如创建编译一个Student类，那么，JVM就会创建一个Student对应Class类的Class实例，该Class实例保存了Student类相关的类型信息，包括属性，方法，构造方法等等，通过这个Class实例可以在运行时访问Student对象的属性和方法等。另外通过Class类还可以创建出一个新的Student对象。这就是反射能够实现的原因，可以说Class是反射操作的基础。

需要特别注意的是，每个class（注意class是小写，代表普通类）类，无论创建多少个实例对象，在JVM中都对应同一个Class对象。

4.Class API简要说明

跟我们之前学习查看Math、String类一样的过程

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是JVM中有N多的实例每个类都有该Class对象。（包括基本数据类型）

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

没有公共的构造方法，方法共有64个太多了。下面用到哪个就详解哪个吧

5.反射的使用

Java 提供反射机制，依赖于 Class 类和 java.lang.reflect 类库。其主要的类如下：

1. Class：表示类或者接口
2. Field：表示类中的成员变量
3. Method：表示类中的方法
4. Constructor：表示类的构造方法
5. Array：该类提供了动态创建数组和访问数组元素的静态方法

先自己设置一个Student类来完成对应的测试，代码如下：

package com.pangsir.model;

public class Student {
    public int no;
    public String sex;

    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    /*
     * 构造方法
     */
    
   Student(String str){  
       System.out.println("(默认)的构造方法 s = " + str);  
   }  
     
   //无参构造方法  
   public Student(){  
       System.out.println("调用了公有、无参构造方法执行了。。。");  
   }  
     
   //有一个参数的构造方法  
   protected Student(char name){  
       System.out.println("姓名：" + name);  
   }  
     
   //有多个参数的构造方法  
   public Student(String name ,int age){  
       System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。  
   }  
     
   //私有构造方法  
   private Student(int age){  
       System.out.println("私有的构造方法   年龄："+ age);  
   }
    
}

5.1 获取Class对象的三种方式

说Class是反射能够实现的基础的另一个原因是：Java反射包java.lang.reflect中的所有类都没有public构造方法，要想获得这些类实例，只能通过Class类获取。所以说如果想使用反射，必须得获得Class对象。

/*
 * Constructor. Only the Java Virtual Machine creates Class
 * objects.
 */
private Class() {}

• Object.getClass() 方法(对象.getClass())

  如果我们有一个类的对象，那么我们可以通过 Object.getClass 方法获得该类的 Class 对象。

  // String 对象的 getClass 方法
  Class clazz1 = "hello".getClass();
  // 数组对象的 getClass 方法
  Class clazz2 = (new byte[1024]).getClass();
  System.out.println(class2) // 会输出 [B, [ 代表是数组， B 代表是 byte。即 byte 数组的类类型
  

  然而对于基本类型无法使用这种方法:

  boolean b;
  Class c = b.getClass();   // compile-time error

• class 语法

  任何数据类型（包括基本数据类型）都有一个“静态”的class属性，若我们知道要获取的类类型的名称时，我们可以使用 class 语法获取该类类型的对象

  // 类
  Class clazz = Integer.class;
  // 数组
  Class clazz2 = int [][].class;

  • 包装类的 TYPE 静态属性

    对于基本类型和 void 都有对应的包装类。在包装类中有一个静态属性 TYPE，保存了该来的类类型。以 Integer 类为例，其源码中定义了如下的静态属性：

    
    @SuppressWarnings("unchecked")
    public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

    生成 Class 类实例的方法：

    Class clazz1 = Integer.TYPE;
    Class clazz2 = Void.TYPE;

• Class.forName() 方法

  通过Class类的静态方法：forName（String className）(常用)

  可以通过 Class 的 forName 方法获取 Class 实例，其中类的名称要写类的完整路径。

  该方法只能用于获取引用类型的类类型对象。

  // 这种方式会使用当前的类的加载器加载，并且会将 Class 类实例初始化
  Class<?> clazz = Class.forName("java.lang.String");
  // 上面的调用方式等价于
  Class<?> clazz = Class.forName("java.lang.String", true, currentLoader);

  对于数组比较特殊:

  Class cDoubleArray = Class.forName("[D");    //相当于double[].class
  
  Class cStringArray = Class.forName("[[Ljava.lang.String;");   //相当于String[][].class

  使用该方法可能会抛出 ClassNotFoundException 异常，这个异常发生在类的加载阶段，原因如下：

  • 类加载器在类路径中没有找到该类（检查：查看所在加载的类以及其所依赖的包是否在类路径下）
  • 该类已经被某个类加载器加载到 JVM 内存中，另外一个类加载器又尝试从同一个包中加载

5.2 Student类获取Class

package com.pangsir;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Student student = new Student();
        
        /*
         * JAVA反射--获取Class对象的三种方式
         */
        
        // 通过对象名.getClass()方法获取
        Class stuClass = student.getClass();
        System.out.println("stuClass is "+stuClass.getName());        
        
        // 通过类名.class方式获得
        Class stuClass1 = Student.class;
        System.out.println("stuClass1 is "+stuClass1.getName());
        System.out.println(stuClass == stuClass1);
        
        // 通过Class.forName()方法获得
        Class stuClass2 = Class.forName("com.pangsir.model.Student");
        System.out.println("stuClass2 is "+stuClass2);
        System.out.println(stuClass1 == stuClass2);
    }
}

Output:
stuClass is com.pangsir.model.Student
stuClass1 is com.pangsir.model.Student
true
stuClass2 is class com.pangsir.model.Student
true

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

5.3 Member & AccessibleObject

在讲 Field、Method、Constructor 之前，先说说 Member 和 AccessibleObject。Member 是一个接口，表示 Class 的成员，前面的三个类都是其实现类。
AccessibleObject 是 Field、Method、Constructor 三个类共同继承的父类，它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。通过 setAccessible 方法可以忽略访问级别，从而访问对应的内容。并且 AccessibleObject 实现了 AnnotatedElement 接口，提供了与获取注解相关的能力。

5.4 获取构造方法

Constructor 提供了有关类的构造方法的信息，以及对它的动态访问的能力。

可以通过 Class 提供的方法，获取 Constructor 对象，具体如下：

方法返回值	方法名称	方法说明
Constructor<T>	getConstructor(Class<?>... parameterTypes)	返回指定参数类型、具有public访问权限的构造函数对象
Constructor<?>[]	getConstructors()	返回所有具有public访问权限的构造函数的Constructor对象数组
Constructor<T>	getDeclaredConstructor(Class<?>... parameterTypes)	返回指定参数类型、所有声明的（包括private）构造函数对象
Constructor<?>[]	getDeclaredConstructor()	返回所有声明的（包括private）构造函数对象

package com.pangsir.test;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {

        // 通过Class.forName()方法获得Class对象
        Class stuClass = Class.forName("com.pangsir.model.Student");
        
        
        System.out.println("************返回所有public构造方法************");
        Constructor[] constructors = stuClass.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        /*
         * Output:
         * ************返回所有public构造方法************
         *    public com.pangsir.model.Student()
         *    public com.pangsir.model.Student(java.lang.String,int)
         */
    
        System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");  
        Constructor[] constructors2 = stuClass.getDeclaredConstructors();
        for (Constructor constructor : constructors2) {
            System.out.println(constructor);
        }
        /*
         * Output:
         * ************所有的构造方法(包括：私有、受保护、默认、公有)***************
         *    private com.pangsir.model.Student(int)
         *    public com.pangsir.model.Student()
         *    protected com.pangsir.model.Student(char)
         *    public com.pangsir.model.Student(java.lang.String,int)
         *    com.pangsir.model.Student(java.lang.String)
         */
        
        
        Constructor constructor;

        System.out.println("************返回指定类型的 public构造器************");
        try {
            constructor = stuClass.getConstructor(String.class, int.class);
            System.out.println(constructor);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        /*
         * Output：
         * ************返回指定类型的 public构造器************
         * public com.pangsir.model.Student(java.lang.String,int)
         * 
         * 如果指定参数的构造器是非public类型的 则抛出java.lang.NoSuchMethodException异常
         */
          
        System.out.println("************返回指定类型的构造器************");
        try { 
            constructor = stuClass.getDeclaredConstructor(int.class);
            System.out.println(constructor);            // char.class
        } catch (NoSuchMethodException e) {             // String.class, int.class
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        /*
         * Output:
         * ************返回指定类型的构造器************
         * public com.pangsir.model.Student(java.lang.String,int)
         * protected com.pangsir.model.Student(char)
         * private com.pangsir.model.Student(int)
         */
        System.out.println("********获取私有构造方法，并调用**********");  
        constructor = clazz.getDeclaredConstructor(char.class);  
        System.out.println(con);  
        //调用构造方法  
        con.setAccessible(true);//暴力访问(忽略掉访问修饰符)  
        obj = con.newInstance('男');  
         /*
         * Output:
         * ************返回指定类型的构造器************
         * public com.pangsir.model.Student(char)  
         * 姓名：男 
         */
    }
}

5.5 获取变量

Field 提供了有关类或接口的单个属性的信息，以及对它的动态访问的能力。

可以通过 Class 提供的方法，获取 Field 对象，具体如下：

方法返回值	方法名称	方法说明
Field	getDeclaredField(String name)	获取指定name名称的(包含private修饰的)字段，不包括继承的字段
Field[]	getDeclaredField()	获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段
Field	getField(String name)	获取指定name名称、具有public修饰的字段，包含继承字段
Field[]	getField()	获取修饰符为public的字段，包含继承字段

public class Student {  
    public Student(){  
          
    }  
    //**********字段*************//  
    public String name;  
    protected int age;  
    char sex;  
    private String phoneNum;  
      
    @Override  
    public String toString() {  
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex  
                + ", phoneNum=" + phoneNum + "]";  
    }  
      
      
}

测试类

package com.pangsir.field;  
import java.lang.reflect.Field;  
/* 
 * 获取成员变量并调用： 
 *  
 * 1.批量的 
 *      1).Field[] getFields():获取所有的"公有字段" 
 *      2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有； 
 * 2.获取单个的： 
 *      1).public Field getField(String fieldName):获取某个"公有的"字段； 
 *      2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的) 
 *  
 *   设置字段的值： 
 *      Field --> public void set(Object obj,Object value): 
 *                  参数说明： 
 *                  1.obj:要设置的字段所在的对象； 
 *                  2.value:要为字段设置的值； 
 *  
 */  
public class Fields {  
  
        public static void main(String[] args) throws Exception {  
            //1.获取Class对象  
            Class stuClass = Class.forName("com.pangsir.model.Student");  
            //2.获取字段  
            System.out.println("************获取所有公有的字段********************");  
            Field[] fieldArray = stuClass.getFields();  
            for(Field f : fieldArray){  
                System.out.println(f);  
            }
            /*
             * Output:
             * ***********获取所有公有的字段********************  
             * public java.lang.String com.pangsir.model.Student.name  
             */
            
            System.out.println("******获取所有的字段(包括私有、受保护、默认的)***********");  
            fieldArray = stuClass.getDeclaredFields();  
            for(Field f : fieldArray){  
                System.out.println(f);  
            }  
             /*
             * Output:
             ************获取所有的字段(包括私有、受保护、默认的)********************  
             *  public java.lang.String com.pangsir.model.Student.name  
             *  protected int com.pangsir.model.Student.age  
             *  char com.pangsir.model.Student.sex  
             *  private java.lang.String com.pangsir.model.Student.phoneNum 
             */
            System.out.println("******获取公有字段并调用*********");  
            Field f = stuClass.getField("name");  
            System.out.println(f);  
            //获取一个对象  
            Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();  
            //为字段设置值  
            f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"  
            //验证  
            Student stu = (Student)obj;  
            System.out.println("验证姓名：" + stu.name);  
            /*
             * Output:
             *************获取公有字段**并调用***********************************  
             * public java.lang.String com.pangsir.model.Student.name  
             * 验证姓名：刘德华 
             */
              
            System.out.println("*****获取私有字段****并调用***************");  
            f = stuClass.getDeclaredField("phoneNum");  
            System.out.println(f);  
            f.setAccessible(true);//暴力反射，解除私有限定  
            f.set(obj, "12345768901");  
            System.out.println("验证电话：" + stu);  
            /*
             * Output:
             **************获取私有字段****并调用********************************  
             * private java.lang.String fanshe.field.Student.phoneNum  
             * 验证电话：Student [name=刘德华, age=0, sex= ,  phoneNum=12345768901]
             */
              
        }  
    }

代码分析：调用字段时：需要传递两个参数：
Object obj = stuClass.getConstructor().newInstance();

//产生Student对象--》Student stu = new Student();

//为字段设置值
f.set(obj, "刘德华");

//为Student对象中的name属性赋值--》stu.name = "刘德华"
第一个参数：要传入设置的对象，第二个参数：要传入实参

5.6 获取方法

Method 提供了有关类或接口的单个方法的信息，以及对它的动态访问的能力。

可以通过 Class 提供的方法，获取 Field 对象，具体如下：

方法返回值	方法名称	方法说明
Method	getDeclaredMethod(String name, Class<?>... parameterTypes)	返回一个指定参数的Method对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[]	getDeclaredMethod()	返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
Method	getMethod(String name, Class<?>... parameterTypes)	返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[]	getMethods()	返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

Student类：

public class Student {  
    //**************成员方法***************//  
    public void show1(String s){  
        System.out.println("调用了：公有的，String参数的show1(): s = " + s);  
    }  
    protected void show2(){  
        System.out.println("调用了：受保护的，无参的show2()");  
    }  
    void show3(){  
        System.out.println("调用了：默认的，无参的show3()");  
    }  
    private String show4(int age){  
        System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);  
        return "abcd";  
    }  
} 

测试类：

package com.pangsir.method;  
  
import java.lang.reflect.Method;  
  
/* 
 * 获取成员方法并调用： 
 *  
 * 1.批量的： 
 *      public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类） 
 *      public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的) 
 * 2.获取单个的： 
 *      public Method getMethod(String name,Class<?>... parameterTypes): 
 *                  参数： 
 *                      name : 方法名； 
 *                      Class ... : 形参的Class类型对象 
 *      public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 
 *  
 *   调用方法： 
 *      Method --> public Object invoke(Object obj,Object... args): 
 *                  参数说明： 
 *                  obj : 要调用方法的对象； 
 *                  args:调用方式时所传递的实参； 
 
): 
 */  
public class MethodClass {  
  
    public static void main(String[] args) throws Exception {  
        //1.获取Class对象  
        Class stuClass = Class.forName("fanshe.method.Student");  
        //2.获取所有公有方法  
        System.out.println("***************获取所有的”公有“方法*******************");   
        Method[] methodArray = stuClass.getMethods();  
        for(Method m : methodArray){  
            System.out.println(m);  
        }
        /*
         * Output:
         ***************获取所有的”公有“方法*******************  
            public void com.pangsir.model.Student.show1(java.lang.String)  
            public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException  
            public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException  
            public final void java.lang.Object.wait() throws java.lang.InterruptedException  
            public boolean java.lang.Object.equals(java.lang.Object)  
            public java.lang.String java.lang.Object.toString()  
            public native int java.lang.Object.hashCode()  
            public final native java.lang.Class java.lang.Object.getClass()  
            public final native void java.lang.Object.notify()  
            public final native void java.lang.Object.notifyAll() 
         */
        System.out.println("***************获取所有的方法，包括私有的*******************");  
        methodArray = stuClass.getDeclaredMethods();  
        for(Method m : methodArray){  
            System.out.println(m);  
        }  
        /*
         * Output:
         ***************获取所有的方法，包括私有的*******************  
        public void om.pangsir.model.Student.show1(java.lang.String)  
        private java.lang.String om.pangsir.model.Student.show4(int)  
        protected void om.pangsir.model.Student.show2()  
        void om.pangsir.model.Student.show3()  
         */
        System.out.println("***************获取公有的show1()方法*******************");  
        Method m = stuClass.getMethod("show1", String.class);  
        System.out.println(m);  
        //实例化一个Student对象  
        Object obj = stuClass.getConstructor().newInstance();  
        m.invoke(obj, "刘德华");  
         /*
         * Output:
         ***************获取公有的show1()方法*******************  
        public void om.pangsir.model.Student.show1(java.lang.String)  
        调用了：公有的，String参数的show1(): s = 刘德华 
         */
          
        System.out.println("***************获取私有的show4()方法******************");  
        m = stuClass.getDeclaredMethod("show4", int.class);  
        System.out.println(m);  
        m.setAccessible(true);//解除私有限定  
        Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参  
        System.out.println("返回值：" + result);
        /*
         * Output:
         ***************获取私有的show4()方法******************  
        private java.lang.String om.pangsir.model.Student.show4(int)  
        调用了，私有的，并且有返回值的，int参数的show4(): age = 20  
        返回值：abcd 
         */
          
          
    }  
}  

代码分析：由此可见：
m = stuClass.getDeclaredMethod("show4", int.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);

5.7 反射main(主方法)

Student类

package com.pangsir.main;  
  
public class Student {  
  
    public static void main(String[] args) {  
        System.out.println("main方法执行了。。。");  
    }  
}

测试类：

package fanshe.main;  
  
import java.lang.reflect.Method;  
  
/** 
 * 获取Student类的main方法、不要与当前的main方法搞混了 
 */  
public class Main {  
      
    public static void main(String[] args) {  
        try {  
            //1、获取Student对象的字节码  
            Class clazz = Class.forName("fanshe.main.Student");  
              
            //2、获取main方法  
             Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，  
            //3、调用main方法  
            // methodMain.invoke(null, new String[]{"a","b","c"});  
             //第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数  
             //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。  
             methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一  
            // methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二  
              
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
          
          
    }  
}

5.8 通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的

import java.lang.reflect.Method;  
import java.util.ArrayList;  
 
/* 
* 通过反射越过泛型检查 
*  
* 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？ 
*/  
public class Demo {  
   public static void main(String[] args) throws Exception{  
       ArrayList<String> strList = new ArrayList<>();  
       strList.add("aaa");  
       strList.add("bbb");  
         
   //  strList.add(100);  
       //获取ArrayList的Class对象，反向的调用add()方法，添加数据  
       Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象  
       //获取add()方法  
       Method m = listClass.getMethod("add", Object.class);  
       //调用add()方法  
       m.invoke(strList, 100);  
         
       //遍历集合  
       for(Object obj : strList){  
           System.out.println(obj);
           System.out.println(obj.getClass());
       }  
        /*
         *Output:
         * aaa
         * class java.lang.String
         * bbb
         * class java.lang.String
         * 100
         * class java.lang.Integer
         */
   }  
}

5.9 通过反射运行配置文件内容

Student类

public class Student {  
    public void show(){  
        System.out.println("is show()");  
    }  
} 

配置文件以txt文件为例子（os.properties）：

className = com.pangsir.model.Student  
methodName = show 

测试类：

import java.io.FileNotFoundException;  
import java.io.FileReader;  
import java.io.IOException;  
import java.lang.reflect.Method;  
import java.util.Properties;  
  
/* 
 * 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改 
 * 我们只需要将新类发送给客户端，并修改配置文件即可 
 */  
public class Demo {  
    public static void main(String[] args) throws Exception {  
        //通过反射获取Class对象  
        Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"  
        //2获取show()方法  
        Method m = stuClass.getMethod(getValue("methodName"));//show  
        //3.调用show()方法  
        m.invoke(stuClass.getConstructor().newInstance());  
          
    }  
      
    //此方法接收一个key，在配置文件中获取相应的value  
    public static String getValue(String key) throws IOException{  
        Properties pro = new Properties();//获取配置文件的对象  
        FileReader in = new FileReader("os.properties");//获取输入流  
        pro.load(in);//将流加载到配置文件对象中  
        in.close();  
        return pro.getProperty(key);//返回根据key获取的value值  
    }  
}  
  /*
  *Output:
  * is show()
  */

需求：
当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动

Student2类：

public class Student2 {  
    public void show2(){  
        System.out.println("is show2()");  
    }  
} 

修改配置文件如下

className = com.pangsir.model.Student2  
methodName = show2  

5.10 利用ParameterizedType获取java泛型参数类

//超类
package test;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

@SuppressWarnings("unchecked")
public class Person<T> {
    private Class<T> clazz;
    public Person() {
        // 使用反射技术得到T的真实类型
        ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass(); // 获取当前new的对象的 泛型的父类 类型
        this.clazz = (Class<T>) pt.getActualTypeArguments()[0]; // 获取第一个类型参数的真实类型
        System.out.println("clazz ---> " + clazz);
    }

}
//子类
package test;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Student extends Person<Student> {
}
//测试类
package test;

public class TestGetClass {

    /**
     * @param args
     */
    public static void main(String[] args) {

          Student student = new Student();
    }

}

6.反射的缺点

没有任何一项技术是十全十美的，Java反射拥有强大功能的同时也带来了一些副作用。

• 性能开销
  反射涉及类型动态解析，所以JVM无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
• 安全限制
  使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如Applet，那么这就是个问题了。
• 内部曝光
  由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用－－代码有功能上的错误，降低可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。

使用反射的一个原则：如果使用常规方法能够实现，那么就不要用反射。