Java反射

霸王龙骨架带走渡渡鸟

于 2022-04-08 12:45:00 发布

阅读量112

点赞数 1

分类专栏： Java数据结构文章标签： java 反射

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/PepDokHa/article/details/124022261

版权

Java数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细讲解了Java反射的定义、基本原理，展示了如何使用Class类获取和操作类的属性、构造器、方法，以及反射在创建对象、访问私有成员和框架应用中的实例。同时探讨了反射的优缺点，适用于提高程序灵活性和扩展性。

摘要由CSDN通过智能技术生成

目录

反射的定义

反射的基本信息

反射相关的类

Class类中的相关方法

常用获得类相关的方法

常用获得类中属性相关的方法(以下方法返回值为Field相关)

获得类中注解相关的方法

获得类中构造器相关的方法（以下方法返回值为Constructor相关）

获得类中方法相关的方法（以下方法返回值为Method相关）

获得class对象的三种方式

反射的使用

反射私有的构造方法

反射私有的属性

反射私有方法

反射的优点和缺点

反射的定义

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。

反射的基本信息

Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = newStudent()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。

反射相关的类

Class类

Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类

Class类中的相关方法

常用获得类相关的方法

常用获得类中属性相关的方法(以下方法返回值为Field相关)

获得类中注解相关的方法

获得类中构造器相关的方法（以下方法返回值为Constructor相关）

获得类中方法相关的方法（以下方法返回值为Method相关）

反射示例

获得class对象的三种方式

第一种，使用 Class.forName("类的全路径名"); 静态方法。前提：已明确类的全路径名。

第二种，使用 .class 方法。说明：仅适合在编译前就已经明确要操作的 Class

第三种，使用类对象的 getClass() 方法

package refelectdemo;

class Student{
    //私有属性name
    private String name = "bit";
    //公有属性age
    public int age = 18;
    //不带参数的构造方法
    public Student(){
        System.out.println("Student()");
    }

    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }

    private void eat(){
        System.out.println("i am eat");
    }

    public void sleep(){
        System.out.println("i am pig");
    }

    private void function(String str) {
        System.out.println(str);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}



public class Test {

    public static void main1(String[] args) throws ClassNotFoundException{
        //1、获取一个Class对象
        Class<?> c1 = Class.forName("refelectdemo.Student");

        Class<?> c2 = Student.class;

        Student student = new Student();
        Class<?> c3 = student.getClass();

        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c2.equals(c3));
        //输出都为true
        //Class对象  只有1个
    }
}

反射的使用

创建对象

package refelectdemo;

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

public class ReflectClassDemo {

    // 创建对象
    public static void reflectNewInstance() {
        try {
            Class<?> c1 = Class.forName("refelectdemo.Student");

            Student student = (Student)c1.newInstance();

            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectNewInstance();
    }
}

反射私有的构造方法

package refelectdemo;

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

public class ReflectClassDemo {

    // 反射私有的构造方法  屏蔽内容为获得公有的构造方法
    public static void reflectPrivateConstructor() {
        try {
            Class<?> c1 = Class.forName("refelectdemo.Student");

            Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class);

            //私有的本身是封装的,
            constructor.setAccessible(true);

            Student student = (Student)constructor.newInstance("bit",19);

            System.out.println(student);

        } catch (ClassNotFoundException e) {

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateConstructor();
    }

}

反射私有的属性

package refelectdemo;

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

public class ReflectClassDemo {
    
    // 反射所有的，用私有属性来举例
    public static void reflectPrivateField() {
        try {
            Class<?> c1 = Class.forName("refelectdemo.Student");

            Student student = (Student)c1.newInstance();

            Field field = c1.getDeclaredField("name");

            field.setAccessible(true);
            //student对象的field字段，设置为zhangsan值
            field.set(student,"zhangsan");

            System.out.println(student);

        } catch (ClassNotFoundException e) {

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateField();
    }

}

反射私有方法

package refelectdemo;

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

public class ReflectClassDemo {

    // 反射私有方法
    public static void reflectPrivateMethod() {
        try {
            Class<?> c1 = Class.forName("refelectdemo.Student");

            Student student = (Student)c1.newInstance();

            //方法名称    方法的参数
            Method method = c1.getDeclaredMethod("function", String.class);

            method.setAccessible(true);

            method.invoke(student,"我是function的参数！");

        } catch (ClassNotFoundException e) {

        }  catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateMethod();
    }
}

反射的优点和缺点

优点

1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法

2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力

3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点

1. 使用反射会有效率问题。会导致程序效率降低。

2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂

霸王龙骨架带走渡渡鸟

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java反射

Java反射机制详解
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。