java的反射机制

程序员文章站 2022-04-24 10:30:06

...

　　java的反射是底层的技术了。很多框架都有用它，但是我们在做一般的编写是建议别使用它，有了它，好像java的三大特性都被破坏了，而且一般人驾驭不了。但是我们也应该了解甚至会用反射，这样在使用java的框架是才不是完全懵逼的。反射即是动态获取类的字节码文件对象，并对其成员进行抽象

反射的原理

　　在Java中，无论某个类的创建多少个实例对象，这些对象都会对应于同一个Class对象，这个Class对象是由JVM生成的，通过它能够得到整个类的结构信息。Class 类的实例表示正在运行的 Java 应用程序中的类和接口。Class类是一个final类，没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
　　 java的反射机制

获取Class对象的方法

（1）、通过Object提供的getClass(),得到字节码文件对象

Person person = new Person();//创建一个Person实例对象
Class<?> class1 = person.getClass();//字节码文件

（2）、每种数据类型都有一个class属性，通过它可以得到字节码文件对象
语法：.class

Class<?>class1 = Person.class;

(3)、Class类提供的静态方法forName(“包名+类名”)，建议使用这种形式
参数中的字符串的类不存在，则会抛出异常ClassNotFoundException

Class<?> class1 = Class.forName("com.test.Person");

先介绍一下Class类，Field类，Method类的API,后面再用代码实例说明。
Class类常用方法
forName(String className)
返回与带有给定字符串名的类或接口相关联的 Class 对象。

forName(String name, boolean initialize, ClassLoader loader)
1.loader指定装载参数类所用的类装载器，如果null则用bootstrp装载器。
2.initialize - 是否必须初始化类,initialize=true时，肯定连接，而且初始化了；
3.name - 所需类的完全限定名

newInstance()
创建此 Class 对象所表示的类的一个新实例。相当于在newInstance()内部调用了无参构造方法.

isPrimitive()
判定指定的 Class 对象是否表示一个基本类型。基本数据类型：byte、short、char、int、long、float、double、boolean 和void.

getClassLoader()
加载此对象所表示的类或接口的类加载器。如果此对象表示一个基本类型或 void，则返回 null。

getField(String name)
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。

getFields()
返回一个表示公共字段的 Field 对象的数组。如果该 Class 对象表示一个类，则此方法返回该类及其所有超类的公共字段。如果该 Class 对象表示一个接口，则此方法返回该接口及其所有超接口的公共字段。

getDeclaredField(String name)
返回此类中指定字段的 Field 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明字段。

getDeclaredFields()
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。

getMethod(String name, Class<\?>… parameterTypes)
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。

getMethods()
返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口包括超类或超接口的公共 member 方法。

getConstructor(Class<\?>… parameterTypes)
返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。parameterTypes 参数是 Class 对象的一个数组。

getConstructors()
返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。

getDeclaredConstructor(Class<\?>… parameterTypes)
返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。

getDeclaredConstructors()
返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

Field类常用方法
Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。
Object get(Object obj)
返回指定对象上此 Field 表示的字段的值。
Type getGenericType()
返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。
String getName()
返回此 Field 对象表示的字段的名称。
Class<\?> getType()
返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
void set(Object obj, Object value)
将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
void setAccessible(boolean flag)从类 AccessibleObject 继承下来的方法
将此对象的 accessible 标志设置为指示的布尔值。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查（暴力访问）。值为 false 则指示反射的对象应该实施 Java 语言访问检查。

Method类的常用方法
Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。
invoke() 反射调用一个方法

public Object invoke(Object obj, Object… args) throws IllegalAccessException, IllegalArgumentException,InvocationTargetException

对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
如果底层方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null。
如果底层方法是静态的，并且尚未初始化声明此方法的类，则会将其初始化。
如果底层方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null,可以不写。
如果底层方法是实例方法，则使用动态方法查找来调用它。
如果方法正常完成，则将该方法返回的值返回给调用者；如果该值为基本类型，则首先适当地将其包装在对象中。但是，如果该值的类型为一组基本类型，将返回基本类型的数组。如果底层方法返回类型为 void，则该调用返回 null。

