常见设计模式

最新推荐文章于 2025-07-08 22:06:45 发布
最新推荐文章于 2025-07-08 22:06:45 发布
阅读量1.3k 收藏 16
点赞数 35
CC 4.0 BY-SA版权
文章标签： 设计模式 java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HansenPole825/article/details/148724172

1.工厂模式

工厂模式可以细分为三种：1.简单工厂模式 2.工厂方法模式 3.抽象工厂模式

1.简单工厂模式

  • 核心思想：创建一个简单的工厂类，包含一个静态方法或者实例方法，根据传入的参数来决定创建并返回哪一种产品对象。
  • 不满足开闭原则：当想要增加一个新的产品时，需要修改工厂类中的方法
  • 适用场景：
    • 产品种类相对固定，不太可能频繁增加。
    • 创建逻辑相对简单。
  • 代码示例
// 1. 产品接口
interface Product {
    void operation();
}

// 2. 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() { System.out.println("Product A operation"); }
}

// 3. 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() { System.out.println("Product B operation"); }
}

// 4. 简单工厂
class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

// 5. 客户端使用
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation(); // Output: Product A operation

        Product productB = SimpleFactory.createProduct("B");
        productB.operation(); // Output: Product B operation
    }
}

2.工厂方法模式

  • 核心思想：定义一个用于创建对象的工厂接口，让它的子类来实现具体的类。
  • 符合开闭原则：添加新的产品时，只需要添加新的具体产品类和具体的工厂类。不用修改现有的工厂。
  • 单一职责原则：每个具体工厂只负责创建一种具体的产品。
  • 适用场景：
    • 无法预知需要创建哪种具体对象（依赖运行时条件）。
    • 系统需要独立于其产品的创建、组合和表示。
    • 需要提供产品的类库，并希望暴露其接口而不是实现。
    • 希望将产品的创建过程委托给子类。
  • 代码示例：
// 1. 产品接口
interface Product {
    void operation();
}

// 2. 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() { System.out.println("Product A operation"); }
}

// 3. 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() { System.out.println("Product B operation"); }
}

// 4. 工厂接口
interface Factory {
    Product createProduct();
}

// 5. 具体工厂A (生产产品A)
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 6. 具体工厂B (生产产品B)
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 7. 客户端使用
public class Client {
    public static void main(String[] args) {
        // 客户端决定使用哪个工厂（通常在配置中决定）
        Factory factory = new ConcreteFactoryA(); // 假设配置了工厂A
        Product product = factory.createProduct();
        product.operation(); // Output: Product A operation

        // 切换工厂只需改变factory的实例化
        factory = new ConcreteFactoryB();
        product = factory.createProduct();
        product.operation(); // Output: Product B operation
    }
}

3.抽象工厂模式

  • 核心思想:提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它强调的是 产品族 的概念。
  • 对产品族符合开闭原则：增加一个新的产品族只需要新增具体产品类和具体工厂类。
  • 对某一类产品来说不满住开闭原则：新增某一类参评需要修改工厂接口和产品接口。
  • 适用场景：
    • 系统需要创建一系列相关的产品对象（属于同一个产品族）。
    • 系统需要独立于其产品的创建、组合和表示。
    • 系统需要配置多个产品族中的一个来使用。
    • 需要强调产品之间的约束关系（比如必须是同一风格）。
  • 代码示例：
// 1. 抽象产品: Button
interface Button {
   void render();
}

// 2. 抽象产品: Checkbox
interface Checkbox {
   void check();
}

// 3. 具体产品: Windows Button
class WindowsButton implements Button {
   @Override
   public void render() { System.out.println("Rendering a Windows button"); }
}

// 4. 具体产品: Windows Checkbox
class WindowsCheckbox implements Checkbox {
   @Override
   public void check() { System.out.println("Checking a Windows checkbox"); }
}

// 5. 具体产品: Mac Button
class MacButton implements Button {
   @Override
   public void render() { System.out.println("Rendering a Mac button"); }
}

// 6. 具体产品: Mac Checkbox
class MacCheckbox implements Checkbox {
   @Override
   public void check() { System.out.println("Checking a Mac checkbox"); }
}

// 7. 抽象工厂
interface GUIFactory {
   Button createButton();
   Checkbox createCheckbox();
}

