一、java反射机制

首先大家应该先了解两个概念，编译期和运行期，编译期就是编译器帮你把源代码翻译成机器能识别的代码，比如编译器把java代码编译成jvm识别的字节码文件，而运行期指的是将可执行文件交给操作系统去执行，JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制；
简单说，反射机制指得是程序在运行时能够获取自身的信息。在java中，只要给定类的名字(类的全路径)，那么就可以通过反射机制来获得类的所有信息。

大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。不使用反射的话，我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类已经被加载了。

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类，这样的特点就是反射。

二、反射作用

假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。
反射可以节约JVM资源（但是相对于new对象来说，性能有损失）；如果不使用反射，使用普通的new对象的方式，则当前类在加载的时候就会为这个new出来的对象生成.class，占用JVM资源；但是如果使用反射的话，类在加载时不会创建这个对象的.class,不会占用JVM资源，只有当程序运行时，运行到反射这里的时候，才会为这个类生成.class文件；

为什么使用反射，直接使用new对象不就可以了吗？

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

一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中，它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。
```
它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。 
```

new对象和反射创建的对象有什么区别

new;静态编译，在编译期就将模块编译进来，执行该字节码文件，所有的模块都被加载；
反射：动态编译，编译期没有加载，等到模块被调用时才加载；

注：spring的ioc就用到反射机制，newInstance创建。更加的通用，并且降低耦合，避免了硬编码，只需提供一个字符串就可以动态的创建。

什么时候使用反射：

Java编码时知道类和对象的具体信息，此时直接对类和对象进行操作即可，无需反射
如果编码时不知道类或者对象的具体信息，此时应该使用反射来实现，去动态的创建对象

反射优缺点

优点

反射提高了Java程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提高硬编码目标类
反射是其他一些常用语言，如C、C++、Fortran或者Pascal等不具备的
Java反射技术应用领域很广，如软件测试、JavaBean等
许多流行的开源框架例如Struts、Hibernate、SpringIOC(配置文件里的类的全路径...)在实现过程中都采用了该技术

缺点

性能问题：使用反射基本上是一种解释操作（通知jvm要做的事情，性能比直接的java代码要慢很多），用于字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用；反射包括了一些动态类型，所以JVM无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
使用反射会模糊程序内部逻辑：程序员希望在代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂
安全问题：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用；

三、反射的具体实现

3.1、反射的常用操作

通过反射获取类的构造器来创建对象

    //参数是字符串，必须是Person类的全路径
    Class c3 = Class.forName("cn.maltose.demo1.Person");

通过反射获取构造方法，创建对象(前提是有public修饰的空参构造方法)

    //1、获取到Class对象
    Class c = Class.forName("cn.maltose.demo1.Person");//包名.类名
    //2、获取指定的构造方法
    //下边的代码可以获取到这个构造参数：public Person()
    //Constructor con = c.getConstructor(null);

    //下边的代码可以获取到这个构造参数：public Person(String name, int age, String address)
    Constructor con = c.getConstructor(String.class, int.class, String.class);

    //3、通过构造方法类中Constructor的方法，创建对象
    //Object obj = con.newInstance(null);
    Object obj = con.newInstance("小明", 22, "哈尔滨");

    //显示
    System.out.println(obj);

通过反射获取私有构造方法，创建对象

    Class c=Class.forName("cn.maltose.demo1.Person");
    //Person类里的该构造方法是私有的：private Person(String name, int age)
    Constructor con = c.getDeclaredConstructor(String.class, int.class);
    //暴力反射 ，取消 Java 语言访问检查
    con.setAccessible(true);
    //创建对象
    Object obj = con.newInstance("小明",12);
    System.out.println(obj);
    //输出：cn.maltose.demo1.Person@17494c8

通过反射获取成员变量并使用
在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：

    // 获取Class对象
    Class c = Class.forName("cn.maltose.demo1.Person");

    // 获取成员变量， 多个变量
    // Field[] fields = c.getFields();
    //获取所有属性，包括私有属性
    Field[] fields = c.getDeclaredFields();
    for (Field field : fields) {
   
        System.out.println(field);
    }
    System.out.println("-----------------");
    // 一个变量
    //获取公有属性： public int age;
    Field ageField = c.getField("age");
    System.out.println(ageField);

    //获取私有属性： private String address
    Field addressField = c.getDeclaredField("address");
    //暴力反射
    addressField.setAccessible(true);
    System.out.println(addressField);

Person类：

public class Person {
   
    String name = "zhangsan";
    public int age = 20;
    private String address;
}

结果：

    java.lang.String cn.maltose.demo1.Person.name
    public int cn.maltose.demo1.Person.age
    private java.lang.String cn.maltose.demo1.Person.address
    -----------------------------------------
    public int cn.maltose.demo1.Person.age
    private java.lang.String cn.maltose.demo1.Person.address

通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作
Person类：

public class Person {
   
    public String name;
    public int age;
    private String address;
    public Person() {
   
        super();
    }
    public Person(String name) {
   
        super();
    }
    public Person(String name, int age, String address) {
   
        super();
        this.name = name;
        this.age = age;
        this.address = address;
    }
}

