java中的反射及其优点说明

目录

• java反射及优点
• java反射机制(Reflection)
• 1.什么是反射？反射有什么作用？
• 2.反射相关的主要API
• 3.什么是Class类
• 4.调用运行时类的指定结构

java反射及优点

反射是java的一大特性，而且是有些框架实现了IoC/DI的原理，本文就来探讨下java中的反射及其优点。

首先是普通的java静态类加载，java静态类是通过new实现的，在编译时刻就要加载所有可能用到的类，这样实际上存在一些缺点的，比如只要有一个类没有找到或者出现重大的问题编译便不会通过，导致其他存在的类也无法使用。另一方面，如果要加载其他的类就要重新进行编译，有的时候是非常不方便的。下面就引入反射机制来动态加载类来解决这个问题。

首先创建一个ClassInterface接口，放在com.classTest包下:

package com.classTest; 
public interface ClassInterface {
    public void start();       //接口约定start()方法
}

然后分别使用Class1Impl和Class2Impl类去实现这个接口，也放在com.classTest包下:

package com.classTest; 
public class Class1Impl implements ClassInterface {
 
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("This is Class1Impl");   //实现start()
    }
}

package com.classTest; 
public class Class2Impl implements ClassInterface {
 
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("This is Class2Impl");   //实现start()
    } 
}

下面先用正常的类加载来说明正常类加载的缺点：

package com.test; 
import java.util.Scanner; 
import com.classTest.ClassInterface;
 
public class LoadClassTest {
    ClassInterface c1 = new Class1Impl();
    ClassInterface c2 = new Class2Impl();
    c1.start();
    c2.start();
}

上面是正常的new方法生成的对象，然后调用接口里的方法，但是一旦Class1Impl类或者Class2Impl类没有，那有的哪个类也就无法使用，而且想要使用新的ClassInterface接口下的方法还是需要重新写类，重新写测试方法，重新生成测试对象，重新编译...

下面介绍利用反射机制动态加载类来解决这个问题：

package com.test; 
import java.util.Scanner; 
import com.classTest.ClassInterface;
 
public class LoadClassTest {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        //new 创建对象是静态加载类，在编译时刻就需要加载所有可能用到的类
        //动态记载类可以解决这个问题
        Scanner sc = new Scanner(System.in);
        String className = sc.nextLine();
        //动态加载类，在运行的时刻进行加载
        //使用类类型（class type） 通过Class这个类的forName(className)方法动态创建类对象
        Class c = Class.forName(className);
        //通过类类型 用newInstance()方法创建该类对象
        ClassInterface ci = (ClassInterface) c.newInstance();
        ci.start();//动态加载类 调用其方法
    }
}

有没有看出这其中的差异，想要加载其他类只需要输入另外的类名即可（这里的类名是包含包的），forName()方法可以通过类名动态创建类类型的对象，然后用类类型的对象的newInstance()方法创建该类类型对象（也就是一个类）的对象（调用newInstance()方法的类类型对象需要进行转化），之后就可以用生成对象调用接口下的方法了。

那这时候可能就会有人问了，要是在我们不知道接口名称为ClassInterface的情况下，我们该如何访问className这个类类型生成的c这个类对象下面的方法呢？我们来实现一下：

Class c = Class.forName("com.classTest.Foo");//创建一个类对象c
Method m1 = c.getMethod("fun1", int.class,int.class);//通过getMethod方法获取c的方法，第一个参数表示想要获取的方法名称fun1，之后的参数列表表示fun1这个函数的所有参数的类类型。
Object o = m1.invoke(foo1,new Object[]{10,20} );//通过invoke方法来调用我们前面通过getMethod()获得的方法，第一个参数表示执行我们所获得方法的对象，第二个参数表示我们所获取方法的参数，这里是两个int类型。如果没有返回值返回null，有返回值则返回具体的返回值，这里将返回结果保存在o对象里。

这样的优点是显而易见的，类无需在编译前全部加载，而且修改接口实现类的时候也不用重新编译。

这只是反射的一小部分，但是也是很重要的一部分，也是Spring中IoC/DI的实现基础。

