Java反射编程

最新推荐文章于 2024-07-30 23:56:00 发布
最新推荐文章于 2024-07-30 23:56:00 发布
阅读量298 收藏 1
点赞数 1
分类专栏： Java反射编程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50743381/article/details/125245333
版权

Java反射编程

认识反射机制

1、反射机制简介

在Java语言里面之所以会有如此众多的开源技术支撑，很大的一部分是来自于Java最大的特征——反射机制

所有的技术实现的目标只有一点：重用性

对于反射技术首先来考虑的是“反”与“正”的操作，所谓的“正”操作指的是当我们要使用一个类的时候，一定要先导入包， 而后根据类进行对象的时候，并且依靠对象调用类中的方法，但是如果说“反”，根据实例化对象反推出其类型

如果要实现 反 的处理，那么首先要采用Object类中所提供的方法：

  • 获取类对象信息：public final CLass<?> getClass()

Class对象的使用

public class JavaDemo {
   public static void main(String[] args) {
      String string = new String();
      System.out.println(string.getClass());
   }
}

getClass()可以帮助使用者找到对象的根源

2、Class类对象的三种实例化模式

反射之中所有的核心操作都是通过Class类对象展开的，可以说Class类是:反射操作的根源所在，但是这个类如果要想获取它的实例化对象，可以采用三种方式完成

Class类定义：

  • public final class Classextends Object implements Serializable, GenericDeclaration, Type, AnnotatedElement

从JDK1.5开始Class类在定义的时候可以使用泛型进行标记，这样的用法这样的用法主要是希望可以避免所谓的向下转型

1、Object类支持

class Person{}
public class JavaDemo {
   public static void main(String[] args) {
      Person person = new Person();
      Class<? extends Person> aClass = person.getClass();
      System.out.println(aClass);
      System.out.println(aClass.getName());
   }
}
//class com.xialuote.Person
//com.xialuote.Person

如果只是要获得Class类对象，则必须先产生指定类对象后才可以获得

2、JVM支持（类.class）

class Person{}
public class JavaDemo {
   public static void main(String[] args) {
      Class<? extends Person> aClass = Person.class;
      System.out.println(aClass);
      System.out.println(aClass.getName());
   }
}

前提是需要导包

3、Class类支持

Class类提供的static方法：

public static Class<?> forName(String className)throws ClassNotFoundException

使用该方法：

public class JavaDemo {
   public static void main(String[] args) throws ClassNotFoundException {
      Class<?> aClass = Class.forName("com.xialuote.domain.Student");
      System.out.println(aClass);
      System.out.println(aClass.getName());
   }
}

这种模式最大的特点是可以直接采用字符串的形式定义要使用的类型，并且程序中不需要编写任何的import语句

反射应用案例

1、反射实例化对象

通过newInstance方法实例化Person类对象

public class Person {
   //任何情况下如果要实例化对象一定要调用类中的构造方法
   public Person() {
      System.out.println("这里是Person的构造方法");
   }
   
   @Override
   public String toString() {
      return "这里是Person的toString方法";
   }
}

测试类

public class JavaDemo {
   public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
      Class<?> aClass = Class.forName("com.xialuote.domain.Person");
      Object o = aClass.newInstance();
      System.out.println(o);
   }
}
//这里是Person的构造方法
//这里是Person的toString方法

通过反射实现的对象实例化处理，依然要调用类中的无参构造，其本质等价于“类对象= new 类()”，相当于隐含了关键字new 类，直接使用了字符串进行替代

当然，该方法在JDK1.9之后就被弃用了

因为默认的Class类中的newInstance()方法只能够调用无参构造，所以有开发者认为描述不准确，所以将其改变了形式

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      Class<?> aClass = Class.forName("com.xialuote.domain.Person");
      Object obj = aClass.getConstructor().newInstance();
      System.out.println(obj);
   }
}

2、反射与工厂设计模式

为什么要提供一个反射的实例化？到底是使用关键字new还是反射呢？

