Java23种设计模式（三）

最新推荐文章于 2024-07-17 14:19:40 发布

七夜琉璃

最新推荐文章于 2024-07-17 14:19:40 发布

阅读量521

点赞数 26

分类专栏： Java设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/qiyeliuli/article/details/139768121

版权

Java设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

装饰器模式通过将对象包装在装饰器类中，以便动态地修改其行为。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

1.1、主要解决的问题

避免通过继承引入静态特征，特别是在子类数量急剧膨胀的情况下。
允许在运行时动态地添加或修改对象的功能。

1.2、使用场景

当需要在不增加大量子类的情况下扩展类的功能。
当需要动态地添加或撤销对象的功能。

2、外观模式

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

为一个复杂的子系统提供一个一致的高层接口。这样，客户端代码就可以通过这个简化的接口与子系统交互，而不需要了解子系统内部的复杂性。

2.1、实现方式

创建外观类：定义一个类（外观），作为客户端与子系统之间的中介。
封装子系统操作：外观类将复杂的子系统操作封装成简单的方法。

2.2、应用实例

医院接待：医院的接待人员简化了挂号、门诊、划价、取药等复杂流程。
Java三层架构：通过外观模式，可以简化对表示层、业务逻辑层和数据访问层的访问。

2.3、优点

减少依赖：客户端与子系统之间的依赖减少。
提高灵活性：子系统的内部变化不会影响客户端。
增强安全性：隐藏了子系统的内部实现，只暴露必要的操作。

3、享元模式

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

主要解决的问题

避免因创建大量对象而导致的内存溢出问题。
通过共享对象，提高内存使用效率。

使用场景

当系统中存在大量相似或相同的对象。
对象的创建和销毁成本较高。
对象的状态可以外部化，即对象的部分状态可以独立于对象本身存在。

4、代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能，这种类型的设计模式属于结构型模式。

代理模式通过引入一个代理对象来控制对原对象的访问。代理对象在客户端和目标对象之间充当中介，负责将客户端的请求转发给目标对象，同时可以在转发请求前后进行额外的处理。

为其他对象提供一种代理以控制对这个对象的访问。

优点

职责分离：代理模式将访问控制与业务逻辑分离。
扩展性：可以灵活地添加额外的功能或控制。
智能化：可以智能地处理访问请求，如延迟加载、缓存等。

缺点

性能开销：增加了代理层可能会影响请求的处理速度。
实现复杂性：某些类型的代理模式实现起来可能较为复杂。

与适配器模式的区别：适配器模式改变接口，而代理模式不改变接口。
与装饰器模式的区别：装饰器模式用于增强功能，代理模式用于控制访问。

实现
我们将创建一个 Image 接口和实现了 Image 接口的实体类。ProxyImage 是一个代理类，减少 RealImage 对象加载的内存占用。

ProxyPatternDemo 类使用 ProxyImage 来获取要加载的 Image 对象，并按照需求进行显示。
在这里插入图片描述
步骤 1
创建一个接口。

Image.java
public interface Image {
   void display();
}

步骤 2
创建实现接口的实体类。

RealImage.java
public class RealImage implements Image {
 
   private String fileName;
 
   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }
 
   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }
 
   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}

ProxyImage.java
public class ProxyImage implements Image{
 
   private RealImage realImage;
   private String fileName;
 
   public ProxyImage(String fileName){
      this.fileName = fileName;
   }
 
   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}

步骤 3
当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。

ProxyPatternDemo.java
public class ProxyPatternDemo {
   
   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");
 
      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   }
}

步骤 4
执行程序，输出结果：

Loading test_10mb.jpg
Displaying test_10mb.jpg

Displaying test_10mb.jpg

5、责任链模式

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

责任链模式通过将多个处理器（处理对象）以链式结构连接起来，使得请求沿着这条链传递，直到有一个处理器处理该请求为止。

责任链模式允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

主要解决的问题
解耦请求发送者和接收者，使多个对象都有可能接收请求，而发送者不需要知道哪个对象会处理它。

