很多时候，java程序运行中，我们需要在运行时了解类的信息，得到类的实例，并且进而继续得到类的方法，构造函数，权限，变量以及其他信息。这时候我们需要用到一门技术，java反射

反射说白了，就是把我们的一些文件，一些字符串，一些地址上具体的配置信息，能够把他们动态的在运行期实例化，并且我们能够操作这些实例。这就是反射。

以下几段话是我学习Android的思考，只是想学习反射的同学可以直接跳到Class的使用

我学习Android开发的时候，我就在想，我们在layout文件下写的xml布局文件，他是文本文件，是一些配置信息吧。既然万事万物皆对象，那我们的手机界面应该是一个类。
xml布局文件有LinearLayout布局，那是不是有一个LinearLayout类？我在xml布局文件那里配置

android:layout_width="match_parent"
android:layout_height="match_parent"

就能让这个LinearLayout的宽高匹配父布局。那么，如果真的有LinearLayout类的话，会不会有个方法类似于setWidth()让我设置宽高？事实上，有LinearLayout类，提供了setLayoutParams()方法让我们设置布局参数，当然这个方法能设置宽高

那，我们在xml布局文件写的配置信息，在手机界面上能够显示那么丰富的效果，有按钮，有文本，有列表。这是怎么做到的？其实，这就是用到反射，把xml布局文件写的配置信息，动态的实例化，比如Button按钮，TextView文本，在程序运行时刻全都动态实例化。如果没有反射，我们就无法使用（调用）xml布局文件，无法使用到xml布局文件的话，那Android系统怎么加载丰富多彩的界面？
同样的，AndroidManifest文件里配置了很多Activity，都是通过反射来实例化。如果没有反射，也无法使用AndroidManifest里的配置信息。当然也就没有了Android框架了。

Java反射那么重要，我们需要理解了才能够去使用他。那我们就来学习Java反射这门技术

Class类的使用

在面向对象的世界里，万事万物皆对象。

在java的世界里，有两样东西不是面向对象的。基本的数据类型和静态（static）的东西。

比如，int a = 5，他不是面向对象，但是他有包装类（Integer）或者说是封装类，弥补了他。Int a = 5；是直接在栈空间中分配内存。而Integer a = new Integer（5），对象在堆内存中，引用变量a在栈内存。像这样的普通数据类型还好几个，比如boolean与Boolean，char和Character，double与Double等等，他们都不是面向对象

还有是就是java静态的东西，他不属于某个对象，是属于类的
现在，除去以上不是面向对象的。

那么我们写的类，类是不是对象呢？类是谁的对象呢？类是哪个类的对象呢？
我们写的每一个类它也是对象，类是对象，类是java.lang.Class类的实例对象。

我写的一个Student类，他是不是对象，是一个对象。谁的对象？Class类的实例对象

public class Student {

}

注意，我们上面的程序class，c是小写，是关键字。在声明java类时使用。而我们说的java.lang.Class类的C是大写，他是一个类，因为我们定义一个类，类名的首字母是大写的呀。也可以这么理解：

现在有一个类，他的名字就叫Class。java.lang.Class类

Class类能不能new出实例对象呢？这个对象到底如何表示呢？
我们按住ctrl+鼠标左键，追踪Class这个类，发现他的构造方法是私有的，还给出了注释，只有java虚拟机才能创建Class对象，如下所示：

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

既然不能通过调用构造方法，new出实例，那么Class类的实例对象如何表示呢？

接下来我们来学习Class类的使用

我们打开eclipse先新建一个Student类

public class Student {

    public void introduce(){
        System.out.println("我是一名大三学生");
    }

}

在新建一个demo，我们很简单的将Student类的实例对象表示出来

public class ClassDemo {
    public static void main(String[] args){
        //student1表示Student的实例对象
        Student student1 = new Student();       
    }
}

那么我们说到，Student这个类，也是一个实例对象，是Class类的实例对象

