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

每日英语：

Do every act of your life as if it were your last.

把生命中的每一件事都当成最后一件来做。 -马可·奥勒留

除了上一篇介绍的单例模式、工厂模式和观察者模式，还有很多其他常用的设计模式。在这里，我将介绍几种常见的设计模式，并提供相应的Java代码案例。

装饰者模式

装饰者模式（Decorator Pattern）允许你动态地将新功能附加到对象上。它是一种结构型设计模式，它允许你通过将对象包装在一个装饰者对象中来扩展对象的行为。以下是一个Java代码示例：

public interface Pizza {
    String getDescription();
    double getCost();
}

public class BasicPizza implements Pizza {
    @Override
    public String getDescription() {
        return "Basic pizza with tomato sauce and cheese";
    }
    
    @Override
    public double getCost() {
        return 4.99;
    }
}

public abstract class PizzaDecorator implements Pizza {
    protected Pizza pizza;
    
    public PizzaDecorator(Pizza pizza) {
        this.pizza = pizza;
    }
    
    @Override
    public String getDescription() {
        return pizza.getDescription();
    }
    
    @Override
    public double getCost() {
        return pizza.getCost();
    }
}

public class PepperoniDecorator extends PizzaDecorator {
    public PepperoniDecorator(Pizza pizza) {
        super(pizza);
    }
    
    @Override
    public String getDescription() {
        return super.getDescription() + ", pepperoni";
    }
    
    @Override
    public double getCost() {
        return super.getCost() + 1.99;
    }
}

public class MushroomDecorator extends PizzaDecorator {
    public MushroomDecorator(Pizza pizza) {
        super(pizza);
    }
    
    @Override
    public String getDescription() {
        return super.getDescription() + ", mushrooms";
    }
    
    @Override
    public double getCost() {
        return super.getCost() + 0.99;
    }
}

在上面的代码中，Pizza是一个接口，它定义了披萨的基本行为。BasicPizza是一个具体的披萨实现，它是最基本的披萨，只有番茄酱和奶酪。PizzaDecorator是一个抽象的装饰者类，它允许你为披萨添加额外的配料。PepperoniDecorator和MushroomDecorator是两个具体的装饰者类，它们允许你为披萨添加意大利辣味香肠和蘑菇。

模板方法模式

模板方法模式（Template Method Pattern）定义了一个算法的框架，将一些步骤推迟到子类中。它是一种行为型设计模式，它允许你定义一个算法的步骤，并将某些步骤延迟到子类中。以下是一个Java代码示例：

public abstract class Meal {
    public final void doMeal() {
        prepareIngredients();
        cook();
        eat();
        cleanUp();
    }
    
    public abstract void prepareIngredients();
    
    public abstract void cook();
    
    public void eat() {
        System.out.println("The meal is delicious!");
    }
    
    public void cleanUp() {
        System.out.println("The kitchen is clean!");
    }
}

public class SpaghettiMeal extends Meal {
    @Override
    public void prepareIngredients() {
        System.out.println("Gathering ingredients for spaghetti.");
    }
    
    @Override
    public void cook() {
        System.out.println("Cooking spaghetti.");
    }
}

public class HamburgerMeal extends Meal {
    @Override
    public void prepareIngredients() {
        System.out.println("Gathering ingredients for hamburger.");
    }
    
    @Override
    public void cook() {
        System.out.println("Cooking hamburger.");
    }
    
    @Override
    public void eat() {
        System.out.println("The hamburger is delicious!");
    }
}

public class TemplateMethodDemo {
    public static void main(String[] args) {
        Meal spaghettiMeal = new SpaghettiMeal();
        spaghettiMeal.doMeal();
        
        System.out.println();
        
        Meal hamburgerMeal = new HamburgerMeal();
        hamburgerMeal.doMeal();
    }
}

在上面的代码中，Meal是一个抽象类，它定义了一顿饭的模板方法doMeal，其中包含了准备食材、烹饪、用餐和清理的步骤。SpaghettiMeal和HamburgerMeal是两个具体的餐食实现类，它们分别实现了prepareIngredients和cook方法。HamburgerMeal还重写了eat方法，以自定义用餐过程。

TemplateMethodDemo是一个测试类，它创建了一个意大利面餐食和一个汉堡餐食，并分别调用它们的doMeal方法来演示模板方法模式。

策略模式

策略模式（Strategy Pattern）定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。它是一种行为型设计模式，它允许在运行时选择算法的行为。以下是一个Java代码示例：

public interface SortStrategy {
    void sort(int[] dataset);
}

public class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] dataset) {
        System.out.println("Sorting using bubble sort strategy");
        // 在此处实现冒泡排序算法
    }
}

public class QuickSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] dataset) {
        System.out.println("Sorting using quick sort strategy");
        // 在此处实现快速排序算法
    }
}

public class Sorter {
    private SortStrategy strategy;
    
    public Sorter(SortStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void sort(int[] dataset) {
        strategy.sort(dataset);
    }
}

在上面的代码中，SortStrategy是一个接口，它定义了一个排序算法的方法。BubbleSortStrategy和QuickSortStrategy是具体的排序策略实现类，它们实现了SortStrategy接口，并定义了相应的排序算法。Sorter是一个排序器类，它持有一个SortStrategy对象的引用，并使用它来实现排序。

通过这种方式，我们可以在运行时选择使用不同的排序策略，而不需要修改排序器类的代码。例如，我们可以将Sorter对象的策略设置为BubbleSortStrategy或QuickSortStrategy，以实现不同的排序算法。这种灵活性使得策略模式成为许多Java应用程序中常用的设计模式之一。

总结

本篇主要讲了一下装饰者模式、模板方法模式、策略模式这三种常用的设计模式，并给了一个代码案例，大家有兴趣的话，可以跑一下案例学习学习。