JAVA 反射

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量575 收藏
点赞数
分类专栏： 初学Java JavaWeb 文章标签： java p2p linq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58765786/article/details/121753435
版权


   反射：
       在程序运行时动态的获取类中的属性方法等内容的机制，叫反射。
       
    
    反射中要用到Class类
    
       获取Class类对象的三种方式
       
           1、类名.class
              User.class
           2、对象.getClass()
           3、Class.forName("全类名");
           
        获取类的内容
        
           1、包  class.getPackage();
           2、类名  class.getSimpleName();  
           3、全类名 class.getName();
           4、获取属性
                 公共属性（本类及父类） class.getFields();   Fields[] 
                 所有属性 （本类）      class.getDecalaredFields();
                 
                 修饰符：field.getModifiers(); //返回int值，Modifier.toString(field.getModifiers());
                 类型：  field.getType();
                 属性名：field.getName();
                 
                 获取指定的公共属性：field.getField("属性名");
           
           5、获取方法
                 公共方法 （本类及父类） class.getMethods();
                 所有方法  （本类）      class.getDecalaredMethods();
                 
                 修饰符：method.getModifiers();
                 返回值类型：method.getReturnType();
                 方法名：method.getName();
                 方法的参数类型： method.getParameterType();
                 
                 获取指定的公共方法对象：class.getMethod("eat",可变参数类型);
                 获取指定的私有方法对象：class.getDecalaredMethod("run",可变参数类型);
                 Method method = class.getMethod("eat",可变参数类型);
                
                调用执行：method.invoke("被执行方法所属对象"，具体参数);

---------------------------------------------------------------------------------------------------------------------------------

反射

1. 反射定义
                

反射即反向探知,有点像考古学家发掘的物品来探知以前的事情。


                 
           

 程序中的反射指程序运行状态中 :

1. 对于给定的一个类(class)对象,可以获得这个类(class)对象所有属性和方法;

2. 对于给定的一个对象(new xxxClassName<? extends Object>), 都能够拥有它的任意一个属性和方法。

这种动态获取类的内容以及动态调用对象的方法和获取属性的机制,就叫做 Java反射机制

2. 反射初始

public class User {
    public void eat(){
        System.out.println("---eat---");
    }
}
public class TestReflect{
    public static void main(String[] args) throws Exception {
        Class<User> clazz = User.class;
        //获取类对象对应的属性和方法
        System.out.println(clazz.getName());
        System.out.println(clazz.getPackage());
        System.out.println(clazz.getSuperclass());
        System.out.println(clazz.getClassLoader());
        //获取一个对象实例
        User user = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("eat");
        method.invoke(user);
    }

3. 为何用反射

直接 new User()不就可以了,为什么要用这种反射写法?

实例化一个User()对象,不使用反射,如果想再实例化其他对象比如 new Person(),那么就需要修改源代码,并且重新编译,使用反射后就不需要修改源代码只需要灵活改动类描述就可以了,不需要重新再编译。如下代码所示:

   //类描述，可根据需要实例化的描述而改动
    String className = "com.tledu.pojo.User";
    //使用反射中API创建对象
    Class.forName(className).newInstance();

4. 反射的优缺点

优点:

        增加程序的灵活性,避免固有逻辑写死的程序中

        代码相对简洁,可以提高程序的复用性

缺点:

        相比于直接调用反射有比较大的性能销毁

        内部暴露和安全隐患

4.1 灵活性测试

public interface Ball {
        void playBall();
    }
    public class BasketBall implements Ball{
        @Override
        public void playBall() {
            System.out.println("打篮球");
        }
    }
    public class FootBall implements Ball{
        @Override
        public void playBall() {
            System.out.println("踢足球");
        }
    }
    //----------------------------
    public static void main(String[] args) {
       //System.out.println(getInstanceByKey("basket"));
        System.out.println(getInstanceReflectByKey("FootBall"));
    }
    public static Ball getInstanceByKey(String key) {
        if("foot".equals(key)){
            return new FootBall();
        }
        if("basket".equals(key)){
            return new BasketBall();
        }
        return null;
    }

如果我们想在添加一个乒乓球那么除了创建一个乒乓球类，还需要在方法中加入获取乒乓球对应的判断和乒乓球创建对象的返回，很显然不够灵活出现了写死代码的情况。

public static Ball getInstanceReflectByKey(String key) {
        String basePackage = "com.tledu.mjw";
        Ball ball = null;
        try {
            Class clazz = Class.forName(basePackage + "." + key);
            ball = (Ball)clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ball;
    }

使用反射的方式获取对象，可以看出代码灵活了很多而且不需要改动创建返回对象的源码。

4.2 性能测试

public static void main(String[] args) {
       //System.out.println(getInstanceByKey("basket"));
       //System.out.println(getInstanceReflectByKey("FootBall"));
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++){
            getInstanceByKey("basket");
            //getInstanceReflectByKey("FootBall");
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));
    }

