设计模式总结（二）

已于 2024-02-28 15:57:50 修改
阅读量829 收藏 16
点赞数 19
文章标签： 设计模式 java
于 2024-02-28 15:53:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiamua_123/article/details/136348128
版权

  本文根据黑马课程和网上相关示例总结而成。

适配器模式

  将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类协作起来

// 要被适配的类
public class Adaptee{
    @Override
    public void request(){
        System.out.println("连接网线上网");
    }
}
// 客户端类
public class Computer{
    // 电脑需要连接上转接器才可以上网
    public void net(NetToUsb adapter){
        // 上网的具体实现：找一个转接头
        adapter.handleRequest();
    }
    public static  void main(String[] args){
        // 电脑，适配器，网线
        Computer computer = new Computer();
        Adaptee adaptee = new Adaptee();
        Adapter adapter = new Adapter();
        
        computer.net(adapter);
    }
}
// 接口转换器的抽象实现
public class NetToUsb{
    // 作用：处理请求：网线插在USB上
    public void handleRequest();
}
// 真正的适配器(可以理解为将USB和网线连接通过适配器连接起来了)：需要连接USB，连接网线(处理上网的请求，继承Adaptee)
public class Adapter extends Adaptee implements NetToUsb{
    @Override
    public void handleRequest(){
        super.request(); // 表示可以上网了
    }
}
// 1.继承（类适配器，单继承的方式）（以上是类适配器）
// 2.组合（对象适配器，常用的方式）（下面的模式）

public class Adapter2 implements NetToUsb{
    private Adaptee adaptee;
    
    public Adapter2(Adaptee adaptee){
        this.adaptee = adaptee;
    }
    
    @Override
    public void handleRequest(){
        adaptee.request();
    }
}
// 更改Computer类：main函数修改为
public static void main(String[] args){
    Computer computer = new Computer();
    Adaptee adaptee = new Adaptee();
    Adapter adapter = new Adapter(adaptee); // 转换器先插网线
    computer.net(adapter); // 其次连接电脑 
}

  上述的例子是这样的：电脑和一个设备因为接口不同所以无法连接，但是可以通过一个转接器（适配器）将不能连接的两个设备实现连接。

享元模式

  运用共享技术来有效支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似对象的开销，从而提高系统资源的利用率。

结构

享元（Flyweight）模板存在两种状态

  • 内部状态，不会随着环境改变而改变的可共享部分
  • 外部状态：指随环境改变而改变的不可共享部分

角色为：

  • 抽象享元角色：在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部状态，同时也可以通过这些方法来设置外部状态
  • 具体享元：实现了抽象享元，在具体享元类中为内部状态提供了存储空间。通常可以结合单例模式来设计具体享元类，为每一个具体的享元类提供唯一的享元对象
  • 非享元：并不是所有的抽象享元子类都需要被共享，不能被共享的子类可设计为非共享具体享元类，当需要一个非共享具体享元类的对象时可以直接通过实例化创建
  • 享元工厂：负责创建和管理享元角色，当客户对象请求一个享元对象时，享元工厂会检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在，则创建一个新的享元对象
案例

  俄罗斯方块，如果在俄罗斯方块游戏中，每个不同的方块是一个实例对象，这些对象就要占用很多的内存空间，下面可以利用享元模式进行实现。

在这里插入图片描述

// 抽象享元角色：AbstractBox  method: getShape()  display(String color())
// 具体实现子类：IBox  LBox OBox
// 工厂：map:HashMap<String, AbstractBox>
public abstract class AbstractBox {
    // 获取图形的方法
    public abstract String getShape();
    // 显示图形及颜色
    public void display(String color){
        System.out.println("方块形状：" + getShape() + "，颜色为：" + color);
    }
}
public class IBox extends AbstractBox {
    @Override
    public String getShape() {
        return "I";
    }
}
public class LBox extends AbstractBox {
    @Override
    public String getShape() {
        return "L";
    }
}
public class OBox extends AbstractBox {
    @Override
    public String getShape() {
        return "O";
    }
}

// 享元工厂
public class BoxFactory {
    private HashMap<String, AbstractBox> map;

    // 单例模式：构造方法私有
    private BoxFactory(){
        map = new HashMap<String, AbstractBox>();
        map.put("I", new IBox());
        map.put("L", new LBox());
        map.put("O", new OBox());
    }

    // 一开始就进行了初始化，这是饿汉式单例模式
    private static BoxFactory factory = new BoxFactory();
    // 因为设计成单例模式，所以提供一个静态方法获取该工厂类对象
    public static BoxFactory getInstance(){
        return factory;
    }