使用场景
当有多个对象可以处理请求，且具体由哪个对象处理由运行时决定时。
当需要向多个对象中的一个提交请求，而不想明确指定接收者时。

实现方式
定义处理者接口：所有处理者必须实现同一个接口。
创建具体处理者：实现接口的具体类，包含请求处理逻辑和指向链中下一个处理者的引用。

在Java Web开发中，责任链模式有广泛应用，如过滤器链、拦截器等。

6、命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。

命令模式将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。

命令模式结构示意图:

在这里插入图片描述
将请求封装为一个对象，允许用户使用不同的请求对客户端进行参数化。

实现方式

定义命令接口：所有命令必须实现的接口。
创建具体命令：实现命令接口的具体类，包含执行请求的方法。
调用者：持有命令对象并触发命令的执行。
接收者：实际执行命令的对象。

当需要对行为进行记录、撤销/重做或事务处理时，使用命令模式来解耦请求者和执行者。

7、解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。

解释器模式给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

这种模式被用在 SQL 解析、符号处理引擎等。

当某一特定类型的问题频繁出现，并且可以通过一种简单的语言来表达这些问题的实例时。

应用实例

编译器：解释器模式可以用于编译器设计，将源代码解释为目标代码。
正则表达式：解释器模式可以用于解析和执行正则表达式。
SQL解析：解释器模式可以用于解析和执行SQL语句。

8、迭代器模式

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。
迭代器模式属于行为型模式。
允许顺序访问一个聚合对象中的元素，同时不暴露对象的内部表示。

应用实例
Java中的Iterator：Java集合框架中的迭代器用于遍历集合元素。
优点

支持多种遍历方式：不同的迭代器可以定义不同的遍历方式。
简化聚合类：聚合类不需要关心遍历逻辑。
多遍历支持：可以同时对同一个聚合对象进行多次遍历。
扩展性：增加新的聚合类和迭代器类都很方便，无需修改现有代码。

实例可参考
https://blog.csdn.net/qiyeliuli/article/details/54933483

9、中介者模式

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性，属于行为型模式。

中介者模式定义了一个中介对象来封装一系列对象之间的交互。中介者使各对象之间不需要显式地相互引用，从而使其耦合松散，且可以独立地改变它们之间的交互。

通过引入一个中介者对象来封装和协调多个对象之间的交互，从而降低对象间的耦合度。

MVC框架：控制器作为模型和视图的中介者。
实现
我们通过聊天室实例来演示中介者模式。实例中，多个用户可以向聊天室发送消息，聊天室向所有的用户显示消息。我们将创建两个类 ChatRoom 和 User。User 对象使用 ChatRoom 方法来分享他们的消息。

MediatorPatternDemo，我们的演示类使用 User 对象来显示他们之间的通信。
在这里插入图片描述
步骤 1
创建中介类。

ChatRoom.java
import java.util.Date;
 
public class ChatRoom {
   public static void showMessage(User user, String message){
      System.out.println(new Date().toString()
         + " [" + user.getName() +"] : " + message);
   }
}

步骤 2
创建 user 类。

User.java
public class User {
   private String name;
 
   public String getName() {
      return name;
   }
 
   public void setName(String name) {
      this.name = name;
   }
 
   public User(String name){
      this.name  = name;
   }
 
   public void sendMessage(String message){
      ChatRoom.showMessage(this,message);
   }
}

步骤 3
使用 User 对象来显示他们之间的通信。

MediatorPatternDemo.java
public class MediatorPatternDemo {
   public static void main(String[] args) {
      User robert = new User("Robert");
      User john = new User("John");
 
      robert.sendMessage("Hi! John!");
      john.sendMessage("Hello! Robert!");
   }
}

步骤 4
执行程序，输出结果：

Thu Jan 31 16:05:46 IST 2013 [Robert] : Hi! John!
Thu Jan 31 16:05:46 IST 2013 [John] : Hello! Robert!

七夜琉璃

关注

26
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
Java23种设计模式（三）

这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。命令模式将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。解释器模式给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。在代理模式（Proxy Pattern）中，一个类代表另一个类的功能，这种类型的设计模式属于结构型模式。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
复制链接

扫一扫