// 8. 具体工厂: Windows 工厂 (生产Windows族产品)
class WindowsFactory implements GUIFactory {
   @Override
   public Button createButton() {
       return new WindowsButton();
   }
   @Override
   public Checkbox createCheckbox() {
       return new WindowsCheckbox();
   }
}

// 9. 具体工厂: Mac 工厂 (生产Mac族产品)
class MacFactory implements GUIFactory {
   @Override
   public Button createButton() {
       return new MacButton();
   }
   @Override
   public Checkbox createCheckbox() {
       return new MacCheckbox();
   }
}

// 10. 客户端使用
public class Application {
   private Button button;
   private Checkbox checkbox;

   public Application(GUIFactory factory) {
       // 使用同一个工厂创建相互关联的产品（保证是同一族）
       button = factory.createButton();
       checkbox = factory.createCheckbox();
   }

   public void paint() {
       button.render();
       checkbox.check();
   }

   public static void main(String[] args) {
       // 配置使用哪个产品族 (通常在运行时根据配置决定)
       GUIFactory factory;
       String os = System.getProperty("os.name").toLowerCase();
       if (os.contains("win")) {
           factory = new WindowsFactory();
       } else if (os.contains("mac")) {
           factory = new MacFactory();
       } else {
           throw new UnsupportedOperationException("OS not supported");
       }

       Application app = new Application(factory);
       app.paint();
       // 如果配置WindowsFactory: Output: Rendering a Windows button / Checking a Windows checkbox
       // 如果配置MacFactory: Output: Rendering a Mac button / Checking a Mac checkbox
   }
}

2.单例模式

  • 核心思想：确保全局只有一个类的一个实例，并提供一个全局访问点来获得这个实例。就像你的多个对象的对象都是你，你是唯一的。
  • 实现方式：

    1.饿汉式（线程安全的）：

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}  // 私有构造
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

特点：

  • 类加载时就初始化
  • 实现简单

2.懒汉式（双重检查锁）

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {                     // 第一次检查
            synchronized (Singleton.class) {        // 加锁
                if (instance == null) {             // 第二次检查
                    instance = new Singleton();     // 安全创建
                }
            }
        }
        return instance;
    }
}
  • 特点:
    • 首次调用时创建
    • 使用volatile防止指令重排

3.静态内部类

public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}
  • 特点：
    • 延迟初始化（Holder类首次加载时创建）
    • 无锁机制，性能最优
    • 天然线程安全（类加载机制保证）

3.适配器模式

适配器模式（Adapter Pattern）是一种结构型设计模式，它充当两个不兼容接口之间的桥梁，使原本因接口不兼容而无法一起工作的类能够协同工作。

  • 核心思想:
    • 接口转换：将一个类的接口转换成客户期望的另一个接口
    • 兼容适配：解决接口不匹配问题
    • 复用旧代码：使已有类在新系统中复用而无需修改
    • 透明转换：客户端无需了解适配细节
  • 结构：
    在这里插入图片描述
  • 实现方式
  1. 类适配器（继承）
// 目标接口（客户端期望的接口）
interface Target {
    void request();
}

// 需要适配的类（已有但接口不兼容的类）
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}

// 适配器（通过继承实现）
class ClassAdapter extends Adaptee implements Target {
    @Override
    public void request() {
        // 转换调用
        specificRequest();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Target target = new ClassAdapter();
        target.request(); // 输出: Adaptee's specific request
    }
}
  1. 对象适配器
// 目标接口（同上）
interface Target {
    void request();
}

// 需要适配的类（同上）
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}

// 适配器（通过组合实现）
class ObjectAdapter implements Target {
    private Adaptee adaptee;
    
    public ObjectAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    
    @Override
    public void request() {
        // 转换调用
        adaptee.specificRequest();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request(); // 输出: Adaptee's specific request
    }
}
  • 一个例子
// 统一打印接口
interface Printer {
    void print(String text);
}

// 旧式点阵打印机
class DotMatrixPrinter {
    void printDotMatrix(String text) {
        System.out.println("Dot Matrix: " + text);
    }
}

// 适配器
class PrinterAdapter implements Printer {
    private DotMatrixPrinter printer;
    
