Java反射总结

1、Class对象的获取

Java中对象可以分为两种，一种是实例对象，一种是Class对象。Class对象是在类加载的时候生成的，而实例对象又是基于Class对象来生成的。
Java中的反射使其拥有了动态语言的属性。在程序开发的过程中，反射技术应用的核心就是Class对象的获取。Class对象的获取有如下三种方法，各有各的使用场景。

public class TestReflect {

    public static void main(String[] args){

        Class<?> clazz1 = null; //Class clazz1 = null;
        Class<?> clazz2 = null; //Class clazz2 = null;
        Class<?> clazz3 = null; //Class clazz3 = null;           
        //使用<?>或者不使用<?>两者是没有区别的，只不过Class支持泛型以后加上<?>会更加规范
        //1、使用Class的静态方法，该方法会产生异常，需要进行异常处理，因为可能没有与所传入字符串相对应的类
        try{

            Class clazz1 = Class.forName("InnerTest");
        } catch (ClassNotFoundException e) {

            e.printStackTrace();
        }

        //2、使用Java中类字面量class获得Class对象
        Class clazz2 = InnerTest.class;

        //3、使用继承于Object的getClass()方法，该方法是native方法
        InnerTest innerTest = new InnerTest();
        Class clazz3 = innerTest.getClass();
    }
}

class InnerTest {

}

2、构造实例对象

获得Class对象之后，采用newInstance()，该方法的返回类型是T，是一个泛型类型。如果Class对象的类型为Class或者Class<?>，则需要强制类型转换。有两种构造实例对象的方法：1、获得Class对象以后调用newInstance()方法；2、获得Constructor对象以后调用newInstance()方法。实际上前者也会调用后者的方法。

import java.lang.reflect.Constructor;
public class TestReflect {