可以通过工厂设计模式来解决，工厂设计模式的最大特点：客户端的程序类不直接牵扯到对象的实例化管理，只与接口发生关联，通过工厂类获取指定接口的实例化对象

传统的工厂设计模式

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      IMessage message = new MessageImpl();
   }
}

interface IMessage{
   void send();
}
class MessageImpl implements IMessage{
   @Override
   public void send() {
      System.out.println("发送消息！");
   }
}

在实际的开发之中，接口的主要作用是为不同的层提供有一个操作的标准。但是如果此时直接将一个子类设置为接口实例化操作，那么一定会有耦合问题，所以使用工厂设计模式解决此问题

利用工厂设计模式解决问题

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      IMessage message = Factory.getInstance("netMessage");
      message.send();
   }
}

interface IMessage{
   void send();
}
class MessageImpl implements IMessage{
   @Override
   public void send() {
      System.out.println("发送消息！");
   }
}
class Factory{
   private Factory() {}    //没有产生实例化对象的意义，所以构造方法直接私有化
   public static IMessage getInstance(String className){
      if ("netMessage".equals(className)){
         return new MessageImpl();
      }
      return null;
   }
}

此种工厂设计模式属于静态工厂设计模式，也就是说如果现在要追加一个子类，则意味着工厂类一定要做出修改，因为如果不追加这种判断是无法获取指定接口对象的

例如如下代码

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      IMessage message = Factory.getInstance("cloudMessage");
      message.send();
   }
}

interface IMessage{
   void send();
}
class MessageImpl implements IMessage{
   @Override
   public void send() {
      System.out.println("发送消息！");
   }
}
class CloudMessageImpl implements IMessage {
   
   @Override
   public void send() {
      System.out.println("发送消息：Cloud");
   }
}
class Factory{
   private Factory() {}    //没有产生实例化对象的意义，所以构造方法直接私有化
   public static IMessage getInstance(String className){
      if ("netMessage".equals(className)){
         return new MessageImpl();
      } else if ("cloudMessage".equals(className)){
         return new CloudMessageImpl();
      }
      return null;
   }
}

工厂设计模式最有效解决的是子类与客户端的耦合问题，但是解决的核心思想是在于提供有一个工厂类作为过渡端，但是随着项目的进行IMessage接口有可能会有更多子类，那么每次有新的子类增加，工厂类就要作出修改，如果一直增加，那将永无止境的修改

此时最好的解决方法就是不使用关键字new来完成

而new Instance()方法只需要有一个类名称的字符串就可以使用

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      IMessage message = Factory.getInstance("com.xialuote.CloudMessageImpl");
      message.send();
   }
}

interface IMessage{
   void send();
}
class MessageImpl implements IMessage{
   @Override
   public void send() {
      System.out.println("发送消息！");
   }
}
class CloudMessageImpl implements IMessage {
   
   @Override
   public void send() {
      System.out.println("发送消息：Cloud");
   }
}
class Factory{
   private Factory() {}    //没有产生实例化对象的意义，所以构造方法直接私有化
   public static IMessage getInstance(String className){
      IMessage instance = null;
      try {
         instance = (IMessage) Class.forName(className).getDeclaredConstructor().newInstance();
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
      return instance;
   }
}

对于使用反射机制实现的工厂设计模式，最大的优势在于对于接口子类的扩充将不再影响到工厂类的定义

在实际的项目开发过程之中有可能会存在有大量的接口，并且这些接口都可能需要工厂类实例化，所以此时的工厂设计模式不应该只为一个IMessage接口服务，而应该变为为所有的接口服务

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      IMessage message = Factory.getInstance("com.xialuote.MessageImpl" , IMessage.class);
      message.send();
      IService service = Factory.getInstance("com.xialuote.MessageServiceImpl" , IService.class);
      service.service();
   }
}

