设计模式

面向对象原则

1. 单一指责原则 （Single responsibility principle，SRP）

一个类应该仅有一个引起它变化的原因。

2. 开闭原则 （Open Closed Principle，OCP）

一个类应该对外扩展开放，对修改关闭。

3. 里氏替换原则 （Liskov Substitution Principle，LSP）

子类型能够替换掉它们的父类型。

4. 依赖倒置原则 （Dependency Inversion Principle，DIP）

要依赖于抽象，不要依赖于具体类，要做到依赖倒置，应该做到：
1. 高层模块不应该依赖底层模块，二者都应该依赖于抽象。
2. 抽象不应该依赖于具体实现，具体实现应该依赖于抽象。

5. 接口隔离原则 （Interface Segregation Principle，ISP）

不应该强迫客户依赖于他们不用的方法。

6. 迪米特法则（Principle of Least Knowledge，PLK）

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

7. 合成复用原则（Composite Reuse Principle，CRP）

尽量首先使用合成/聚合的方式，而不是使用继承。

其他原则

• 面向接口编程
• 一个类需要的数据应该隐藏在类的内部
• 类之间应该零耦合，或者只有传导耦合，换句话说，类之间要么没关系，要么只使用另一个类的接口提供的操作
• 在水平方向上尽可能统一地分布系统功能

设计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1. 单例模式

1. 懒汉式

在需要的时候才创建实例。

public class Singleton {
    private Singleton() {}//构造函数私有化
    private static Singleton instance = null;//实例私有化
    public static Singleton getInstance() {
        //实例不存在，则创建
        if(instance == null) {
            //懒汉式单例线程不安全，加上同步后创建实例
            synchronized (Singleton.class) {
                //双重检查锁定
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 饿汉式

在创建类的同时创建好实例。

public class Singleton {
    private Singleton() {}//构造函数自由化
    private static final Singleton instance = new Singleton();//实例私有化
    //获取实例的方法
    public static Singleton getInstance() {
        return instance;
    }
}

2. 工厂方法模式

1. 工厂方法模式（Factory Method）

• 一个抽象产品类，多个具体产品类（继承自抽象产品类）
• 一个抽象工厂接口，多个具体工厂类（实现抽象工厂接口），各个具体工厂类用于创建不同的具体产品实例
• 具体产品角色通过创建不同的具体工厂实例，获取不同的具体产品

//抽象产品类
abstract class Product {
    public Product() {}
}
//具体产品类A
public class ProductA extends Product {
    public ProductA() {
        System.out.println("ProductA created");
    }
}
//具体产品类B
public class ProductB extends Product {
    public ProductB() {
        System.out.println("ProductB created");
    }
}
//抽象工厂接口
interface Factory {
    Product createProduct();
}
//具体工厂类A
public class FactoryA implements Factory {
    @Override
    public ProductA createProduct() {
        return new ProductA();
    }
}
//具体工厂类B
public class FactoryB implements Factory {
    @Override
    public ProductB createProduct() {
        return new ProductB();
    }
}
//具体产品
public class Client {
    public static void main(String[] args) {

        FactoryA fa = new FactoryA();
        ProductA pa = fa.createProduct();

        FactoryB fb = new FactoryB();
        ProductB pb = fb.createProduct();
    }
}

2. 简单工厂模式（Simple Factory Method）

• 一个抽象产品类，多个具体产品类（继承自抽象产品类）
• 一个具体工厂类，用于创建具体产品实例
• 具体产品角色通过创建具体工厂实例，调用其内部方法，得到具体产品实例

//抽象产品类
abstract class Product {
    public Product() {}
}
//具体产品类A
public class ProductA extends Product {
    public ProductA() {
        System.out.println("ProductA created");
    }
}
//具体产品类B
public class ProductB extends Product {
    public ProductB() {
        System.out.println("ProductB created");
    }
}
//具体工厂类
public class Factory {
    public Product createProduct(int type) {
        switch(type) {
            case 1:
                return new ProductA();
            case 2:
                return new ProductB();
            default:
                return null;
        }
    }
}
//具体产品
public class Client {
    public static void main(String[] args) {

        Factory factory = new Factory();
        Product pa = factory.createProduct(1);
        Product pb = factory.createProduct(2);
    }
}

3. 抽象工厂模式

4. 建造者模式

5. 原型模式

1. 深拷贝

2. 浅拷贝

6. 适配器模式

7. 装饰器模式

8. 代理模式

9. 外观模式

10. 桥接模式

11. 组合模式

12. 享元模式

13. 策略模式

14. 模版方法模式

15. 观察者模式

16. 迭代子模式

17. 责任链模式

18. 命令模式

19. 备忘录模式

20. 状态模式

21. 访问者模式

22. 中介者模式

23. 解释器模式