Test类：

    //1,获取Class对象
    Class c = Class.forName("cn.maltose.demo1.Person");
    //2，获取构造方法
    //public Person(String name) 
    Constructor con = c.getConstructor(String.class);
    //3，通过构造方法，创建对象
    Object obj = con.newInstance("小明");
    //4，获取指定的成员变量
    //public String name;
    Field nameField = c.getField("name");
    //public int age;
    Field ageField = c.getField("age");
    //private String address;
    Field addressField = c.getDeclaredField("address");
    addressField.setAccessible(true); //取消 Java 语言访问检查

    //5，通过方法，给指定对象的指定成员变量赋值或者获取值
    System.out.println("赋值前：");
    System.out.println("name = "+ nameField.get(obj));
    System.out.println("age = "+ ageField.get(obj));
    System.out.println("address = "+ addressField.get(obj));

    //赋值
    nameField.set(obj, "张三");
    ageField.set(obj, 23);
    addressField.set(obj, "凯利广场");

    System.out.println("------------------------");
    System.out.println("赋值后：");
    System.out.println("name = "+ nameField.get(obj));
    System.out.println("age = "+ ageField.get(obj));
    System.out.println("address = "+ addressField.get(obj));

结果：

    赋值前：
    name = null
    age = 0
    address = null
    ------------------------
    赋值后：
    name = 张三
    age = 23
    address = 凯利广场

通过反射获取成员方法并使用
在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法
Person类：

public class Person {
   
    public String name;
    public int age;
    private String address;
    public Person() {
   
        super();
    }
    public Person(String name) {
   
        super();
    }
    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;
    }
    public void method1(){
   
        System.out.println("Person里的公有method1方法");
    }
    public String method4(String name){
   
        System.out.println("Person里的公有method4(String name)方法");
        return name;
    }
    private void method5(){
   
        System.out.println("Person里的私有method5方法");
    }
}

测试类：

    // 获取Class对象
    Class c = Class.forName("cn.maltose.demo1.Person");
    // 获取多个公共方法，会显示父类方法
    // Method[] methods = c.getMethods();
    //获取所有方法，包括私有方法，不显示父类方法
    Method[] methods = c.getDeclaredMethods();
    System.out.println("获取所有方法：");
    for (Method method : methods) {
   
        System.out.println(method);
    }
    System.out.println("-----------------------");
    // 获取一个方法：
    // public void method1()
    System.out.println("获取一个指定方法：");
    Method method = c.getMethod("method1", null);
    System.out.println(method);
    // public String method4(String name){
   
    method = c.getMethod("method4", String.class);
    System.out.println(method);
    // 私有方法
    // private void method5()
    method = c.getDeclaredMethod("method5", null);
    System.out.println(method);

结果：

    获取所有方法：
    public void cn.maltose.demo1.Person.method1()
    public void cn.maltose.demo1.Person.setAge(int)
    public java.lang.String cn.maltose.demo1.Person.method4(java.lang.String)
    public int cn.maltose.demo1.Person.getAge()
    private void cn.maltose.demo1.Person.method5()
    public java.lang.String cn.maltose.demo1.Person.getName()
    public void cn.maltose.demo1.Person.setName(java.lang.String)
    public java.lang.String cn.maltose.demo1.Person.getAddress()
    public void cn.maltose.demo1.Person.setAddress(java.lang.String)
    -----------------------
    获取一个指定方法：
    public void cn.maltose.demo1.Person.method1()
    public java.lang.String cn.maltose.demo1.Person.method4(java.lang.String)
    private void cn.maltose.demo1.Person.method5()

通过反射，创建对象，调用指定的方法

      //1， 获取Class对象
    Class c = Class.forName("cn.maltose.demo1.Person");
    //2,获取构造方法
    //public Person(String name, int age, String address){
   
    Constructor con = c.getConstructor(String.class, int.class, String.class);
    //3，通过构造方法，创建对象
    Object obj = con.newInstance("小明", 23, "哈尔滨");
    //4，获取指定的方法
    //public void method1()  没有返回值没有参数的方法
    //Method m1 = c.getMethod("method1", null);//null可以不写

    //public String method4(String name)
    Method m4 = c.getMethod("method4", String.class);

    //5，执行找到的方法
    //m1.invoke(obj, null);

    Object result = m4.invoke(obj, "itcast");
    System.out.println("result = " + result);

通过反射，创建对象，调用指定的private 方法：

   //1， 获取Class对象
    Class c = Class.forName("cn.itcast_01_Reflect.Person");
    //2,获取构造方法
    //public Person(String name, int age, String address){
   
    Constructor con = c.getConstructor(String.class, int.class, String.class);
    //3，通过构造方法，创建对象
    Object obj = con.newInstance("小明", 23, "哈尔滨");
    //4，获取指定的方法
    //private void method5(){
   
    Method m5 = c.getDeclaredMethod("method5", null);
    //5,开启暴力访问
    m5.setAccessible(true);
    //6，执行找到的方法
    m5.invoke(obj, null);

java反射机制

一、java反射机制

二、反射作用

三、反射的具体实现

3.1、反射的常用操作

热门文章

最新文章

相关课程

相关电子书

相关实验场景