使用反射的一般步骤：
1.获取待操作类的字节码文件对象
2.通过字节码文件对象获取对应的实例对象
3.给属性赋值（通过从属性中提取出来的类—filed类）
4.调用方法（通过从方法中提取出来的类–Method类）
代码演示：
创建一个Person类：

public class Person {
    private String name ;
    public int age;
    public Person() {
    }
    public Person(String name) {
        super();
        this.name = name;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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 void run() {
        System.out.println("无参run");
    }
    public void eat(String apple) {
        System.out.println("有参eat:"+apple);
    }
    public static void play(int num) {
        System.out.println("静态static-play:"+num);
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

1.获取待操作类的字节码文件对象

public class Demo2 {
    public static void main(String[] args) {
        //fun1();
//      fun2();
        fun3();
    }
    //a:通过Object提供的getClass(),得到字节码文件对象
    //说明一个类只有一个字节码文件对象，即Class对象
    public static void fun1() {
        Person person = new Person();
        Class<?> class1 = person.getClass();//字节码文件
        Class<?> class2 = person.getClass();//字节码文件
        System.out.println(class1==class2); //true
    }
    //b:每种数据类型都有一个class属性，通过它可以得到字节码文件对象
    public static void fun2() {
        Class<?>class1 = Person.class;
        System.out.println(class1);//class com.test.Person
    }

    // c:Class类提供的静态方法forName(包名+类名)
    public static void fun3() {
        try {
            Class<?> class1 = Class.forName("com.test.Person");
            System.out.println(class1); //class com.test.Person
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } 
    }
}

2.通过字节码文件对象获取对应的实例对象

//通过字节码文件对象获取对应的实例对象
public class Demo3 {
    public static void main(String[] args) {
        // //普通方式：
        // Person person = new Person();
        try {
            // 通过字节码文件获取实例对象
            Class<?> class1 = Class.forName("com.test.Person");
            // fun1(class1);
            fun2(class1);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    // 通过无参的构造方法创建对象
    public static void fun1(Class<?> cls) {
        try {
            // 创建实例对象 多态
            // 相当于在newInstance()内部调用了无参构造方法
            Object person = cls.newInstance();
            Person person2 = (Person) person;
            person2.setName("tom");
            person2.setAge(12);
            System.out.println(person2);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    // 通过有参的构造方法创建对象
    public static void fun2(Class<?> cls) {
        // 先得到有参的构造方法
        try {
            // 这里的参数是实际的构造方法参数的字节码文件 简单数据类型也有字节码文件 .class实现
            Constructor<?> constructor = cls.getConstructor(String.class, int.class);
            // 调用构造方法
            Object p = constructor.newInstance("mary", 12);
            System.out.println(p);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.给属性赋值

public class Demo4 {
    public static void main(String[] args) {
        /*
         * //通过普通的方式 Person person = new Person(); person.setName("Tom");
         */
        // 通过反射的方式--通过字节码文件对象调用
        try {
            // 1 得到字节码文件
            Class<?> class1 = Class.forName("com.test.Person");
            // 2 调用Field相关方法获得属性
            // 参数就是哪个实际的属性
            // Field field = class1.getField("name"); //获得包括父类的共有的
            // Field field2 = class1.getField("age");
            Field field = class1.getDeclaredField("name");
            field.setAccessible(true);// 私有属性 暴力进入
            Field field2 = class1.getDeclaredField("age");
            // 3 通过字节码文件创建Person类型的实例对象
            Object per = class1.newInstance();
            // 4 将Field属性指定给当前的实例对象并完成赋值
            // 第一个参数：绑定的具体的实例对象 第二个：具体赋的值
            field.set(per, "mary");
            field2.set(per, 23); // 相当于per.setAge=23;
            // 打印值
            System.out.println(field.get(per));// mary
            System.out.println(field2.get(per));// 23

            // 5 通过字节码文件再创建一个对象
            Object per1 = class1.newInstance();
            field.set(per1, "zhang");
            System.out.println(field.get(per1));// zhang
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.调用方法

public class Demo5 {
    public static void main(String[] args) {
        // 普通方法调用
        Person person = new Person();
//      person.run();
        //1 得到字节码文件
        Class<?> class1 = null;
        try {
            class1 = Class.forName("com.test.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        // 通过反射方法调用
        // 1.调用非静态的无参方法
        fun1(class1);
        // 2.调用非静态的有参方法
        fun2(class1);
        // 3.调用静态的有参方法
        fun3(class1);
    }
    // 1.调用非静态的无参方法
    public static void fun1(Class<?> cls) {
        try {
            //第一个参数：创建的方法名  第二个：方法参数的字节码文件对象 
            Method method = cls.getMethod("run");
            //创建实例对象
            Constructor<?> constructor = cls.getConstructor(String.class,int.class);
            Object per = constructor.newInstance("zhanggang",22);
            //实现方法的调用  第一个参数：方法所属的对象  第二个：方法参数
            method.invoke(per);//run方法没有参数，这个方法可以不传第二个参数
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 2.调用非静态的有参方法
    public static void fun2(Class<?> cls) {
        try {
            //第一个参数：创建的方法名  第二个：方法参数的字节码文件对象 
            Method method = cls.getMethod("eat",String.class);
            //创建实例对象
            Constructor<?> constructor = cls.getConstructor(String.class,int.class);
            Object per = constructor.newInstance("tom",22);

            //实现方法的调用  第一个参数：方法所属的对象  第二个：方法参数
            method.invoke(per,"苹果");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // 3.调用静态的有参方法
    public static void fun3(Class<?> cls) {
        try {
            //第一个参数：创建的方法名  第二个：方法参数的字节码文件对象 
            Method method = cls.getMethod("play",int.class);
            //实现方法的调用  第一个参数：方法所属的对象  第二个：方法参数
            method.invoke(null,22);//play()为静态方法，传null
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

小示例：
配置属性文件config.properties

vehicle0=com.vehicle.Bus
vehicle1=com.vehicle.Car
vehicle2=com.vehicle.Truck

/**
 * 定义一个交通工具接口
 * @ClassName vehicle
 * @Description 
 * @Author Handsome Zhang
 */
public interface vehicle {
    public void typeOfVehicle();//类型
    public void run();//交通工具开走
    public void stop();//停止
}

三类交通工具

public class Bus implements vehicle{

    @Override
    public void typeOfVehicle() {
        System.out.println("***公交车***");
    }

    @Override
    public void run() {
        System.out.println("***公交车运行***");
    }

    @Override
    public void stop() {
        System.out.println("***公交车停止***");
    }

}
public class Car implements vehicle{

    @Override
    public void typeOfVehicle() {
        System.out.println("---小汽车---");
    }

    @Override
    public void run() {
        System.out.println("---小汽车开走---");
    }

    @Override
    public void stop() {
        System.out.println("---小汽车停止---");
    }

}
public class Truck implements vehicle{

    @Override
    public void typeOfVehicle() {
        System.out.println("###货车###");
    }

    @Override
    public void run() {
        System.out.println("###货车开走###");
    }

    @Override
    public void stop() {
        System.out.println("###货车停止###");
    }

}

测试

public class VehiclaTest {
    public static void main(String[] args) {
        // 读取config.properties的内容
        Properties properties = new Properties();
        // 创建字符输入流
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("src/com/vehicle/config.properties");
            properties.load(fileInputStream);
            // properties.size()获得键值对个数
            for (int i = 0; i < properties.size(); i++) {
                String key = "vehicle" + i;
                String value = properties.getProperty(key);
                // 获取字节码文件对象
                Class<?> cls = Class.forName(value);
                // 创建实例对象
                 vehicle veh = (vehicle) cls.newInstance();
                veh.typeOfVehicle();
                veh.run();
                veh.stop();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

打印结果

***公交车***
***公交车运行***
***公交车停止***
---小汽车---
---小汽车开走---
---小汽车停止---
###货车###
###货车开走###
###货车停止###

上一篇：百度网盘就“用户激励计划”致歉

下一篇： java中的反射

java的反射机制

反射的原理

获取Class对象的方法

全面解释java中StringBuilder、StringBuffer、String类之间的关系

Java教程各种接口的介绍

java 学习笔记(入门篇)_java的基础语法

java在线运行工具（教你创建一个普通的 Java 项目）

java得到某年某周的第一天实现思路及代码

java编程规范题库（学习java需要的基础）

java流的概念（java代码大全及详解）

mac开发java的好处（mac搭建java开发环境的相关知识）

java获取指定开始时间与结束时间之间的所有日期

Java8 Comparator: 列表排序的深入讲解