为什么这么慢呢？（分别查看forName()方法和newIntance()方法源码分析）

1、调用了native方法

2、每次调用newInstance()方法都会做安全检查，比较耗时

5. 反射的操作

 5.1 获取类对象的四种方式

//获取类对象的四种方式
Class<User> clazz1 = User.class;
Class<?> clazz2 = Class.forName("com.tledu.mjw.User");
Class<? extends User> clazz3 = new User().getClass();
Class<?> clazz4 = Demo3.class.getClassLoader().loadClass("com.tledu.mjw.User");

5.2 类中基本信息的获取

System.out.println(clazz1.getClassLoader());
System.out.println(clazz1.getSuperclass());
System.out.println(clazz1.getPackage());
System.out.println(clazz1.getModifiers()); //获取类的修饰符
System.out.println(clazz1.getName());
System.out.println(clazz1.getSimpleName());
System.out.println(clazz1.getInterfaces().length);//获取类实现的所有接口
System.out.println(clazz1.getAnnotations().length);

5.3 类中字段的操作

创建User类继承Person类添加相应属性

public class Person {
    public String idCard;
    private String userName;
}
public class User extends Person{
    private String name;
    public String sex;
    public static String address;
    public void eat(){
        System.out.println("---eat---");
    }
}

测试方法调用

public static void main(String[] args) throws Exception {
    Class<User> userClass = User.class;
    User user = userClass.newInstance();
    //getFields()获取的是本类及父类中的公共属性
    Field[] fields = userClass.getFields();
    for (Field field : fields) {
        System.out.println(field.getModifiers() + " " + field.getName());
    }
    System.out.println("---------------");
    //getDeclaredFields()获取本类中的所有属性
    Field[] fields2 = userClass.getDeclaredFields();
    for (Field field : fields2) {
        System.out.println(field.getModifiers() + " " + field.getName());
    }
    System.out.println("---------------");
    //获取name字段对应的field
    Field nameField = userClass.getDeclaredField("name");
    //如果需要修改私有属性信息那么我们要放开权限
    nameField.setAccessible(true);
    nameField.set(user,"天亮教育");
    System.out.println(nameField.get(user));
    //System.out.println(user.getName());
    System.out.println("---------------");
    //如何对静态的属性赋值
    Field addressField = userClass.getDeclaredField("address");
    addressField.set(null,"Jack");
    System.out.println(addressField.get(null));
    //System.out.println(User.address);
}

5.4 类中方法的操作

在User类中将eat方法改为私有的,并添加静态方法 say

private void eat(){
    System.out.println("---eat---");
}
public static void say(String msg){
    System.out.println(msg);
}

在Person类中添加共有的fn1()方法和私有的fn2()方法

public void fn1(){}
private void fn2(){}

测试方法调用

public static void main(String[] args) throws Exception {
    Class<User> userClass = User.class;
    User user = userClass.newInstance();

    //获取本类及父类中的公共方法
    Method[] methods1 = userClass.getMethods();
    for (Method method : methods1) {
        System.out.println(method.getModifiers() + " " + method.getName());
    }
    System.out.println("--------------");
    //获取本类中所有的方法包括私有
    Method[] methods2 = userClass.getDeclaredMethods();
    for (Method method : methods2) {
        System.out.println(method.getModifiers() + " " + method.getName());
    }
    System.out.println("--------------");
    //调用方法执行
    Method eatMethod = userClass.getDeclaredMethod("eat");
    //调用私有方法时要先开放权限
    eatMethod.setAccessible(true);
    eatMethod.invoke(user);
    System.out.println("--------------");
    //调用静态的方法
    Method sayMethod = userClass.getDeclaredMethod("say",String.class);
    sayMethod.invoke(null,"你好");
}