——》紧接上面提到的问题：Class类的实例对象如何表示呢？
任何一个类都是Class类的实例对象（这句话可以心里念三遍）。这个实例对象有三种表示方式：

第一种表示方式 —>通过类名调用静态成员变量class。 类名.class

Class class1 = Student.class;

这实际在告诉我们任何一个类都有一个隐含的静态成员变量class

第二种表示方式 —> 已经知道该类的对象，通过调用getClass方法。object.getClass()

Class class2 = student1.getClass();

第三种表达方式 —> Class类调用静态方法forName（“类的全称”）。
Class.forName(“类的全称”)

Class class3 = null;
    try {
        class3 = Class.forName("com.xyh.reflect.Student");
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

万一我们找不到这个类呢？这种方法会抛出ClassNotFoundException异常
好，现在我们已经将Class类的实例对象表示出来了。

class1, class2，class3 表示了Student类的类类型(class type)。
这里的三种表示方式，类名.class，object.getClass()，Class.forName(“类的全称”)，是指哪个类调用.class返回的就是哪个类的类类型，哪个对象调用getClass（）返回的就是这个对象所属类的类类型，Class.forName()同理

我是这么理解类类型的，类类型是某个类的另一种表示方式，另一种类型。他们大有不同，却又息息相关。（这有点绕口）
下面我们会学到用类类型来创建对象，如：通过class1对象调用newInstance()方法，需要进行一下强转

Student student2 = (Student) class1.newInstance();

这种通过类类型创建Student类的实例对象，我们也可以通过new Student()来创建对象，两种方式都可以创建对象嘛！所以我把Student的类类型理解成了Student类的另一种表示方式，
类也是对象，是Class类的实例对象
这个Class类的对象，我们称为该类的类类型

我们看到下面这行代码

System.out.println(class1 == class2);

输出：true

结论：不管class1 ，class2都代表了Student类的类类型，一个类只可能是Class类的一个实例对象，也就是唯一，只有一个

我们完全可以通过类的类类型创建该类的实例对象 —>
比如，可以通过class1，class2，class3创建Student类的实例对象

    try {
        //前提是需要有无参数的构造方法
        Student student2 = (Student) class1.newInstance();
        //student2调用方法验证一下
        student2.introduce();

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

输出：true
我是一名大三学生

| 以下才是核心知识点 |
| 以下才是核心知识点 |
| 以下才是核心知识点 |

动态加载类

Class.forName(“类的全称”)
不仅表示了类的类类型，还代表了动态加载类。那么，什么是动态加载类，什么是静态加载类

编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

我一开始写Java程序，是在Notepad++写的，写好后后通过命令行输入javac 类名.java编译，通过java 类名，执行程序。好怀念，后来我使用了eclipse写java，我就在想，为什么这些IDE能够做到：我一写好程序，点击运行就ok，他一定做了很多功能的封装，（比如我一点击运行，eclipse就执行了javac和java命令吧），不管怎样。IDE方便了开发者，而且他检错很好，比如下图

我现在Office类需要使用Word类的实例对象，但是我并没有定义这个Word类

如果我们使用Notepad++就没有那么好了，并没有提示。不过却能让我们更好的理解 动态加载类 这个知识点

好，我们通过Notepad++写一段程序回忆下

public class Office {
    public static void main(String[] args){

        //new创建对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类
        if("Word".equals(args[0])){
            Word word = new Word();
            word.open();
        }
        if("Excel".equals(args[0])){
            Excel excel = new Excel();
            excel.open();
        }

    }

}

我们知道这样编译肯定会报错的。因为我们现在没有声明Word类和Excel类。此时，我们不禁会想，Word一定用到吗？Excel一定用到吗？

那我们现在声明一个Word类

public class Word{

    public void open(){
        System.out.println("Word...Open");
    }

}

现在只报两个错了，这个程序有什么问题? Word类已经有了，我现在就想用Word，这个程序能跑吗？不能，因为程序一直会报找不到Excel类的错误，如果现在有一百个类，有一个类找不到或者出问题，全部都用不了。而且一百个类，每一个都还需要用if语句去判断

思路：我们这段程序实现的是静态加载。是在编译时加载。
而我们希望写的程序是可以扩展的，我想要用到哪个类就加载哪个类，即在程序运行时刻动态加载。接着我们新建一个OfficeBetter类如下

public class OfficeBetter{  
    public static void main(String[] args){         
        try{            
            Class class1 = Class.forName(args[0]);
            Word word = (Word)class1.newInstance();
            word.open();    
        }catch(Exception e){            
            e.printStackTrace();            
        }       
    }   
}

编译通过，运行OK。但是上面的代码也是有问题的，问题如下：

    Word word = (Word)class1.newInstance();
    word.open();

如果我传入的是Excel，PPT呢？那么就无法强转了。还是说我用到哪个类了，在来OfficeBetter这里修改强转的类型？？这也太麻烦了吧。所以我们应该提供一个标准，新建一个OfficeAble接口

public interface OfficeAble{
    public void open();
}

以后我们想用到哪个类，就让他实现这个接口就行了。优化后的代码如下

public class Word implements OfficeAble{
    

    public void open(){
        System.out.println("Word...Open");
    }

}

public class OfficeBetter{  
    public static void main(String[] args){         
        try{            
            Class class1 = Class.forName(args[0]);
            OfficeAble officeAble = null;
            officeAble = (OfficeAble)class1.newInstance();
            officeAble.open();  
        }catch(Exception e){            
            e.printStackTrace();            
        }       
    }   
}

如果我们想用到Excel类，那就新建Excel类实现OfficeAble接口

public class Excel implements OfficeAble{
    

    public void open(){
        System.out.println("Excel...Open");
    }

}

呐，我想用到哪个类，我就写一个类去实现OfficeAble这个标准就行了，如图PPT类我是没有去写的，传进去参数才会报错。而那个OfficeBetter程序我更本不用去修改它

功能性的类一般使用动态加载

总结：到这里，我们已经学习了Class类的使用，和动态加载类的知识点，我们需要明白什么是类类型(class type)。
以上的内容我们只是通过类类型来创建该类的实例对象—>类类型.newInstance()
但是，类类型还能够做很多很多事情。

要获取类的信息，首先要获取类的类类型，（class type）

---

---

我们通过eclipse的代码提示，可以看到，类类型很多get方法
在这里我们可以封装一个工具类，去获取类的信息，就叫ClassUtil吧

package com.xyh.reflect;

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

/**
 * 获取类的信息的工具类
 *
 */
public class ClassUtil {
    
    /**
     * 以后在任意情况下，我们想获取一个类的信息，首先要获取到这个类的类类型
     */

    /**
     * 
     * 打印类的成员函数信息
     * @param object 
     */
    public static void printMethodMessage(Object object){

        //获取到该类的类类型
        Class class1 = object.getClass();//Object类是一切类的父类,传递的是哪个子类的对象，class1就是该子类的类类型

        //获取类的名称
        System.out.println("类的名称是："+class1.getName());

        /**
         * 方法也是对象，Method类的对象
         * 一个成员方法就是一个Method对象
         * getMethod()方法获取的是所有的public函数，包括父类继承而来的
         * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
         * 
         */
        Method[] methods = class1.getMethods();
        for(int i = 0 ;i <methods.length ; i++){
            //得到方法的返回值类型的类类型
            Class  returnType = methods[i].getReturnType();
            System.out.print(returnType.getName()+" ");

            //得到方法的名称
            System.out.print(methods[i].getName()+"(");

            //获取参数类型 ->得到的是参数列表的类型的类类型
            Class[] paramTypes = methods[i].getParameterTypes();            

            for (Class class2 : paramTypes) {
                System.out.print(class2.getName()+",");
            }

            System.out.println(")");

        }

    }


    /**
     * 打印类的成员变量的信息
     * @param object
     */
    public static void printFieldMessage(Object object) {
        /**
         * 成员变量也是对象
         * java.lang.reflect.Field
         * Field类封装了关于成员变量的操作
         * getFields()方法获取的是所有的public的成员变量的信息
         * getDeckaredFields()获取的是该类自己声明的成员变量的信息
         */
        //Field[] fields = class1.getFields();
        Class class1 = object.getClass();
        Field[] fields = class1.getDeclaredFields();
        for(Field field :fields){
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName+" "+fieldName);
        }
    }

    /**
     * 获取对象的构造函数的信息
     * @param object
     */
    public static void printConstructorMessage(Object object){
        Class class1 = object.getClass();
        /**
         * 构造函数也是对象，
         * java.lang.Constructor中封装了构造函数的信息
         * getConstructors()获取所有的public的构造函数
         * getDeclaredConstructors()获取所有的构造函数
         * 
         */
        Constructor[] constructors = class1.getDeclaredConstructors();
        for(Constructor constructor : constructors){
            System.out.print(constructor.getName()+"(");
            //获取构造函数的参数列表->得到的是参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class2 : paramTypes) {

                System.out.print(class2.getName()+",");
            }
            System.out.println(")");
        }
    }

}