（另外告诉大家一个小tip:所谓的泛型数据容器的数据类型（也就是HashMap<String,String>中的<String,String>）不能写入其他数据类型实际上只是存在于编译层面的，是为了防止开发者往里面误写入自己不想写入的东西，然而通过泛型可以跳过编译层面实现往这个泛型数据容器里存入和这个泛型数据容器数据类型不一样的数据，虽然这样之后用foreach遍历就会报错...）

java反射机制(Reflection)

1.什么是反射？反射有什么作用？

能够分析类能力的程序称为反射。反射机制允许程序在运行状态借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

反射机制的作用

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时获取泛型信息
• 在运行时处理注解
• 生成 动态代理

2.反射相关的主要API

• java.lang.Class:代表一个类
• java.lang.reflect.Method:代表类的方法
• java.lang.reflect. Field:代表类的成员变量
• java.lang.reflect.Constructor:代表类的构造器

3.什么是Class类

对Class类的深入理解

• Class本身也是一个类
• Class 对象只能由系统建立对象（Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的）
• 一个类在 JVM 中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的一个.class文件
• 每个类的实例都会记得自己是由哪个 Class 实例所生成
• 通过Class可以完整地得到一个类中的完整结构

类的加载过程:

程序经过javac.exe命令以后，会生成一 个或多个字节码文件(.class结尾)。

接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为CLass的一个实例。

java.Lang.Class实例的获取（四种方式）

package package03;
import org.junit.Test;
public class ReflectiveTeat01 {
    //获取 Class 类的实例
    @Test
    public void test01() throws Exception {
        //方式一:通过调用运行时类得属性：.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);//class package03.Person
        //方式二：通过运行时类的对象,调用 getClass() 方法
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);//class package03.Person
        //方式三：调用 Class 的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("package03.Person");
        System.out.println(clazz3);//class package03.Person
        //方法四：使用类的加载器：ClassLoader
        ClassLoader classLoader = ReflectiveTeat01.class.getClassLoader();
        Class clazz4 = classLoader. loadClass("package03.Person") ;
        System. out . println(clazz4);//class package03.Person
    }
}

4.调用运行时类的指定结构

如何操作运行时类中指定的属性

@Test
    public void testField() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象 P
        Person p = (Person) clazz.newInstance();
        //获取指定的属性
        Field fieldName = clazz.getDeclaredField("id");
        //fieldName 要操作的属性名赋值给 fieldName 变量名

        //保证当前属性是可访问的
        fieldName .setAccessible(true);
        /*
        设置当前属性的值
        set():参数1：指明设置哪个对象的属性
              参数2：将此属性值设置为多少
         */
        fieldName.set(p,1001);
        /*
        获取当前属性的值
        get():参数1:获取哪个对象的当前属性值
         */
        int intName = (int) fieldName.get(p);
        System.out.println(intName );
    }

操作运行时类的方法

已调用 show 方法例子：该方法有 注解，参数，返回值，权限小（private）

@MyAnonotation//自定义注解
    private String show(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

 @Test
    public void testMethod() throws Exception {
        Class clazz = Person.class;
        //创建运行时类对象
        Person p = (Person) clazz.newInstance();
       /* 1.获取指定的某个方法
       getDeclaredMethod():参数1：指明获取的方法的名称
                           参数2：指明获取的方法的形参列表
       * */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2.保证当前方法时可访问的
        show.setAccessible(true);
        /*
        3.调用方法的invoke():参数1：方法的调用者
                            参数2：给方法形参赋值的实参
          invoke()方法的返回值即为对应类中调用的方法的返回值
         */
        show.invoke(p, "CHN");

        //调用静态方法时：
        //private static void showDesc()
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则 invoke() 返回 null
        Object invoke = showDesc.invoke(Person.class);
        System.out.println(invoke);
    }

上面代码用到的 Person 类

public class Person {
    private String name;
    private int age;
    public int id;
    //空参构造器
    public Person() {
    }
    //全参构造器
    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    @MyAnonotation
    private String show(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }
    //静态方法
    private static void showDesc(){
        System.out.println("我是一个可爱的人");
    }
    // get、set 方法
    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 int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。