    public PrinterAdapter(DotMatrixPrinter printer) {
        this.printer = printer;
    }
    
    @Override
    public void print(String text) {
        printer.printDotMatrix(text);
    }
}

4.观察者模式

观察者模式（Observer Pattern）是一种行为型设计模式，定义对象间的一种一对多的依赖关系，当一个对象状态发生改变时，所有依赖它的对象都会得到通知并自动更新。

  • 核心思想
    • 解耦：将观察者与被观察者解耦
    • 动态订阅：运行时动态添加/移除观察者
    • 自动通知：状态变化时自动通知所有订阅者
    • 广播通信：一对多的消息传递机制
  • 代码示例
// 1. 主题接口
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

// 2. 观察者接口
interface Observer {
    void update(String message);
}

// 3. 具体主题（被观察者）
class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String latestNews;
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(latestNews);
        }
    }
    
    public void publishNews(String news) {
        this.latestNews = news;
        notifyObservers(); // 状态变化时通知所有观察者
    }
}

// 4. 具体观察者
class EmailSubscriber implements Observer {
    private String email;
    
    public EmailSubscriber(String email) {
        this.email = email;
    }
    
    @Override
    public void update(String news) {
        System.out.println("Sending email to " + email + ": " + news);
    }
}

class MobileApp implements Observer {
    private String deviceId;
    
    public MobileApp(String deviceId) {
        this.deviceId = deviceId;
    }
    
    @Override
    public void update(String news) {
        System.out.println("Push notification to " + deviceId + ": " + news);
    }
}

// 5. 客户端使用
public class Client {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();
        
        Observer emailUser = new EmailSubscriber("user@example.com");
        Observer appUser = new MobileApp("DEV-12345");
        
        // 订阅
        publisher.attach(emailUser);
        publisher.attach(appUser);
        
        // 发布新闻（自动通知所有订阅者）
        publisher.publishNews("Breaking: New product launched!");
        
        // 取消订阅
        publisher.detach(appUser);
        