5.5 类中构造器的操作

在User中添加如下构造方法

public User() {
}
public User(String name) {
    this.name = name;
}
private User(String name,String sex) {
    this.name = name;
    this.sex = sex;
}

通过反射操作User中的构造方法

public static void main(String[] args) throws Exception {
    Class<User> userClass = User.class;
    //获取公共的构造器
    Constructor<?>[] constructors = userClass.getConstructors();
    for (Constructor<?> constructor : constructors) {
        System.out.println(constructor.getModifiers() + " " + constructor.getName());
    }
    System.out.println("------------------");
    //获取所有的构造器
    Constructor<?>[] declaredConstructors = userClass.getDeclaredConstructors();
    for (Constructor<?> declaredConstructor : declaredConstructors) {
        System.out.println(declaredConstructor.getModifiers() + "  " + declaredConstructor.getName());
    }
    //1、直接通过newInstance创建对象
    User user = userClass.newInstance();
    //2、获取对应的Constructor对象获取实例
    Constructor<User> constructor = userClass.getDeclaredConstructor(String.class, String.class);
    //操作私有的构造器要先打开权限
    constructor.setAccessible(true);
    User user1 = constructor.newInstance("乔森", "男");
}

6. 反射破局单例

单例模式

public class PersonSingle {
    private static PersonSingle instance = null;
    private PersonSingle(){}
    public static PersonSingle getInstance(){
        if(instance == null){
            instance = new PersonSingle();
        }
        return instance;
    }
}

测试单例、通过反射可以调用私有构造

public static void main(String[] args) throws Exception {
    PersonSingle instance1 = PersonSingle.getInstance();
    PersonSingle instance2 = PersonSingle.getInstance();
    PersonSingle instance3 = PersonSingle.getInstance();
    System.out.println(instance1);
    System.out.println(instance2);
    System.out.println(instance3);
    System.out.println("---------------------");
    Class<PersonSingle> personSingleClass = PersonSingle.class;
    Constructor<PersonSingle> declaredConstructor = personSingleClass.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    System.out.println(declaredConstructor.newInstance());
}

改进单例如下

