12 反射

12.1  反射的概念

12.1.1 反射机制

　　Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。简单的说反射就是动态获取类中信息，对类进行解刨。

　　理解反射首先要明确一个概念：那就是动态语言！因为我在学习时对“动态获取类中信息”很困惑。

　　动态语言：程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。

　　从这个观点出发Java语言不是动态语言，所以Java有了一个非常突出的动态相关机制--Reflection,可以在运行时加载，探知，使用编译时期完全未知的classes,也就是说Java可以加载一个运行时才知道名称的class。也就是说Java反射机制是在运行状态中，对于任意一个类（class文件<字节码文件>），都能知道这个类的属性和方法。对于任意一个对象，都能调用它的属性和方法。这种动态获取类的信息以及动态调用对象的方法的功能成为Java语言的反射机制。简单的说：反射就是把Java类中的各种成分映射成相应的java类。

12.1.2 反射的好处：

反射极大的增强了程序的扩展性。

12.1.3 反射是使用步骤

步骤：

1，获得Class对象，就是获得指定名称的字节码文件对象。

2，实例化对象，获类的属性，方法和构造函数。

3，调用构造函数创建对象，访问属性，调用方法。

12.2 Class类

1字节码

     当源程序中用到类时，首先要从硬盘把这个类的那些二进制代码，一个类编译成class文件放在硬盘上以后，就是一些二进制代码，要把这些二进制代码加载到内存中里面来，再用这些字节码去复制出一个一个对象来。

2 Class类的由来

　　所有的类文件都有共同属性，所以可以向上抽取，把这些共性内容封装成一个类，这个类就叫Class（描述字节码文件的对象）。Class类中包含属性有field（字段）、method（方法）、construction（构造函数）。要想对一个类进行内容的获取，必须要先获取该字节码文件的对象。该对象是Class类型。Class类描述的信息：类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表等。每一个字节码就是class的实例对象。如：classcls=Data.class;

3 Class和class的区别

        1）class：Java中的类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则由此类的实例对象确定，不同的实例对象有不同的属性值。

        2）Class：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类，这些类称为Class。例如人对应的是Person类，Java类对应的就是Class。Class是Java程序中各个Java类的总称；它是反射的基石，通过Class类来使用反射。

4 获取Class对象的三种方式

        加载XX.class文件进内存时就被封装成了对象，该对象就是字节码文件对象

1).通过对象的getClass方法进行获取。

        如：Class clazz=new Person().getClass();//Person是一个类名

        弊端：每次都需要具体的类和该类的对象，以及调用getClass方法。

2).任何数据类型都具备着一个静态的属性class，这个属性直接获取到该类型的对应 Class对象。

        如：Class clazz=Person.class;//Person是一个类名

        弊端：还是要使用具体的类，和该类中的一个静态属性class完成。

3). 这种方式较为简单，只要知道类的名称即可。不需要使用该类，也不需要去调用具 体的属性和行为。就可以获取到Class对象了。

        如：String className=”Person”;

Class clazz=Class.forName(className);//Person是一个类名

        这种方式仅知道类名就可以获取到该类字节码对象的方式，利于扩展。

package reflect;

public class Person {
    private String name;
    private int age;
    private String address;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age, String address) {
        super();
        this.name = name;
        this.age = age;
        this.address = address;
    }
    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;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
}

package reflect;
/*
 * 反射： 通过class文件的对象，获取构造函数、字段、方法的操作
 * 
 * 学习反射的目的：
 *         有些时候，可能JDK中的方法没有在帮助文档中提供，但是通过查看源代码，却发现有这个方法，不会该方法为private私有，所以JDK的帮助文档没有提供该方法
 *         如果，必须要用这个方法， 我们可以通过反射的方式来获取，进行使用
 * 
 * 构造函数： Constructor
 * 字段：Field
 * 方法：Method
 * 
 * 
 * 如何获取Person类的 字节码文件对象呢？
 * 方式1：  getClass(): 返回进行时的类
 * 方式2： 数据类型.class 静态属性，来获取当前数据类型的字节码文件对象
 * 方式3： public static Class forName(String className) 返回与带有给定字符串名的类或接口相关联的 Class 对象
 * 
 */