    // 根据名称获取图形对象
    public AbstractBox getShape(String name){
        return map.get(name);
    }
}

// 客户测试类
public class Client {
    public static void main(String[] args) {
        // 获取I图形对象
        AbstractBox box1 = BoxFactory.getInstance().getShape("I");
        box1.display("灰色");

        // 获取L图形对象
        AbstractBox box2 = BoxFactory.getInstance().getShape("L");
        box2.display("绿色");

        // 获取O图形对象
        AbstractBox box3 = BoxFactory.getInstance().getShape("O");
        box3.display("红色");

        // 获取O图形对象
        AbstractBox box4 = BoxFactory.getInstance().getShape("O");
        box4.display("灰色");

        // 输出结果为true，是同一个对象，享元模式对图形进行共享操作
        System.out.println(box3 == box4);
    }
}

优点：

  • 极大减少内存中相似或相同对象数量，节约系统资源
  • 享元模式中的外部状态相对独立，且不影响内部状态。比如说上面的颜色是外部状态，颜色的修改不影响图形，只要图形一样，不管什么颜色，均是同一对象

缺点：

  • 为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

适用场景：

  • 一个系统有大量相同或者相似的对象，造成内存的大量耗费
  • 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中
  • 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源。因此，应当在需要多次重复使用享元对象时才值得使用享元模式
  • Integer类使用了享元模式

模板方法模式

  在面向对象编程时，可能会遇到这种情况：设计一个系统时知道了算法所需的关键步骤， 而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

  例如：去银行办理业务时，需要经过4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等。其中取号、排队和评分对每个客户都是一样的，可以在父类实现，但是办理具体业务是因人而异的，它可能是存款、取款或者转账等，可以延迟到子类中实现。

**定义：**定义一个操作中的算法框架，将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

结构
  • 抽象类：负责给出一个算法的轮廓和骨架，由一个模板方法和若干个基本方法构成
    • 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法
    • 基本方法：是实现算法各个步骤的方法，是模板方法的组成部分，基本方法分为三种
      • 抽象方法：由抽象类声明，由其具体子类实现
      • 具体方法：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承，比如银行示例中的取号、排队和对银行人员进行评分
      • 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。一般用于判断的逻辑方法，返回值类型为boolean类型
  • 具体子类：实现抽象类中所定义的抽象方法和钩子方法
示例

  炒菜的步骤是固定的，分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法进行模拟。

// 抽象方法为：倒蔬菜、倒调料品
// 具体实现：倒油、热油、翻炒
public abstract class AbstractClass{
    // 模板方法定义：这个是按照一定步骤进行的
    // 需要定义final，不让子类重写
    public final void cookProcess(){
        pourOil();
        heatOil();
        pourVegetable();
        pourSauce();
        fry();
    }

    // 基本方法定义:具体方法：第一步
    public void pourOil(){
        System.out.println("倒油");
    }
    // 具体方法：第二步
    public void heatOil(){
        System.out.println("热油");
    }
    // 抽象方法：第三步
    public abstract void pourVegetable();
    // 抽象方法：第四步
    public abstract void pourSauce();
    // 具体方法：第五步
    public void fry(){
        System.out.println("翻炒");
    }
}

// 具体实现子类
public class ConcreteClass_BaiCai extends AbstractClass{

    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是白菜");
    }

    @Override
    public void pourSauce() {
        System.out.println("下锅的料是醋");
    }
}
// 客户测试类
public class Client {
    public static void main(String[] args) {
        // 炒白菜
        // 创建对象
        ConcreteClass_BaiCai baiCai = new ConcreteClass_BaiCai();
        // 调用炒菜的功能
        baiCai.cookProcess();
    }
}

优点：

  • 提高代码复用性，将相同部分的代码放在抽象的父类中，而将不同的放入不同的子类
  • 实现了反向控制。通过一个父类调用其子类的操作，通过对子类的具体实现扩展不同的行为，实现了反向控制，并符合开闭原则

缺点：

  • 对每个不同的实现都需要定义一个子类，这会导致类的个数增加
  • 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这会导致一种反向的控制结构，提高了代码阅读的难度

适用场景：

  • 算法的整体步骤很固定，只有个别部分易变，这是可以适用模板方法模式，将容易变化的部分抽象出来，用子类实现
  • 需要通过子类来决定父类算法中某个步骤是否执行，实现子类对父类的反向控制
  • InputStream类适用到了模板方法模式

观察者模式

  定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使它们能够自动更新自己。

