设计模式

设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

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

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

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

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

六大原则：

单一职责原则:
不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，否则就应该把类拆分

里氏替换原则（Liskov Substitution Principle）:
子类可以扩展父类的功能，但不能改变父类原有的功能。父类能出现的地方都可以用子类来代替，而且换成子类也不会出现任何错误或异常，而使用者也无需知道是父类还是子类，但反过来则不成立。总之，就是抽象。

依赖倒转原则（Dependence Inversion Principle）:
面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互

接口隔离原则（Interface Segregation Principle）:
每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

迪米特法则（最少知道原则）（Demeter Principle）:
一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。
最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

合成复用原则（Composite Reuse Principle）:
尽量首先使用合成/聚合的方式，而不是使用继承。

建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。主要应用场景是：创建的对象整体结构不变，但是组成对象会经常变化。例如我要点一个牛肉面（Noodle），它是由面、牛肉、汤组成，在这些前提不变的情况下，面可能是白面，也可能是菠菜面；牛肉可能是黄牛肉也可能是奶牛肉；汤里可能包含醋，也可能包含辣椒。

建造者模式的核心角色

• Director指挥者：指挥Builder生产产品
• Builder抽象接口：定义生产产品需要的方法、属性
• Product产品：要被生产的对象
• ProductBuilder构建者：实际生产产品的对象

使用实例（以做一碗牛肉面为例）

Product：牛肉面（BeefNoodle），组成对象：面（Noodle）、牛肉（Beef）、汤（Soup）

Builder接口：Builder

ProductBuilder构建者：Chef

Director指挥者：Director

面（Noodle）

public class Noodle {
    String NoodleKind;//面条种类

    public Noodle(String noodleKind) {
        NoodleKind = noodleKind;
    }
}

牛肉（Beef）

public class Beef {
    String BeefKind;//牛肉种类

    public Beef(String beefKind) {
        BeefKind = beefKind;
    }
}

汤（Soup）

public class Soup {
    String taste;//味道

    public Soup(String taste) {
        this.taste = taste;
    }
}

牛肉面（BeefNoodle）

public class BeefNoodle {
    Beef beef;
    Noodle noodle;
    Soup soup;

    public Beef getBeef() {
        return beef;
    }

    public void setBeef(Beef beef) {
        this.beef = beef;
    }

    public Noodle getNoodle() {
        return noodle;
    }

    public void setNoodle(Noodle noodle) {
        this.noodle = noodle;
    }

    public Soup getSoup() {
        return soup;
    }

    public void setSoup(Soup soup) {
        this.soup = soup;
    }

    @Override
    public String toString() {
        return "BeefNoodle{" +
                "牛肉种类=" + beef.BeefKind +
                ", 面的种类=" + noodle.NoodleKind +
                ", 汤的味道=" + soup.taste +
                '}';
    }
}

Builder接口

public interface Builder {
    //做面
    public void makeNoodle(Noodle noodle);

    //选牛肉
    public void makeBeefKind(Beef beef);

    //做汤
    public void makeSoup(Soup soup);

    //返回产品
    public BeefNoodle getBeefNoodle();
}

Chef

public class Chef implements Builder {
    private BeefNoodle beefNoodle = new BeefNoodle();

    @Override
    public void makeNoodle(Noodle noodle) {
        this.beefNoodle.setNoodle(noodle);
    }

    @Override
    public void makeBeefKind(Beef beef) {
        this.beefNoodle.setBeef(beef);
    }

    @Override
    public void makeSoup(Soup soup) {
        this.beefNoodle.setSoup(soup);
    }

    @Override
    public BeefNoodle getBeefNoodle() {
        return this.beefNoodle;
    }
}

Director

public class Director {
    public BeefNoodle builder(Builder builder) {
        return builder.getBeefNoodle();
    }
}

测试

    public static void main(String[] args) {
        Director director = new Director();
        
        Chef chef1 = new Chef();
        chef1.makeNoodle(new Noodle("荞麦面"));
        chef1.makeBeefKind(new Beef("黄牛肉"));
        chef1.makeSoup(new Soup("酸"));
        BeefNoodle beefNoodle1 = director.builder(chef1);
        System.out.println("第一种面：" + beefNoodle1);

        Chef chef2 = new Chef();
        chef2.makeNoodle(new Noodle("菠菜面"));
        chef2.makeBeefKind(new Beef("和牛"));
        chef2.makeSoup(new Soup("辣"));
        BeefNoodle beefNoodle2 = director.builder(chef2);
        System.out.println("第二种面：" + beefNoodle2);
    }

建造者模式的优缺点

优点：

1、适用于复杂对象的创建，是解决系统中创建和操作包含多重对象的复杂对象的一种极佳方案；

2、便于细节的控制，在对象的每个复杂属性都可以管控到。

3、利于多重对象数据或者方法的相互调用，例如总对象可以调用到每个子对象的数据和方法。

缺点：

1、程序复杂，无论是写代码还是需求设计方面都有难度。

2、依赖性大，各个子对象和总对象需要有关联，所以会有一定的局限性。

3、系统如果用到了该模式会在一定程度上和业务需求关联性强，如果需求变更可能改动点会比较大。

建造者模式和工厂模式的区别

相同点：工厂模式和建造者模式都是属于设计模式中的‘创建者模式’类型，都是用来创建对象的解决方案；

不同点：工厂模式创建对象的侧重点是‘新建’，简单点来说就是注重于从无到有的创建；建造者模式创建对象的过程更强调于对象属性的组装，简单来说就是通过A和B来组成C。