private PersonSingle(){
    if(instance != null){
        throw new RuntimeException("实例已经存在不允许再创建")
    }

7. 反射使用场景

 1、jdbc封装

 2、SpringIOC

 3、JdbcTemplate

4、Mybatis

...................   

Iiversse
关注
专栏目录
java getinstance 反射_Java 基础篇之反射
weixin_42522857的博客
02-16 611
使用反射获取程序运行时的对象和类的真实信息。获取 Class 对象每个类被加载之后，系统会为该类生成一个对应的 Class 对象，通过该 Class 对象可以访问到 JVM 中的这个类。使用 Class 类的 forName(String clazzName) 静态方法。字符串参数的值是某个类的全限定类名，必须包含完整的包名调用某个类的 class 属性调用某个对象的 getClass() 方法。...
java getinstance 反射_【反射】Java反射机制
weixin_36011776的博客
02-16 612
Class1、Class是一个类，一个描述类的类(也就是描述类本身)，封装了描述方法的Method，描述字段的Filed，描述构造器的Constructor等属性2、对象照镜子后(反射)可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。3、对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。4、Class...
java反射机制基础详解
weixin_30745641的博客
04-23 158
java反射机制基础详解 1. ji什么是Java的反射？ 要让Java程序能够运行，就得让Java类被Java虚拟机加载。Java类如果不被Java虚拟机加载就不能正常运行。正常情况下，我们运行的所有的程序在编译期时候就已经把那个类被加载了。 Java的反射机制是在编译时并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用的是在编译期并不知道的类。这样...
Java高级编程：反射
soulmate______的博客
08-16 621
文章目录本章的主要内容关于反射的理解体会反射机制的“动态性”反射机制能提供的功能相关APIClass类的理解与获取Class的实例Class类的理解获取Class实例的几种方式：（前三种方式需要掌握）总结：创建类的对象的方式Class实例可以是哪些结构的说明了解ClassLoader类的加载过程----了解类的加载器的作用类的加载器的分类Java类编译、运行的执行的流程使用Classloader加载src目录下的配置文件反射应用一：创建运行时类的对象说明反射应用二：获取运行时类的完整结构反射应用三：调用运行
java getinstance 反射_深入分析JAVA 反射和泛型
weixin_39830012的博客
02-13 201
从 JDK5 以后，Java 的 Class 类增加了泛型功能，从而允许使用泛型来限制 Class 类，例如，String.class 的类型实际上是 Class。如果 Class 对应的类暂时未知，则使用 Class>。通过在反射中使用泛型，可以避兔使用反射生成的对象需要强制类型转换。泛型和 Class 类使用 Class 泛型可以避免强制类型转换。例如，下面提供一个简单的对象工厂，该对象...
java反射
专栏
05-13 1015
反射 主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。 反射本质就是把一个java类中所有的成分封装成对象,然后对这些对象进行操作。
java 反射
12-22
这种动态获取信息以及动态调用对象方法的功能成为java反射机制。 2. java 文件和 .class 文件的关系 java 文件 java文件中包含代码的所有内容，类，接口，成员变量，成员方法.... .class 字节码文件 .class 是由 ...
Java反射技术详解及实例解析
08-18
Java反射技术是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、对象等的内部信息，包括但不限于类名、方法、字段等。这种能力使得Java程序具有高度的灵活性和动态性，是许多高级框架和库的...
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
JAVA反射
03-18
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制主要由java.lang.Class、java.lang.reflect.Method、java.lang.reflect.Field和...
Java反射技术原理与用法实例分析
08-19
Java反射技术原理与用法实例分析 Java反射技术是Java语言中的一种动态语言技术，能够在运行时解析外部对象的信息。通过反射技术，可以动态地获取类以及类中的成员，并可以调用该类成员。 产生反射技术的需求： 在...
java getinstance 反射_JAVA类加载和反射介绍
weixin_32736623的博客
02-16 420
简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息.反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。当程序主动使用某个类时，若该类还没加载到内存中，系统会通过加载，链接，初始化3个操作对类进行初始化。类字面常量”,class”创建Class对象的引用...
java的反射
m0_47624935的博客
07-01 108
反射的概述 Java的反射机制：是指在运行去获取一个类的变量和方法信息，然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用再编译期就完成确定，在运行期仍然可以扩展。 通过反射获取到构造方法： 先说只能获取到一个构造方法的方法： Class c=Class.forName("Reflect.Student");//引号中的为学生类的路径 Constructor con=c.getConstructor();//获取无参构造方法 Student
java反射(二)--反射应用案例
b068742459863074的博客
08-28 149
一.反射实例化对象 　　经过一系列的分析之后发现虽然可以获取Class类的实例化对象,但是依然觉得这个对象的获取意义不是很大,因此可以通过以下几个案例去理解反射的核心意义--反射实例化对象:获取Class对象之后最大的意义并不是在于只是一个对象的实例化操作形式,更重要的是Class类中提供有一个对象的反射实例化方法,在JDK1.9之前的实例化:public T newInstance(...
Java反射机制
qq_50791983的博客
12-03 320
反射，反射API，CLass类全限定类名说明Class类四种创建方式简单使用并解释其他API注解+反射（简单应用实例） Java反射体现出了Java的动态性，就是在Java运行期间直接对任意对象进行操作，比如属性、方法。反射概念是非常抽象的^o^,假设我们做一件事都有一个计划我们就按照计划行事（这相当于我们写的代码一行一行执行下去），当遇见特殊情况之前计划不能实施了我们就需要见机行事灵活实施（这里灵活变通就是反射，就是动态的把事情处理了），通过下面反射API的代码可以进一步了解反射
java getinstance 反射_JAVA反射机制实例
weixin_39931923的博客
02-13 250
importjava.lang.reflect.Constructor;importjava.lang.reflect.Field;importjava.lang.reflect.InvocationTargetException;importjava.lang.reflect.Method;public classRefletTest {/***@paramargs*@throwsClassNo...
Java-网络
最新发布
2301_81543552的博客
09-14 481
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
深入理解Java反射机制
"Java反射机制是Java编程中的重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。通过Java反射，开发者可以在不知道具体类名的情况下，对类进行实例化，调用方法，访问和修改属性，实现更加灵活的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Iiversse

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值