c++ 23种设计模式_23种设计模式？一目了然！

设计模式之间的关系

设计模式分类

创建型模式（5种）

处理对象创建，试图根据实际情况使用合适的方式创建对象。

• 将系统使用的具体类封装。
• 隐藏具体类实例创建和组合方式。

包含：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式（7种）

借由一以贯之的方式来了解元件间的关系，以简化设计。
包含： 适配器模式、 装饰器模式、 代理模式、 外观模式、 桥接模式、 组合模式、 享元模式。

行为型模式（11种）

用来识别对象之间的常用交流模式并加以实现。
包含： 策略模式、 模板方法模式、 观察者模式、 迭代子模式、 责任链模式、 命令模式、 备忘录模式、 状态模式、 访问者模式、 中介者模式、 解释器模式。

其它（2种）

并发型模式、 线程池模式。

设计模式六大原则（SOLID）

单一职责原则（Single Responsibility Principle）

一个类只负责一个职责。

• 代码的粒度降低了，类的复杂度降低了。
• 可读性提高了，每个类的职责都很明确，可读性自然更好。
• 可维护性提高了，可读性提高了，一旦出现 bug ，自然更容易找到他问题所在。
• 改动代码所消耗的资源降低了，更改的风险也降低了。

开闭原则（Open Closed Principle）

对扩展开放，对修改关闭。
在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。
实现“开-闭”原则的关键步骤就是抽象化。

里氏代换原则（Liskov Substitution Principle）

面向对象设计的基本原则之一。 任何基类可以出现的地方，子类一定可以出现。
LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
里氏代换原则是对“开-闭”原则的补充。
基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

迪米特法则（最少知道原则）（Law of Demeter）

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

接口隔离原则（Interface Segregation Principle）

使用多个隔离的接口，比使用单个接口要好。
降低依赖，降低耦合。

依赖倒置原则（Dependence Inversion Principle）

开闭原则的基础。 针对接口编程，依赖于抽象而不依赖于具体。

设计模式（23种）

工厂方法模式（Factory Method）

核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。
核心结构有四个角色，分别是工厂；抽象产品；具体产品。

public interface ShirtProducer {
    
​
    void produceShirt();
​
}

public class ManShirtProducer implements ShirtProducer {
    
​
    @Override
    public void produceShirt() {
    
        System.out.println("produce man shirt.");
    }
​
}

public class WomanShirtProducer implements ShirtProducer {
    
​
    @Override
    public void produceShirt() {
    
        System.out.println("produce woman shirt.");
    }
​
}

简单工厂模式

建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

public class SimpleShirtFactory {
    
​
    public ShirtProducer produce(String shirtType) {
    
        if ("t-shirt".equals(shirtType)) {
    
            return new WomanShirtProducer();
        } else {
    
            return new ManShirtProducer();
        }
    }
​
}

简单工厂（反射）

简单工厂的改进，通过反射实现对新增产品生产的兼容，新增产品生产无需改写工厂类。

public class ReflectSimpleShirtFactory {
    
​
    public ShirtProducer produce(String shirtType)
            throws ClassNotFoundException, InstantiationException, IllegalAccessException {
    
        Class<?> ShirtProducer = Class.forName(shirtType);
        return (ShirtProducer) ShirtProducer.newInstance();
    }
​
}

多个工厂方法模式

对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提 供多个工厂方法，分别创建对象。

public class MultiShirtFactory {
    
​
    public ShirtProducer produceManShirt() {
    
        return new ManShirtProducer();
    }
​
    public ShirtProducer produceWomanShirt() {
    
        return new WomanShirtProducer();
    }
​
}

静态工厂方法模式

将多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class StaticMultiShirtFactory {
    
​
    public static ShirtProducer produceShirt() {
    
        return new ManShirtProducer();
    }
​
    public static ShirtProducer produceTShirt() {
    
        return new WomanShirtProducer();
    }
​
}

凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。
​
大多数情况下，选用静态工厂方法模式。

public class ShirtFactoryMain {
    
​
    public static void main(String[] args) {
    
        System.out.println("普通工厂模式");
        SimpleShirtFactory shirtFactory1 = new SimpleShirtFactory();
        ShirtProducer shirtProducer1 = shirtFactory1.produce("shirt");
        shirtProducer1.produceShirt();
​
        try {
    
            System.out.println("普通工厂模式（反射）");
            ReflectSimpleShirtFactory shirtFactory11 = new ReflectSimpleShirtFactory();
            ShirtProducer shirtProducer11 = shirtFactory11.produce(ManShirtProducer.class.getName());
            shirtProducer11.produceShirt();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
    
            e.printStackTrace();
        }
​
        System.out.println("多工厂方法模式");
        MultiShirtFactory shirtFactory2 = new MultiShirtFactory();
        ShirtProducer shirtProducer2 = shirtFactory2.produceManShirt();
        shirtProducer2.produceShirt();
​
        System.out.println("静态工厂方法模式");
        ShirtProducer shirtProducer3 = StaticMultiShirtFactory.produceShirt();
        shirtProducer3.produceShirt();
    }
​
}

抽象工厂模式（Abstract Factory）

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。
抽象工厂模式， 工厂方法模式的抽象化，创建多个工厂类，需要增加新的功能时，直接增加新的工厂类即可，不需要修改之前的代码。
核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品。

• 抽象工厂

抽象工厂模式核心，与应用程序无关，任何在模式中创建的对象的工厂类必须实现这个接口。

• 具体工厂

实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

• 抽象产品

工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

• 具体产品

实现了抽象产品角色所定义的接口。

public interface ShirtFactory {
    
​
    ShirtProducer produce();
​
}

public class MailSenderFactory implements SenderFactory {
    
    
    @Override
    public Sender produce() {
    
        return new MailSender();
    }
}

public class ManShirtFactory implements ShirtFactory {
    
​
    @Override
    public ShirtProducer produce() {
    
        return new ManShirtProducer();
    }
​
}

public class WomanShirtFactory implements ShirtFactory {
    
​
    @Override
    public ShirtProducer produce() {
    
        return new WomanShirtProducer();
    }
​
}

public class ShirtProducerMain {
    
​
    public static void main(String[] args) {
    
        System.out.println("抽象工厂模式");
        ShirtFactory shirtProvider1 = new ManShirtFactory();
        ShirtProducer shirtProducer1 = shirtProvider1.produce();
        shirtProducer1.produceShirt();
​
        ShirtFactory shirtProvider2 = new WomanShirtFactory();
        ShirtProducer shirtProducer2 = shirtProvider2.produce();
        shirtProducer2.produceShirt();
    }
​
}

建造者模式（Builder）

将各种产品集中起来进行管理，用来创建复合对象。
工厂模式关注创建单个产品，建造者模式关注创建符合对象、多个部分。

public class ShirtProducerBuilder {
    
​
    private List<ShirtProducer> shirtProducerlist = new LinkedList<ShirtProducer>();
​
    public void produceManShirtProducer(int count) {
    
        for (int i = 0; i < count; i++) {
    
            shirtProducerlist.add(new ManShirtProducer());
        }
    }
​
    public void produceWomanShirtProducer(int count) {
    
        for (int i = 0; i < count; i++) {
    
            shirtProducerlist.add(new WomanShirtProducer());
        }
    }
​
}public class SenderBuilder {
    
    private LinkedList<Sender> senderList = new LinkedList<Sender>();
    
    public voi