interface IMessage{
   void send();
}
class MessageImpl implements IMessage{
   @Override
   public void send() {
      System.out.println("发送消息！");
   }
}

interface IService{
   void service();
}
class MessageServiceImpl implements IService {
   
   @Override
   public void service() {
      System.out.println("为消息服务！");
   }
}

class Factory{
   private Factory() {}    //没有产生实例化对象的意义，所以构造方法直接私有化
   
   /**
    * 获取接口实例化对象
    * @param className className 接口的子类
    * @param clazz clazz 描述的是一个接口的类型
    * @return 如果子类存在则返回指定接口实例化对象
    */
   @SuppressWarnings("unchecked")  //警告压制
   public static <T> T getInstance(String className , Class<T> clazz){
      T instance = null;
      try {
         instance = (T) Class.forName(className).getDeclaredConstructor().newInstance();
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
      return instance;
   }

此时的工厂设计模式依靠于泛型将不再受限于指定的接口，可以为所有的接口提供实例化服务

3、反射与单例设计模式

单例设计模式的核心本质在于:类内部的构造方法私有化，在类的内部产生实例化对象之后通过static方法获取实例化对象进行类中的结构调用，单例设计模式一共有两类：懒汉式、饿汉式。饿汉式的单例不在本次讨论之内。

懒汉式单例设计模式问题

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      for (int i = 0; i < 3; i++) {
         new Thread(() -> {
            Singleton.getInstance().print();
         } , "单例设计模式 - " + i).start();
      }
   }
}

class  Singleton {
   private static Singleton instance = null;
   private Singleton (){
      System.out.println("单例模式实例化成功");
   }
   public static Singleton getInstance() {
      if (instance == null) {
          instance = new Singleton();
      }
      return instance;
   }
   public void print(){
      System.out.println("输出消息");
   }
}
//单例模式实例化成功
//输出消息
//单例模式实例化成功
//输出消息
//单例模式实例化成功
//输出消息

单例设计模式的最大特点是在整体的运行过程之中只允许产生一个实例化，但是在多线程之中，依然会被创建多个实例化对象，所以这种单例设计模式明显是有问题的。

解决当前问题的关键在于同步处理，同步自然会想到synchronized关键字

修改getInstance()方法

public static synchronized Singleton getInstance() {
   if (instance == null) {
       instance = new Singleton();
   }
   return instance;
}

这个时候的确是进行了同步处理，但是这个同步的代价有些大，因为效率会变低。因为整体代码里面实际上只有一块部分需要进行同步处理，instance对象的实例化处理部分。因此synchronized并不能完美的解决问题

合理的进行同步处理

public class JavaDemo {
   public static void main(String[] args) throws Exception {
      for (int i = 0; i < 3; i++) {
         new Thread(() -> {
            Singleton.getInstance().print();
         } , "单例设计模式 - " + i).start();
      }
   }
}

class  Singleton {
   private static volatile Singleton instance = null;
   private Singleton (){
      System.out.println("单例模式实例化成功");
   }
   public static synchronized Singleton getInstance() {
      if (instance == null) {
         synchronized (Singleton.class){
            if (instance == null) {
               instance = new Singleton();
            }
         }
      }
      return instance;
   }
   public void print(){
      System.out.println("输出消息");
   }
}
//单例模式实例化成功
//输出消息
//输出消息
//输出消息

面试题：

  • 请编写单例设计模式？编写一个饿汉式的单例设计模式，并且实现构造方法私有化
  • 在Java中那里使用到了单例设计模式？Runtime类、Spring框架
  • 懒汉式单例设计模式中存在的问题？ 多线程问题，答案为上述代码

下一篇：反射与类操作

MyRedScarf
关注
专栏目录
编程语言中的反射机制
weixin_43369409的博客
04-08 1万+
     今天在开发的过程中需要把两个类似产品的代码进行合并，减少代码的维护量，同时可以减少物料的维护成本。      两个产品只是一个通信用结构体内的元素有些区别，结构体相同元素的便宜地址发生了变化，同时增加了一些元素。      在设计之初应该考虑到升级的问题，应该做到通信地址兼容，不改变原来的通信地址，...