public class ReflectDemo {

    public static void main(String[] args) {
        //反射机制获取当前正在运行的类
//        getClassTest1();
        //反射机制获取当前正在运行类的字节码文件
        getClassTest2();
        getClassTest3();

    }
    //通过反射机制,获取当前正在运行的类的字节码文件的对象
    //方式一:对象.getClass()
    public static void getClassTest1(){    
        Person p1 = new Person();
        Person p2 = new Person();
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        if (p1==p2) {
            System.out.println("判断获取到的四个对象之间是否为一个对象:"+"p1和p2是一个对象,地址和内容都一致;");
        } else {
            System.out.println("判断获取到的四个对象之间是否为一个对象:"+"p1和p2不是一个对象,地址或内容不一致;");
        }
        if (c1==c2) {
            System.out.println("判断获取到的四个对象之间是否为一个对象:"+"c1和c2是一个对象,地址和内容都一致;");
        } else {
            System.out.println("判断获取到的四个对象之间是否为一个对象:"+"c1和c2不是一个对象,地址或内容不一致;");
        }
    }
    //通过反射机制,获取当前正在运行的类的字节码文件的对象
    //方式一:类名.class   静态属性，来获取当前数据类型的字节码文件对象
    public static void getClassTest2(){
        Class c1 = Person.class;
        Class c2 = Person.class;
        if(c1==c2){
            System.out.println("判断获取到的四个对象之间是否为一个对象:"+"c1和c2是一个对象,地址和内容都一致;");
        }else {
            System.out.println("判断获取到的四个对象之间是否为一个对象:"+"c1和c2不是一个对象,地址或内容不一致;");
        }
    }
    // 方式3： public static Class forName(String className)
    // 返回与带有给定字符串名的类或接口相关联的 Class 对象
    // className : 类的全路径名称 包名.类名
    public static void getClassTest3(){
        try {
            //注意如果不写全路径名,会出现ClassNotFound异常
            Class c1 = Class.forName("reflect.Person");
            Class c2 = Class.forName("reflect.Person");
            if(c1==c2){
                System.out.println("判断获取到的四个对象之间是否为一个对象:"+"c1和c2是一个对象,地址和内容都一致;");
                System.out.println(c1);
            }else {
                System.out.println("判断获取到的四个对象之间是否为一个对象:"+"c1和c2不是一个对象,地址或内容不一致;");
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}

12.3 常用方法

12.3.1 获取构造函数

package reflect;

public class Student {
    public String name;
    public int age;
    private String address;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student(String name, String address) {
        super();
        this.name = name;
        this.address = address;
    }
    //私有的构造函数
    private Student(String name, int age, String address) {
        super();
        this.name = name;
        this.age = age;
        this.address = address;
    }
    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;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
}

package reflect;

import java.lang.reflect.Constructor;

/*
 * 反射：
 *         
 * Class类中的方法：
 *         构造函数： Constructor
 * public Constructor getConstructor(Class<?>... parameterTypes) 返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
 *         public Constructor[] getConstructors() : 获取所有的公共的构造函数
 *         public Constructor[] getDeclaredConstructors(): 获取所有的构造函数
 */
public class ReflectConstructorDemo {

    public static void main(String[] args) {
        //根据参数类型获取指定公共构造函数
        getConstructorTest();
        //获取所有的公共构造函数
        getConstrnctorsTest();
        //获取指定的构造函数(公有,私有)
        getDeclaredConstructorTest();
        //获取所有的公共构造函数(公有,私有)
        getDeclaredConstructorsTest();

    }
    //获取指定的公共构造函数
    public static void getConstructorTest(){
        Class c = Student.class;
        try {
            Constructor conPub = c.getConstructor(String.class,int.class);
            System.out.println(conPub);
            
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //获取指定的私有构造函数,注意只能获取公共的构造函数,访问私有会报出java.lang.NoSuchMethodException: reflect.Student.<init>(java.lang.String, int, java.lang.String)
//        try {
//            Constructor conPri = c.getConstructor(new Class[] {String.class,int.class,String.class});
//            System.out.println(conPri);
//        } catch (NoSuchMethodException | SecurityException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
    }
    //获取所有的公共构造函数
    public static void getConstrnctorsTest(){
        Class c = Student.class;
        Constructor[] conPub = c.getConstructors();
        for (Constructor constructor : conPub) {
            System.out.println("获取到的所有的公共的构造函数:"+constructor);
        }
    }
    //获取指定的构造函数(公共和私有都可以获取)
    public static void getDeclaredConstructorTest(){
        Class c = Student.class;
        try {
            Constructor conPub = c.getDeclaredConstructor(new Class[]{String.class,int.class});
            System.out.println("获取公共的构造函数:"+conPub);
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Constructor conPri = c.getDeclaredConstructor(String.class,int.class,String.class);
            System.out.println("获取私有的构造函数:"+conPri);
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //获取所有的构造函数(公共和私有都可以获取)
    public static void getDeclaredConstructorsTest(){
        Class c = Student.class;
        Constructor[] con = c.getDeclaredConstructors();
        for (Constructor constructor : con) {
            System.out.println("获取所有的公共构造函数:"+constructor);
        }
    }

}

12.3.2 获取当前字节码实例

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/*
 * public Constructor getConstructor(Class<?>... parameterTypes)
 * 
 * 通过构造函数， 创建对象
 * public Object newInstance(Object... initargs)
 * 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
 */
public class NewInstanceByConstructorDemo {

    public static void main(String[] args) {
        //通过构造函数创建实例对象
        getPublicInstanceByConstructorTest();
        //暴力进入,通过私有构造获取实例
        setAccessibleTest();
    }
    //通过构造函数创建实例对象,注意不能创建私有的构造函数,否则报出错误
    //java.lang.IllegalAccessException: Class reflect.NewInstanceByConstructorDemo can not access a member of class reflect.Student with modifiers "private"
    public static void getPublicInstanceByConstructorTest(){
        Class c = Student.class;
//        try {
//            //创建私有对象
//            Constructor conPri = c.getDeclaredConstructor(String.class,int.class,String.class);
//            Object obj1 = conPri.newInstance("静",27,"河南");
//            Object obj2 = conPri.newInstance("静",27,"河南");
//            if (obj1 == obj2) {
//                System.out.println("获取到的两个对象是同一个地址!");
//            }else {
//                System.out.println("获取到的不是两个对象!");
//            }
//        } catch (NoSuchMethodException | SecurityException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        } catch (InstantiationException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        } catch (InvocationTargetException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
        //创建公共构造函数
        
        try {
            Constructor conPub = c.getConstructor(String.class,int.class);
            Object obj1 = conPub.newInstance("静",27);
            Object obj2 = conPub.newInstance("静",27);
            if (obj1==obj2) {
                System.out.println("创建是同一个对象");
            } else {
                System.out.println("不是同一个对象");
            }
        } catch (InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //在上边我们看到私有构造函数创建实例时,报错了,这是java的机制决定的,那么有没有办法让他创建成功呢
    /*
     * 获取Student类中的非public的构造函数,并创建对象
     * 
     * public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
     * 获取指定的构造函数 （包含私有的）
     * 
     * public void setAccessible(boolean flag)
     * 将此对象的 accessible 标志设置为指示的布尔值。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查
     * 
     * 步骤：
     *         创建一个Class字节码文件对象
     *         获取指定的构造函数  如果是非public的构造函数，需要 强制访问(暴力访问)
     *         创建对象
     */
    public static void setAccessibleTest(){
        Class c = Student.class;
        try {
            Constructor conPri = c.getDeclaredConstructor(String.class,int.class,String.class);
            //强制访问,暴力进入,(通过私有构造函数获取对象)
            conPri.setAccessible(true);
            Object obj = conPri.newInstance("静",27,"河南");
            System.out.println(obj);
            Object object = conPri.newInstance("静",27,"河南");
            System.out.println(object);
        } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

12.3.3 获取当前字节码中字段

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/*
 * 字段：Field
 * 
 * private String name;
 * int age;
 * public String address;
 *
 * 步骤：
 *     a: 创建class字节码文件对象
 *     b: 获取指定的字段,如果是非public 修饰的字段， 需要 暴力访问
 *     c: 对字段进行操作
 * 
 *  Class中的方法：
 *      public Field[] getFields() : 获取 public 修饰的 所有字段
 *         public Field[] getDeclaredFields(): 获取所有的字段（包含私有）
 *         public Field getDeclaredField(String name):获取指定的字段,包含私有
 *         public Field getField(String name): 获取指定的字段
 * 
 * Field中的方法：
 *         public void set(Object obj, Object value)：  为指定对象中的当前字段， 赋值
        
        Person p1;
        Person p2;
        addressField.set( p1,"上海");
 * 
 */
public class ReflectFieldDemo {

    public static void main(String[] args) {
        //获取指定的字段(公共的),操作字段
        getPubFieldTest();
        //获取指定的字段(私有的),操作字段
        getPriFieldTest();
        //获取所有公共字段
        getPubFieldsTest();
        //获取所有字段(含私有)
        getAllFieldsTest();

    }
    //获取指定的字段(公共的)
    public static void getPubFieldTest(){
        //获取字节码对象
        Class c = Student.class;
        //获取指定字段
        try {
            //获取构造函数
            Constructor conPub = c.getConstructor(String.class,int.class);
            //获取实例对象
            Object obj = conPub.newInstance("静",27);
            //获取指定字段
            Field fN = c.getField("name");
            //设置对象字段
            fN.set(obj, "静");
            Field fA = c.getField("age");
            fA.set(obj, 27);
            System.out.println(obj);
            Student stu = (Student) obj;
            System.out.println(stu.getName()+"--"+stu.getAge());
            System.out.println("-------------------------------------");
        } catch (NoSuchFieldException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //获取指定的字段(私有的)
    public static void getPriFieldTest(){
        Class c = Student.class;
        try {
            //获取私有的构造函数
            Constructor conPri = c.getDeclaredConstructor(String.class,int.class,String.class);
            //暴力获取实例
            conPri.setAccessible(true);
            Object obj = conPri.newInstance("静",25,"河北");
            //获取字段
            Field fN = c.getDeclaredField("name");
            Field fA = c.getDeclaredField("age");
            fA.set(obj, 27);
            Field fAdder = c.getDeclaredField("address");
            //java.lang.IllegalAccessException: Class reflect.ReflectFieldDemo can not access a member of class reflect.Student with modifiers "private"
            //不能直接操作私有字段,否则报错上面,
//            fAdder.set(obj, "河南");
            fAdder.setAccessible(true);
            fAdder.set(obj, "河南");
            Student stu = (Student) obj;
            System.out.println(stu.getName()+"--"+stu.getAge()+"--"+stu.getAddress());
            System.out.println("-------------------------------------");
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException 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();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //获取所有的字段(公共)
    public static void getPubFieldsTest(){
        //获取字节码文件
        Class c = Student.class;
        try {
            //获取构造函数
            Constructor conPub = c.getConstructor(String.class,int.class);
            Object obj = conPub.newInstance("静",25);
            //获取所有公共字段
            Field[] f = c.getFields();
            for (Field field : f) {
                System.out.println(field.get(obj));
                System.out.println(field);
                System.out.println("-------------------------------------");
            }
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException 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 getAllFieldsTest(){
        Class c = Student.class;
        try {
            Constructor conPri = c.getDeclaredConstructor(String.class,int.class,String.class);
            conPri.setAccessible(true);
            Object obj = conPri.newInstance("静",27,"河南");
            Field[] f = c.getDeclaredFields();
            for (Field field : f) {
                //字段数组中存在私有,要暴力访问
                field.setAccessible(true);
                System.out.println(field.get(obj));
                System.out.println(field);
                System.out.println("-------------------------------------");
            }
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException 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();
        }
    }
}

12.3.4 获取当前字节码中的方法

package reflect;

public class Student {
    public String name;
    public int age;
    private String address;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student(String name, String address) {
        super();
        this.name = name;
        this.address = address;
    }
    //私有的构造函数
    private Student(String name, int age, String address) {
        super();
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    private void setAge(int age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
}

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/*
 * 反射方法： Method
 * 
 * 步骤：
 *     a: 创建class 字节码文件对象
 *     b: 获取指定的方法
 *     c: 使用方法(需要前有对象，才能使用方法)
 * 
 * Class类中的方法：
 *         public Method[] getMethods() 获取所有的公共方法（包含父类的）
 *         public Method[] getDeclaredMethods() 获取所有的方法（不包含父类）
 * 
 *         public Method getMethod(String name, Class<?>... parameterTypes) : 获取指定的方法
 *                                 name: 想要获取的方法的名字
 *                                 parameterTypes： 获取的方法的参数列表的数据类型
 * 
 *         public Method getDeclaredMethod(String name, Class<?>... parameterTypes) : 获取指定的方法(包含私有的)
 * 
 * Method类的方法：
 *         public Object invoke(Object obj, Object... args)
 *         调用给定的对象中的当前方法，并且给定方法的参数列表，这个时候就可以确定调用的是具体的哪一个方法了
 *     暴力访问
 *         public void setAccessible(boolean flag)
 * 
 */
public class ReflectMethodDemo {

    public static void main(String[] args) {
        //获取指定方法(公共)
        getPubMethodTest();
        //获取所有的公共方法
        getPubMethodsTest();
        //获取所有方法,含私有
        getAllMethodsTest();
    }
    //获取指定方法(公共),私有
    public static void getPubMethodTest(){
        //获取字节码文件
        Class c = Student.class;
        //获取构造函数,创建该字节码文件对象实例
        try {
            Constructor conPub = c.getConstructor(String.class,int.class);
            Object obj = conPub.newInstance("静",27);
            //获取指定方法,公共
            Method m1 = c.getMethod("setName", String.class);
            //java.lang.NoSuchMethodException: reflect.Student.setAge(int)
//            Method m2 = c.getMethod("setAge", int.class);
            //获取指定方法,私有
            Method m2 = c.getDeclaredMethod("setAge", int.class);
            m1.invoke(obj, "岁月静好");
//java.lang.IllegalAccessException: Class reflect.ReflectMethodDemo can not access a member of class reflect.Student with modifiers "private"
            //暴力调用私有方法
            m2.setAccessible(true);
            m2.invoke(obj, 28);
            Student stu = (Student) obj;
            System.out.println(stu.getName()+"--"+stu.getAge());
            System.out.println("---------------------------------------");
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException 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 getPubMethodsTest(){
        Class c = Student.class;
        try {
            Constructor con = c.getConstructor(String.class,int.class);
            Object obj = con.newInstance("静",27);
            Method[] mm = c.getMethods();
            for (Method method : mm) {
                System.out.println("方法名字:"+method.getName());
            }
            System.out.println("---------------------------------------------");
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException 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 getAllMethodsTest(){
        Class c = Student.class;
        try {
            Constructor con = c.getConstructor();
            Object obj = c.newInstance();
            Method[] mm = c.getDeclaredMethods();
            for (Method method : mm) {
                System.out.println(method.getName());
            }
        } catch (NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

12.3.5 通过反射向集合中添加字符串

package reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/*
 *  需求： ArrayList<Integer> list = new ArrayList<Integer>();
 *      向集合中 添加3个字符串
 *  
 *      通过反射来解决该问题
 *      
 *      思路： 
 *          a: 获取  ArrayList 的字节码文件对象
 *          b: 获取 add 方法
 *          c: 使用方法
 *      
 *      注意： 当我们的java文件 生成对应的Class文件的时候， 泛型是不会编译到 class文件中的
 */
public class ReflectTest {

    public static void main(String[] args) {
        //通过反射向集合中添加字符串]
        test();

    }
    public static void test(){
        ArrayList<String> al = new ArrayList<>();
        Class c = al.getClass();
        try {
            Method m = c.getMethod("add", Object.class);
            m.invoke(al, "2014");
            m.invoke(al, "2015");
            m.invoke(al, "2016");
            System.out.println("ArrayList:"+al);
        } catch (NoSuchMethodException | 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();
        }
    }
}

 12.4 反射的优点和缺点

  为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，  

  静态编译：在编译时确定类型，绑定对象,即通过。  

  动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。  

  一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发。

它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。