观察者模式的角色
  • 抽象主题（抽象被观察者）：抽象主题角色把所有观察者对象保存在一个集合中，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象
  • 具体主题（具体被观察者）：该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
  • Observer（抽象观察者）：观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
  • 具体观察者，实现抽象观察者定义的更新接口，一遍在得到主题更改时更新自身的状态。

  示例1：使用微信公众号时，当关注的公众号中有新内容更新的话，就会推送给关注公众号的微信用户端。微信用户是观察者，微信公众号是被观察者，有多个微信用户关注了这个公众号

// 创建抽象主题：微信公众号
public interface Subject{
    // 增加观察者对象
   void attach(Observer observer);
    // 删除观察者对象
   void detach(Observer observer);
    // 通知观察者更新信息
   void notify(String message);
}
// 创建抽象观察者
public interface Observer{
    // 更新信息
    void update(String message);
}

// 创建具体抽象主题
public class SubscriptionSubject implements Subject{
    // 观察者对象集合
    private List<Observer> observerList = new ArrayList<Observer>();
    public void attach(Observer observer){
        observerList.add(observer);
    }
    public void detach(Observer observer){
        observerList.remove(observer);
    }
    public void notify(String message){
        observer.update(message);
    }
}
// 创建具体观察者对象
public class weixinUser implements Observer{
    // 需要知道观察者的名字
    private String name;
    public void update(String message){
        System.out.println(name + "-" + message);
    }
}

// 创建一个客户类，实现上述模式
public class Client{
    public static void main(String[] args){
        // 创建被观察者
        SubscriptionSubject subject = new SubscriptionSubject();
        // 创建观察者对象
        subject.attach(new weixinUser("lisi"));
        subject.attach(new weixinUser("wangwu"));
        subject.attach(new weixinUser("zhaoliu"));
        // 订阅更新后，需要通知所有的观察者对象，需要说明更新信息
        subject.update("专栏更新了");
    }
}

  示例2：对用户显示数学饼状图需要数据支撑，数学饼状图在开发中，其实分为两个部分，一个是视图部分（以饼状图呈现出的样子），一个是数据部分，即各国的金牌数量，由于将数据和视图抽离，因为一旦数据部分更新，视图部分得不到最新的数据，难以维持一致性。此时，需要一个时刻关注数据变化的观察者，一旦观察者感知到数据变化则立即更新视图，视图类本身也可以作为一个观察者，但是更好的方法是单独分离出一个观察者类来维护两个类之间的一致性。订阅者是谷歌数据源和百度数据源（该示例来自网上一篇博客分析，现已不知道对应链接）

// 第一种方法：定义接口，实现接口的方式
// 视图类
Class View{
    public void show(Object data){
        System.out.println(data);
    }
}
// 抽象数据源（被观察对象）
public interface DataSource{
    // 添加观察者对象
    void attach(Observer observer);
    // 更新数据，如果相同，则不更新，不同，通知观察者更新数据
    void updateDate(String newData);
    // 通知观察者
    void notifyObserver(String data);
}
// 抽象观察者类
public interface Observer{
    void update(DataSource ds, String data);
}

// 具体被观察者对象，这里只展示GooleDataSource，BaiduDataSource代码类似
public class GooleDataSource implements DataSource{
    // 观察者对象列表
    List<Observer> observerList = new ArrayList<Observer>();
    // 值对象列表
    HashSet<String> data = new HashSet<>();

    @Override
    public void attach(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void updateDate(String newData) {
        if(!data.contains(newData)){
            data.add(newData);
            notifyObserver(newData);
        }
    }

    @Override
    public void notifyObserver(String data){
        for (Observer observer : observerList) {
            observer.update(this,data);
        }
    }

}

// 客户类
public class ClientTest {
    public static void main(String[] args) {
        View view = new View();
        view.show("初始状态");

        System.out.println();

        // 定义与View相关的数据源
        DataSource bds = new BaiduSource();
        DataSource gds = new GooleDataSource();

        // 为View添加观察数据源的观察者
        Observer observer1 = new ObserverA(view);
        Observer observer2 = new ObserverA(view);

        bds.attach(observer1);
        gds.attach(observer2);

        // 手动更新数据
        bds.updateDate("这是百度新数据--" + new Date());
        System.out.println();
        gds.updateDate("这是谷歌新数据--" + new Date());
    }
}

  第一种方法还可以再优化，上述代码中使用了两个观察者，其实两个设置不同种类的观察者，用来观察不同的内容，但是当增加观察者时，代码会变得很复杂度，而且代码会增加很多。

// 第二种方法，不定义接口，使用抽象类的方式实现
//视图类
class View {
    //通过复杂转换将数据可视化，这里简单的打印
    public void show(Object data) {
        System.out.println(data);
    }
}
abstract class DataSource{
    // 相关的数据
    protected String data = "";
    // 存储观察者
    protected List<Observer> observers = new ArrayList<>();
    