Java高级编程：反射
soulmate______的博客
08-16 625
文章目录本章的主要内容关于反射的理解体会反射机制的“动态性”反射机制能提供的功能相关APIClass类的理解与获取Class的实例Class类的理解获取Class实例的几种方式：（前三种方式需要掌握）总结：创建类的对象的方式Class实例可以是哪些结构的说明了解ClassLoader类的加载过程----了解类的加载器的作用类的加载器的分类Java类编译、运行的执行的流程使用Classloader加载src目录下的配置文件反射应用一：创建运行时类的对象说明反射应用二：获取运行时类的完整结构反射应用三：调用运行
JAVA里的反射（详解）
最新发布
weixin_65752158的博客
07-30 1126
是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。通俗的理解：（掌握）利用反射创建的对象可以无视修饰符调用类里面的内容可以跟配置文件结合起来使用，把要创建的对象信息和方法写在配置文件中。读取到什么类，就创建什么类的对象读取到什么方法，就调用什么方法此时当需求变更的时候不需要修改代码，只要修改配置文件即可。
Java编程的动态性--03应用反射
xiaoning19840703的专栏
05-23 443
2003 年 9 月 25 日命令行参数处理是一项令人厌烦的零碎工作，不管您过去已经处理过多少次了，它好像总能重新摆在您的面前。与其一遍又一遍地编写同一块代码的不同变种，为什么不利用反射来简化参数处理的工作呢？Java 顾问 Dennis Sosnoski 向您展示了如何做到这一点。在本文中，Dennis 简明扼要地介绍了一个开源库，这个库可以使得命令行参数实际上自己处理自己。在 上个月的
Java的反射编程
鲲鹏化羽
11-15 588
Java的反射编程 Reflection 一、反射编程对Java编程有深远的影响：获得类的基因信息，创建对象，调用方法。  (1)获得类型的基因信息(class类型的对象)  (2)根据该基因信息探察出类属性和方法   (类的所有细节，修饰符、包名、方法名...)  (3)根据该基因信息能“克隆”实例化该类的对象  (4)能够调用对象的属性和方法   二、Class类 ja
粗浅看java反射机制编程开发技术共27页.pdf.zip
12-02
Java反射机制是Java编程语言中的一个强大工具，它允许程序在运行时检查并操作类、接口、字段和方法等对象。在"粗浅看java反射机制编程开发技术共27页.pdf.zip"这个压缩包中，很显然，内容将深入探讨Java反射的基本...
Java编程反射机制用法入门与实例总结
08-28
Java反射机制是一种强大的机制，可以在运行时动态获取类的信息和调用类中的方法。下面将对Java反射机制的概念、原理和简单使用方法进行详细的介绍。 一、Java反射机制的概念 Java反射机制是指在Java程序中可以动态...
java基础编程必须知道的：SPI、反射、位运算
08-09
Java基础编程涵盖了许多核心概念，其中包括SPI（Service Provider Interface）、反射和位运算。这些特性都是Java强大灵活性的关键组成部分。 SPI（Service Provider Interface）是Java的一种服务发现机制，它允许...
Java SE编程入门教程 java反射机制（共16页）.pptx
12-04
Java SE编程入门教程涵盖了许多Java基础知识，其中包括对Java反射机制的讲解。反射是Java中一个强大的功能，它允许程序在运行时动态地获取类的信息并进行操作。这使得Java能够实现一些灵活的功能，如动态加载类、...
Java反射在实际工作中的应用笔记
08-28
通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的编程方式。在实际工作中，Java反射的应用非常广泛，例如在测试工具、插件系统、依赖注入等领域都可以看到Java反射的身影。...
Java高级编程：反射机制
王明晓的博客
02-22 514
1.反射机制 反射指的是可以于运行时加载、探知、使用编译期间完全未知的类 程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法，对于任意对象都能够调用它的任一方法和属性 Class c = Class.forName(&amp;amp;amp;quot;com.wmx.test.User&amp;amp;amp;quot;); 加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只有一个Clas...
java高级编程之反射
weixin_52365243的博客
12-07 346
就像我上面所画的图，反射就相当于一个逆过程，比如我们正常的创建一个对象是通过 但如果我们想通过反射创建一个对象就需要这样 1.2对反射的深入理解 能够分析类能力的程序称为反射，反射机制的功能极其强大反射可以用来： 1.在运行时分析类的能力 2.在运行时检查对象，例如编写一个适用于所有类的toString方法 3.
Go-反射编程
袋鼠的博客
07-15 509
反射类型：reflect.TypeOf() 反射值：reflect.Value() reflect.ValueOf() 只会返回一个值； reflect.TypeOf()可以返回两个值，第二个值可以用来判断这个值有没有。 kind() 可以对反射回来的类型做判断值。 reflect.TypeOf(s).FieldByName("Name")； 调用 reflect.ValueOf(s).FieldByName() 方法，必须是结构体进行调用。 调用 reflect.ValueOf(&s).MethodB
Java基础回顾系列-第八天-高级编程之反射编程
java
04-25 324
Java基础回顾系列-高级编程之反射编程认识反射机制Class类对象的三种实例化模式 认识反射机制 要想理解反射的原理，首先要了解什么是类型信息。Java让我们在运行时识别对象和类的信息，主要有2种方式：一种是传统的RTTI，它假定我们在编译时已经知道了所有的类型信息；另一种是反射机制，它允许我们在运行时发现和使用类的信息。 每个类都会产生一个对应的Class对象，也就是保存在.class文件。...
Java编程基础-反射
終有、過去
12-05 3710
一、java反射 1、反射：动态获取类的信息，以及动态调用对象的方法的功能。可以理解为动态看透类的能力。 2、主要功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。 通过java反射机制，可以在程序中访问已经装载到JVM中的java对象的描述，实现访问、检测和修改描述java对
Java 反射编程(上)
Beyond_Nothing
01-01 2774
文章目录**反射的泛型就是用 `? `来描述**反射与类的操作 (取得父类信息)取得父类信息1. 获得本类的包名称:2. 取得父类的Class 对象3. 取得父类接口案例: 使用上述方法反射与类的操作 (反射调用构造)反射调用构造1. 取得指定参数类型的构造2. 取得类中的所有构造`实例化对象: `案例: 取得类中的所有构造方法信息.改进: 使用getName() 方法取得构造方法完整信息案例实现: 自己拼凑构造方法重点:案例: 观察 Class 实例化对象的问题案例: 要通过 Constructor 类实
动态编程（一）：反射
Justin·AndLin
01-04 498
一、反射机制 1.1概念 在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 主要提供了以下功能： 在运行时判断任意一个对象所属的类。 在运行时构造任意一个类的对象。 在运行时判断任意一个类所具有的成员变量和方法。 在运行时调用任意一个对象的方法 1.2应用场...
Java-反射
Ego_Ekko的博客
09-24 594
1）Class也是类，同样也继承了Object类；2）Class类对象不是new出来的，而是系统创建的；3）对于某个类的Class类对象，在内存中只有一份，因为类只加载一次；4）每个类的实例都会记住自己是由哪个Class实例所生成；5）通过Class对象可以完整地得到一个类的完整结构，通过一系列API；6）Class对象是存放在堆中的；7）类的字节码二进制数据是放在方法区的，有的地方也称为类的元数据（包含方法代码、变量名、方法名、访问权限等）。
深入理解Java反射机制
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。这一机制使得Java具有高度的灵活性和强大的功能，尤其在框架开发、插件系统、元数据处理等方面发挥着关键作用。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MyRedScarf

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

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

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

打赏作者

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

抵扣说明：

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

余额充值