    public static void main(String[] args){

        //若没有传入类型参数，使用newInstance()方法生成对象的时候，会有两种情况：1、只能生成Object对象；2、进行强制类型转换；
        Class<?> clazz1 = null;
        //此处传入了类型参数，使用newInstance()方法生成对象的时候，无需进行强制类型转换；
        Class<InnerTest> clazz2 = null;
        clazz1 = InnerTest.class;
        clazz2 = InnerTest.class;

        //1、使用newInstance()的方法返回实例对象
        try{
            Object test11 = clazz1.newInstance();//只能生成Object对象
            InnerTest test12 = (InnerTest) clazz1.newInstance();//必须进行强制类型转换
            InnerTest test2 = clazz2.newInstance();//直接可以生成所需的类型对象
        }catch (IllegalAccessException e) {
            e.printStackTrace();
        }catch (InstantiationException e){
            e.printStackTrace();
        }

        //2、直接获取构造函数
        Constructor<?> c1 = null;
        Constructor<InnerTest> c2 = null;
        try{
            c1 =clazz1.getDeclaredConstructor();
            c2 = clazz2.getDeclaredConstructor();
        }catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        try{
            Object innerTest11 = c1.newInstance(null);
            InnerTest innerTest112 = (InnerTest)c1.newInstance(null);
            InnerTest innerTest2 = c2.newInstance(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class InnerTest {

}

3、构造方法

在获得Class的对象以后，通过该对象获得对应的构造函数，如果同时存在多个构造函数。

import java.lang.reflect.Constructor;

public class TestReflect {

    public static void main(String[] args){

        Class<InnerTest> clazz = null;
        clazz = InnerTest.class;
        Constructor<InnerTest> c1 = null;
        Constructor<InnerTest> c2 = null;
        Constructor<InnerTest> c3 = null;
        try{

            c1 = clazz.getDeclaredConstructor();
            c2 = clazz.getDeclaredConstructor(int.class);
            c3 = clazz.getDeclaredConstructor(int.class,int.class);
        }catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        try{
            InnerTest innerTest1 = c1.newInstance();
            System.out.println("innerTest1 a: " + innerTest1.a + " b: " + innerTest1.b + " c: " + innerTest1.c);
            InnerTest innerTest2 = c2.newInstance(6);
            System.out.println("innerTest2 a: " + innerTest2.a + " b: " + innerTest1.b + " c: " + innerTest2.c);
            InnerTest innerTest3 = c3.newInstance(6,12);
            System.out.println("innerTest3 a: " + innerTest3.a + " b: " + innerTest1.b + " c: " + innerTest3.c);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class InnerTest {
    static int a = 2;

    int b;

    int c;

    public InnerTest() {

    }

    public InnerTest(int b) {
        this.b = b;
    }

    public InnerTest(int b, int c) {
        this.b = b;
        this.c = c;
    }
}

4、非构造方法

非构造方法的获取和使用与构造方法有着明显的区别：1、获取非构造方法不仅需要指定参数的类型，还需要指定方法名；2、非构造方法的调用分为两种情况：a)，静态方法调用；b)，非静态方法调用

import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args){

        Class<InnerTest> clazz = null;
        clazz = InnerTest.class;
        try{
            //需要指定方法名和参数类型
            Method m1 = clazz.getDeclaredMethod("getA");
            Method m2 = clazz.getDeclaredMethod("setA", int.class);
            //调用静态方法时候，invoke函数的第一个参数为null；
            System.out.println(m1.invoke(null));
            m2.invoke(null,4);
            System.out.println(m1.invoke(null));

            InnerTest innerTest = new InnerTest();
            Method m3 = clazz.getDeclaredMethod("getB");
            Method m4 = clazz.getDeclaredMethod("setB", int.class);
            //调用非静态方法的时候，需要指定对象名；
            System.out.println(m3.invoke(innerTest));
            m4.invoke(innerTest,8);
            System.out.println(m3.invoke(innerTest));
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class InnerTest {
    static int a = 2;

    int b;

    public static int getA() {
        return a;
    }

    public int getB() {
        return b;
    }

    public static void setA(int a) {
        InnerTest.a = a;
    }

    public void setB(int b) {
        this.b = b;
    }
}

5、域

域的获取相对简单，只需要传入变量名字。可以获取域的值和设置域的值。更厉害的时候可以通过setAccessible()，进而访问private的变量

import java.lang.reflect.Field;

public class TestReflect {

    public static void main(String[] args){

        Class<InnerTest> clazz = null;
        clazz = InnerTest.class;
        try{
            Field a = clazz.getDeclaredField("a");
            System.out.println("a: " + a.getInt(null));
            a.setInt(null,4);
            System.out.println("a: " + a.getInt(null));

            InnerTest innerTest = new InnerTest();
            Field b = clazz.getDeclaredField("b");
            System.out.println("b: " + b.getInt(innerTest));
            b.setInt(innerTest,20);
            System.out.println("b: " + b.getInt(innerTest));

            Field c = clazz.getDeclaredField("c");
            System.out.println("accessible: " + c.isAccessible());
            c.setAccessible(true);
            System.out.println("accessible: " + c.isAccessible()+ " c: " +c.getInt(innerTest));
            c.setInt(innerTest,40);
            System.out.println("accessible: " + c.isAccessible()+ " c: " +c.getInt(innerTest));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class InnerTest {
    static int a = 2;

    int b = 10;

    private int c = 20;
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,972评论 18赞 399
  • Java反射总结
    概念介绍 Java反射机制JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任...
    niaoge2016阅读 3,486评论 0赞 2
  • Java基础知识总结
    一：java概述：1，JDK：Java Development Kit，java的开发和运行环境，java的开发工...
    ZaneInTheSun阅读 7,602评论 0赞 11
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 135,596评论 19赞 139
  • 0712晨读感悟：不断更新的自己
    过去的几年，我只能懒懒散散地做到一年看两本书，有时间就看，没时间就对自己说工作太忙了，等有空了再看（可是当初并不及...
    天蝎麦子阅读 1,449评论 2赞 4