开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 23 天，点击查看活动详情

每日英语：

We live in the world when we love it.

当我们热爱这世界时，我们才真正生活在这世上。 -泰戈尔

除了上一篇介绍的代理模式、适配器模式、原型模式，还有很多其他常用的设计模式。在这里，我将介绍几种常见的设计模式，并提供相应的Java代码案例。

建造者模式

建造者模式是一种创建型设计模式，它将对象的构建和表示分离开来。它允许你通过指定对象类型和内容，构建出复杂的对象，同时隐藏构建细节。

以下是建造者模式的示例代码：

public class Meal {
    private String drink;
    private String mainCourse;
    private String side;
    
    public String getDrink() {
        return drink;
    }
    
    public void setDrink(String drink) {
        this.drink = drink;
    }
    
    public String getMainCourse() {
        return mainCourse;
    }
    
    public void setMainCourse(String mainCourse) {
        this.mainCourse = mainCourse;
    }
    
    public String getSide() {
        return side;
    }
    
    public void setSide(String side) {
        this.side = side;
    }
}

public interface MealBuilder {
    void buildDrink();
    void buildMainCourse();
    void buildSide();
    Meal getMeal();
}

public class BurgerMealBuilder implements MealBuilder {
    private Meal meal = new Meal();
    
    @Override
    public void buildDrink() {
        meal.setDrink("Coke");
    }
    
    @Override
    public void buildMainCourse() {
        meal.setMainCourse("Burger");
    }
    
    @Override
    public void buildSide() {
        meal.setSide("Fries");
    }
    
    @Override
    public Meal getMeal() {
        return meal;
    }
}

public class Director {
    private MealBuilder mealBuilder;
    
    public void setMealBuilder(MealBuilder mealBuilder) {
        this.mealBuilder = mealBuilder;
    }
    
    public Meal getMeal() {
        mealBuilder.buildDrink();
        mealBuilder.buildMainCourse();
        mealBuilder.buildSide();
        return mealBuilder.getMeal();
    }
}

public class Client {
    public static void main(String[] args) {
        MealBuilder burgerMealBuilder = new BurgerMealBuilder();
        
        Director director = new Director();
        director.setMealBuilder(burgerMealBuilder);
        
        Meal meal = director.getMeal();
        System.out.println("Drink: " + meal.getDrink());
        System.out.println("Main Course: " + meal.getMainCourse());
        System.out.println("Side: " + meal.getSide());
    }
}

在这个例子中，我们通过建造者模式创建了一个餐点。Meal 类表示一个餐点，它有三个属性：drink（饮料）、mainCourse（主菜）和 side（副菜）。

MealBuilder 接口定义了建造者所需的方法。BurgerMealBuilder 是一个具体的建造者，它实现了 MealBuilder 接口，并且定义了如何建造一个汉堡套餐。

Director 类是建造者的主管，它控制建造过程。通过 setMealBuilder() 方法，Director 可以使用不同的建造者来构建不同类型的餐点。

在 Client 类中，我们创建了一个 BurgerMealBuilder，并将其传递给 Director。然后，我们调用 Director 的 getMeal() 方法，返回一个餐点对象。最后，我们打印餐点的属性。

外观模式

外观模式是一种结构型设计模式，它为复杂的系统提供一个简单的接口。通过封装底层系统的复杂性，外观模式可以帮助客户端更方便地使用系统，同时也提高了系统的可维护性。

以下是外观模式的示例代码：

public class CPU {
    public void freeze() {
        System.out.println("CPU freeze");
    }
    
    public void jump(long position) {
        System.out.println("CPU jump to position " + position);
    }
    
    public void execute() {
        System.out.println("CPU execute");
    }
}

public class Memory {
    public void load(long position, byte[] data) {
        System.out.println("Memory load data at position " + position);
    }
}

public class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    
    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
    }
    
    public void start() {
        cpu.freeze();
        memory.load(0, new byte[]{});
        cpu.jump(0);
        cpu.execute();
    }
}

public class Client {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.start();
    }
}

在这个例子中，我们使用外观模式创建了一个计算机。CPU 类和 Memory 类表示计算机的两个子系统。ComputerFacade 类是一个外观，它封装了 CPU 和 Memory，为客户端提供了一个简单的启动方法。

在 Client 类中，我们创建了一个 ComputerFacade 对象，并调用 start() 方法。这个方法会依次调用 CPU 和 Memory 的方法，启动计算机。这个过程对客户端是透明的，客户端只需要调用一个简单的方法，就可以完成一个复杂的任务。

桥接模式

桥接模式是一种结构型设计模式，它将抽象部分与实现部分分离，以便它们可以独立地变化。桥接模式通过将抽象类与实现类之间的继承关系转换为对象之间的关联关系，从而实现这种分离。

以下是桥接模式的示例代码：

public interface Color {
    void applyColor();
}

public class Red implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying red color");
    }
}

public class Blue implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying blue color");
    }
}

public abstract class Shape {
    protected Color color;
    
    public Shape(Color color) {
        this.color = color;
    }
    
    abstract void draw();
}

public class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }
    
    @Override
    void draw() {
        System.out.print("Drawing circle with color ");
        color.applyColor();
    }
}

public class Square extends Shape {
    public Square(Color color) {
        super(color);
    }
    
    @Override
    void draw() {
        System.out.print("Drawing square with color ");
        color.applyColor();
    }
}

public class Client {
    public static void main(String[] args) {
        Color red = new Red();
        Color blue = new Blue();
        
        Shape circle = new Circle(red);
        Shape square = new Square(blue);
        
        circle.draw();
        square.draw();
    }
}

在这个例子中，我们使用桥接模式来实现不同颜色的形状。Color 接口表示颜色，Red 和 Blue 类是具体的颜色。Shape 抽象类表示形状，它包含一个 Color 对象。Circle 和 Square 类是具体的形状。

在 Client 类中，我们创建了两个颜色对象，一个红色和一个蓝色。然后我们创建了一个圆形和一个正方形，并分别给它们指定颜色。最后我们调用 draw() 方法，输出形状的颜色。这个过程对客户端是透明的，客户端只需要创建形状和颜色对象，并将它们组合起来，就可以完成一个复杂的任务。

总结

本篇主要聊了一下建造者模式、外观模式、桥接模式，并举例说明了一下。大家有兴趣的话，可以cv一下代码，跑跑看，体验一下这三个设计模式的玩法。