        publisher.publishNews("Update: Special discount available!");
    }
}
Java 中的 23 种设计模式详解
微笑听雨
05-06 5万+
项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
设计模式教程：概述常见设计模式及应用场景（更多设计模式使用细节在主页）
遇见伯灵说的博客
02-24 2341
设计模式（Design Patterns）是软件开发中针对常见问题的解决方案，是一种经过时间验证的最佳实践。它们不仅提供了对常见问题的高效解决方案，还能提升代码的可维护性、可扩展性和可重用性。
Java常见设计模式
WZX17307935391的博客
09-01 3107
Java的常见设计模式
前端常见设计模式
前端工作学习中
01-08 3662
前端设计模式是在前端开发中常用的一些设计思想或者编程范式，它们旨在解决特定的问题，并提供了一种可复用的解决方案。
C++ 常见设计模式总结
qq_41952309的博客
08-22 2190
c++ 常见设计模式整理。
JAVA常见设计模式面试题
lzqiang2011的博客
01-29 4067
一、单例模式 java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、双重检查锁定 1.单例模式有以下特点： 　　a、单例类只能有一个实例。 　　b、单例类必须自己创建自己的唯一实例。 　　c、单例类必须给所有其他对象提供这一实例。 2.代码特点 　　a、私有静态变量 　　b、私有构造方法 　　c、公有的静态访问方法　　 3.懒汉式 public class Singleton { private Singleton() {} private
C++ 常见设计模式
HYB3701的博客
04-25 8202
一、定义：定义一系列算法(将算法定义为虚函数，子类重写它），将它们封装起来，并使他们可互相替换（变化）。 二、应用场景：在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担（例如if/else条件判断语句有很多判断语句不会被执行）。 三、解决什么问题：在运行时根据需要透明地更改对象的算法；将算法与对象本身解耦。 原始代码设计（伪代码）： enum TaxBase { CN_Tax, ...
Android常见设计模式
m0_61130325的博客
06-21 4340
首先一个重点就是**类的初始化得在一开始就弄,并且是由static修饰** 使用**static关键字创建类的静态变量时，这个变量会在类加载时被初始化**。**在java中,类加载只会发生1次**。因此，如果使用static关键字创建单例对象，那么在类加载时就会创建单例对象。 但是饿汉模式是有一个缺点,就是这个变量会在类加载时被初始化,如果没用过这个实例的话,就容易造成内存的浪费。 这就不符合**懒加载**的效果
常见的设计模式
二两蚊子的博客
06-08 4592
设计模式-设计原则 创建型模式：静态工厂模式、工厂方法模式、抽象工厂模式、 单例模式、建造者模式 结构型模式：桥接模式、适配器模式、装饰器模式、代理模式、组合模式 行为型模式：模板方法模式、策略模式、观察者模式、 责任链模式、命令模式、访问者模式 ...
软件工程Java设计模式面试专题：常见设计模式解析与应用场景说明
05-23
使用场景及目标：帮助开发者理解并掌握常见设计模式的实现机制，提高代码复用性和可维护性，优化程序架构设计。 阅读建议：建议读者结合实际项目经验，思考每种设计模式的应用场景，尝试将所学知识应用于实践中，...
### 文章总结：常见设计模式的解析与实现（C++）
06-01
内容概要：本文档《C++版常见设计模式解析与实现.pdf》详细介绍了20种常见的C++设计模式，包括工厂模式、抽象工厂模式、建造者模式、原型模式、单例模式、适配器模式、桥接模式、组合模式、装饰模式、代理模式、模板...
软件工程常见设计模式解析及其应用场景：创建型、结构型和行为型模式详解
04-08
内容概要：本文档《软件设计模式.docx》系统介绍了多种常见的设计模式及其应用场景。文档通过选择题的形式详细解析了每种设计模式的核心概念和使用场景，涵盖了创建型模式（如单例模式、工厂方法模式、建造者模式等...
设计模式（九）
2401_86679269的博客
07-03 1026
职责链模式将请求的发送者和接收者解耦，使多个对象都有机会处理请求。这些对象连接成一条链，请求沿着链传递，直到有一个对象处理它为止。职责链模式通过将请求处理者组织成链，实现了请求发送者与接收者的解耦，使系统更具灵活性和可维护性。在需要动态处理请求或多级处理的场景中，该模式尤为适用。来封装一系列对象间的交互，使各对象无需显式引用彼此，从而降低耦合度。中介者负责协调对象间的通信，所有交互都通过中介者进行，而非对象直接调用。中介者模式通过引入中介对象，将复杂的对象间交互集中管理，降低了系统耦合度，提高了可维护性。
基于模板设计模式开发优惠券推送功能以及对过期优惠卷进行定时清理
最新发布
Hellyc的博客
07-08 365
通过上述DTO可以使得不同功能模块找到自己的实现方式（比如立即发送和延时发送就是通过判别DTO中delayTime是否为null，再比如通过Topic使得不同消费者只监听自己的内容）。通过两个事件类对两个功能模块所需属性做了区分，实质上最终传递的内容就是对应的事件。
设计模式精解：观察者与工厂模式的实战应用与场景剖析
IT深耕十余载，大道之简
07-05 647
设计模式是编程中的最佳实践套路，本文通过生活化案例解析两种常用模式。观察者模式采用发布-订阅机制实现气象站温度变化的自动通知，解耦事件源与处理器，适用于一对多依赖关系。工厂模式通过封装对象创建过程，解决披萨订购系统的扩展难题，分为简单工厂和工厂方法两种实现，前者处理单一产品，后者支持产品族创建。两种模式都遵循开闭原则，提升代码复用性和扩展性。
《设计模式之禅》笔记摘录 - 4.抽象工厂模式
lnluozi的博客
07-05 478
抽象工厂模式(Abstract Factory Pattern)是一种比较常用的模式，其定义如下：Provide an interface for creating families of related or dependent objects without specifying ir concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的体类。
设计模式之【模版方法模式】
weixin_43945238的博客
07-04 384
用最简单的篇幅带你了解模版方法模式
设计模式文章
_____________________________________simanstar____
07-07 144
1.
掌握Java常见设计模式：单例实例详解
Java设计模式是软件开发中的重要概念，它提供了一种解决常见问题的标准化解决方案，使得代码结构更加模块化、易于维护和复用。在本文中，我们将深入探讨其中几种常用的Java设计模式，以单例模式为例进行详细讲解。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值