    public String getData(){
        return data;
    }
    
    public void addObserver(Observer observer){
        observers.add(observer);
    }
    
    abstract public void notifyObserver();
}
// 数据源类的实现类之一：百度数据源类，谷歌数据源类代码类似，不再予以展示
class BaiduDataSource extends DataSource{
    @Override
    protected void updateData(String newData){
        if(!newData.equals(data)){
            data = newData;
            notifyObserver();
        }
    }
    @Override
    public void notifyObserver(){
        for(Observer observer: observers){
            observer.update(this, data);
        }
    }
}

// 观察者接口
interface Observer{
    void update(DataSource ds, String data);
}
class ObserverA implements Observer{
    private View view;
    public ObserverA(View view){
        this.view = view;
    }
    @Override
    public void update(DataSource ds, String data){
        System.out.println("观察到" + ds.getClass().getSimpleName() + "发生变化，更新视图");
        view.show(data);
    }
}
// 客户测试类与第一种方法相同，不再赘述

  第二种方法跟第一种方法存在一样的问题，也是观察者模式的缺点之一，当观察者越来越多的时候，代码会变得更加难以扩展维护。二者可以优化的点是：一旦有变化则通知所有的观察者，但是有些观察者对这些消息不感兴趣，所以应该只通知那些对该变化感兴趣的观察者们，所以可以定义一个Aspect类表示该变化的特点，可以采用哈希表保存观察者：

Map<Aspect, List<Observer>> map = new HashMap<>();
// 观察者注册时，必须表明自己对哪些方面的变化感兴趣
public void addObserver(Aspect aspect, Observer observer){
    map.put(aspect, observer);
}

优点：

  • 降低了目标和观察者之间的耦合关系，两者之间是抽象耦合关系，符合依赖倒置原则
  • 目标和观察者之间建立了一套触发机制

缺点：

  • 目标和观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用
  • 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率，并且可能会导致意外的更新

策略模式

  该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

结构
  • 抽象策略（Strategy）：抽象角色，通过有接口或抽象类实现，该角色给出所有具体策略类所需的接口
  • 具体策略（Concrete Strategy）：抽象角色的实现类，提供具体的算法实现或行为
  • 环境（Context，对封装的算法进行管理的角色）：持有一个策略类的引用，最终给客户端调用
案例

  一家百货公司在定年度的促销活动，针对不同的节日（春节、中秋节、圣诞节）推出不同的促销活动（这些促销活动在这些节日可以通用），由促销员将促销活动展示给客户

// 定义抽象策略接口
public interface Strategy{
    void show();
}
// 具体策略实现类
public StrategyA implements Strategy{
    @Override
    public void show(){
        System.out.println("买一送一");
    }
}
public StrategyB implements Strategy{
    @Override
    public void show(){
        System.out.println("满200减50");
    }
}
public StrategyC implements Strategy{
    @Override
    public void show(){
        System.out.println("满300减60");
    }
}
// 定义一个环境，即管理策略的引用
public class Salesman{
    private Strategy strategy;
    public Salesman(Strategy strategy){
        this.strategy = strategy;
    }
    public Strategy getStrategy(){
        return strategy;
    }
    public void setStrategy(Strategy strategy){
        this.strategy = strategy;
    }
    // 由促销员将促销活动展示出来
    public void salesmanShow(){
        strategy.show();
    }
}
// 定义客户类
public class Client {
    public static void main(String[] args) {
        // 春节来了，使用春节促销活动
        SalesMan salesMan = new SalesMan(new StrategyA());
        // 展示促销活动
        salesMan.salesManShow();
        System.out.println("===========");
        // 中秋节
        salesMan.setStrategy(new StrategyB());
        salesMan.salesManShow();
    }
}

优点

  • 策略类之间可以自由切换
  • 易于扩展，增加一个新的策略，只需要增加一个具体的策略类即可，符合开闭原则

缺点

  • 客户端必须知道所有的策略类，并自行决定使用哪一种策略类
  • 策略模式将造成很多策略类，可以通过使用享元模式在一定程序上减少对象的数量

使用场景