这里直接贴出了代码，注释也写的比较详细。还需要补充的是，ClassUtil工具类是欢迎大家去丰满他的，现在只能打印一些类的信息，但是我们开头说到的，反射可以在运行时实例化，获取到类的信息，并能操作这些实例，既然是操作，我们可以看到下图：

如果我们能得到Constructor构造函数对象，他有很多方法，是可以做很多事的。其他成员函数，成员变量亦同理。

最后一个知识点。

方法的反射操作

方法的反射操作是用method对象来进行方法调用。一般是这样的
method.invoke(对象，参数列表)

我们写一个Computer类

public class Computer {

    public void plus(int a,int b){
        System.out.println(a+b);
    }
    public void plus(String a,String b){
        System.out.println(a.toUpperCase()+","+b.toLowerCase());
    }

}

目标：我们要通过方法的反射操作来获取到plus方法

新建一个MethodDemo类，

package com.xyh.reflect;

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

public class MethodDemo {
    

    public static void main(String[] args){
        /**
         * 方法是类的信息，要获取一个方法，就是获取类的信息，获取类的信息首先要获取这个类的类类型
         * 
         */ 
        Computer computer = new Computer();

        Class class1 = computer.getClass();
        /**
         * 获取方法，名称和参数列表来决定
         * getMethod获取的是public的方法
         * getDelcaredMethod获取自己声明的方法
         */     
        try {
            Method method = class1.getMethod("plus",new Class[]{
   int.class,int.class});

                //方法的反射操作是用method对象来进行方法调用，和computer.plus(10, 20)调用的效果是一样的

                /**
                 * 其实可以这么理解，这个plus现在变成了方法对象了，那么就是computer这个对象操作plus这个对象
                 * 同样，我们也可以反过来操作，用plus这个方法所代表的对象method，来操作computer这个对象
                 * 
                 * 用plus这个方法对象。那么plus方法对象是谁？
                 * 是method。来操作computer
                 */
            Object object = method.invoke(computer, new Object[]{
   10,20});
            //Object object = method.invoke(computer, 10,20);

            Method method2 = class1.getMethod("plus", String.class,String.class);
            method2.invoke(computer,"hello","world");

            /**
            * 无参数
             *  Method method3 = class1.getMethod("plus");
             * method3.invoke(computer);
             */ 
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }
}

最后需要补充的是，Class的getMethod方法和getMethods方法是不一样的

后者getMethods我们在ClassUtil工具类里用到过，返回的是一个数组，需要遍历每一个方法对象。
而getMethod方法，第一个参数传的是方法名，第二个参数是参数列表，是一个数组
方法名称和方法的参数列表才能唯一决定某个方法