  • 一个系统需要动态地在集中算法中选择一种时，可以将每个算法封装在策略类中
  • 多个类之区别于表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为
xiamua_123
关注
Java23种设计模式(总结).doc
01-25
Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)Java23种设计模式(总结)...
设计模式精解- GoF 23种设计模式解析附C++实现源码
10-24
设计模式精解- GoF 23种设计模式解析附C++实现源码 懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要。反之好像也可能成立。道可道，非常道。道不远人，设计模式亦然如此。 一直想把自己的学习经验以及在...
Java常见设计模式总结
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
Java中23种设计模式
呜呜老司机的博客家园
10-10 8万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
24大设计模式总结
流华追梦的专栏
07-07 1670
设计模式（Design Pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。在软件开发中，前人对软件系统的设计和开发总结了一些原则和模式， 不管用什么语言做开发，都将对我们系统设计和开发提供指导意义。本文主要将对24种设计模式进行总结和阐述具体意义。创建型（6种）、行为型（11种）、结构型（7种）。
二十四种设计模式总结
好好学习，天天向上
12-02 5368
设计模式 什么是设计模式 ​ 设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。 ​ 1995 年，GoF（Gang of Four，四人组/四人帮）合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了 23 种设计模式，从此树立了软件设计模式领域的里程碑，人称「GoF设计模式」。 ​ 这 23 种设计模式的本质是面向对象设计原则的实际运用，是对类的封.
23种设计模式总结
lgxzzz的博客
05-25 7万+
一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛
常见的23种设计模式总结
秃头的博客
10-20 5103
创建型模式：单例模式、建造者模式、工厂模式、原型模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式、过滤器模式。 行为型模式：模版模式(模版方法模式)、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式、访问者模式。
Java设计模式学习总结
Java技术江湖
07-08 5698
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
《Java设计模式》刘伟 课后习题及模拟试题答案.rar
08-24
设计模式是经验丰富的开发者在解决常见问题时总结出的通用解决方案，是软件开发中的智慧结晶。这本书的课后习题和模拟试题旨在帮助读者巩固学习内容，加深对设计模式的理解，提升实际编程能力。 课后习题参考答案...
C++设计模式
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-15 1689
Abstract Factory 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。Adapter适配器模式：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工 作。Bridge桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变 化。Builder建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建 过程可以创建不同的表示。
设计模式】Listener模式和Visitor模式的区别
tr6666的博客
09-11 1270
在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详细解释这两种模式，并通过Java和Go语言的代码示例展示它们的实现，最后总结它们的区别和适用场景。Listener模式（监听器模式）是一种行为设计模式，主要用于事件驱动的编程。它允许一个对象（监听器）注册到另一个对象（事件源），以便在特定事件发生时接收通知。
《程序猿之设计模式实战 · 装饰者模式》
山人行
09-13 939
上一篇文章《程序猿之设计模式实战 · 策略模式》介绍的了策略模式的实际运用，这篇紧随其后，补充上装饰者模式。装饰者模式也是相当实用的，适合很多场景，且听慢慢道来。装饰者模式是一种结构型设计模式，它允许在不改变对象自身的情况下，动态地给对象添加新的功能。通过将功能封装在装饰类中，装饰者模式提供了一种灵活的方式来扩展对象的行为。装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。
《程序猿之设计模式实战 · 策略模式》
山人行
09-12 1276
近期，无论是编码还是休闲阶段，偶尔都会刷到关于设计模式的相关内容，发掘可以整理的内容还不少，就想着归纳高低给它整一个专栏。网上介绍23种设计模式的内容也不少，大多枯燥而冗长，这边不会重复搬砖，也不会按顺序介绍所有设计模式，只会从实战层面去分享几个实用的。好了，废话不多说，先开始最常用的策略模式吧。题外话有的人认为设计模式很有用，遵循了面向对象等开发原则，可以提升代码复用，提高可维护性，便于后期的功能扩展。
JS设计模式之代理模式：对象的“虚拟与现实”
前端梦工厂
09-12 1076
概述：代理模式是一种结构型设计模式，它通过引入一个代理对象来控制对另一个对象的访问或操作。代理对象和真实对象具有相同的接口，客户端代码通常无需关注代理对象和真实对象之间的差异。在代理模式中，客户端不直接与真实对象进行交互，而是通过代理对象来完成访问或操作。代理对象可以对客户端的请求进行过滤、验证、处理，以及添加额外的功能，然后再将请求传递给真实对象去执行。代理模式主要包括两个角色：真实对象）：真实对象是代理模式中要被访问或操作的对象，它具有具体的业务逻辑和功能。代理对象和真实对象通常都实现同一个接口。
设计模式中工厂模式的C语言实现
最新发布
瞅瞅水的博客
09-17 346
在C语言中实现工厂模式（Factory Pattern）通常需要模拟面向对象的编程方式。工厂模式的核心思想是通过工厂函数来创建不同类型的对象，隐藏对象创建的细节。下面是一个简单的工厂模式在C语言中的实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值