设计模式

本文最后更新于：2 小时前

策略模式

什么是策略模式

策略模式定义了一系列的算法，将他们单独封装起来，并使之可以相互替换。

结构

  • 抽象策略类：由一个接口或抽象类实现，给出所有具体策略类所需的接口。
  • 具体策略类：实现由抽象策略类定义的接口，提供具体的算法实现或行为。
  • 环境类

demo

点此处下载源码

促销互动

image-20210509220834500

package strategy.demo1_salesMan;

/**
 * @author QiuQian
 * 抽象策略
 */
public interface Strategy {
    public void show();
}


package strategy.demo1_salesMan;

/**
 * @author QiuQian
 * 具体策略
 */
public class StrategyA implements Strategy{
    @Override
    public void show() {
        System.out.println("具体策略A");
    }
}


package strategy.demo1_salesMan;

/**
 * @author QiuQian
 * 具体策略
 */
public class StrategyB implements Strategy {
    @Override
    public void show() {
        System.out.println("具体策略B");
    }
}


package strategy.demo1_salesMan;

/**
 * @author QiuQian
 * 具体策略
 */
public class StrategyC implements Strategy {
    @Override
    public void show() {
        System.out.println("具体策略C");
    }
}


package strategy.demo1_salesMan;

/**
 * @author QiuQian
 * 环境
 */
public class SalesMan {
    private Strategy strategy;

    public SalesMan(Strategy strategy) {
        this.strategy = strategy;
    }

    public void salesManShow() {
        strategy.show();
    }
}


package strategy.demo1_salesMan;

/**
 * @author QiuQian
 */
public class Client {
    public static void main(String[] args) {
        SalesMan salesMan = new SalesMan(new StrategyA());
        salesMan.salesManShow();
    }
}

书店

image-20210509221323541

image-20210509223648428

package strategy.demo2_bookStore;

/**
 * @author QiuQian
 * 抽象策略
 */
public interface Book {

	public void calculate(double price);

}


package strategy.demo2_bookStore;

/**
 * @author QiuQian
 * 具体策略
 */
public class ComputerBook implements Book {

	@Override
	public void calculate(double price) {
		System.out.println("所有计算机类图书(ComputerBook)每本都有10%的折扣");
		System.out.println(price * 0.9);
	}

}


package strategy.demo2_bookStore;

/**
 * @author QiuQian
 * 具体策略
 */
public class LanguageBook implements Book {

	@Override
	public void calculate(double price) {
		System.out.println("所有语言类图书(LanguageBook)每本都有2元的折扣");
		System.out.println(price - 2);
	}

}


package strategy.demo2_bookStore;

/**
 * @author QiuQian
 * 具体策略
 */
public class NovelBook implements Book {

	@Override
	public void calculate(double price) {
		System.out.println("小说类图书(NovelBook)每100元有10元的折扣");
		//计算有多少个100元
		int t = (int)price / 100;
		System.out.println(price - t * 10);
	}

}


package strategy.demo2_bookStore;

/**
 * @author QiuQian
 * 环境
 */
public class Price {

	private Book book;

	public Price(Book book) {
		this.book = book;
	}

	public void cal(double price) {
		book.calculate(price);
	}

}


package strategy.demo2_bookStore;

/**
 * @author QiuQian
 */
public class Client {
    public static void main(String[] args) {
        Price price = new Price(new LanguageBook());
        price.cal(200);
        System.out.println("====================");

        Price price1 = new Price(new ComputerBook());
        price1.cal(300);
        System.out.println("====================");

        Price price2 = new Price(new NovelBook());
        price2.cal(100);
        System.out.println("====================");

    }
}

运行结果

image-20210509222456118

后记

学校开了设计模式这门课，然而给我们班分了一个sb老师……课不好好讲，天天吹牛，净整些没用的。教材用的是《Head First》英文原版。看原版实在有些吃力，B站有个老外按照这本书讲的，但是中文字幕也不是很友好。于是去图书馆借了一本中文版的，配合上各种开源博客加上尚硅谷和黑马程序员的Java设计模式，决定自己总结课内的十种设计模式。大概每篇的内容都是概念、结构和案例。

图片来源于网络，也会有自己画的类图，具体用什么工具画类图还在摸索中，Atash这个软件很方便，但是似乎用的人不是很多，教程不好找，而且我到现在都没找到怎么在方法里面添加构造器。其他的诸如draw.io这类画图软件又不如Atash来得方便，几乎需要全部自己手动写。

案例来源于尚硅谷、黑马、《Head First》以及学校里的平时小作业。

最近博客写得少了，手上的在做的项目比较多，每次都说抽点空出来更新一些博客填一下以前的坑，然而实在是不太好抽时间啊。。。

观察者模式

前言

案例是黑马程序员的WeiXin订阅案例，这个案例简单，很容易理解。没有用《Head First》里面经典的气象站案例是因为我觉得这本书里面这个案例写的不太好，有点乱，让本来就不容易理解的观察者模式更看着更复杂了。

什么是观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

结构

  • 抽象主题(Subject)：提供用于保存观察者对象的聚集类，增加和删除观察者对象的方法，以及通知所有观察者的抽象方法。
  • 具体主题：实现抽象主题中的通知方法，当具体主题内部发生改变时，通知所有注册过的观察者对象。
  • 抽象观察者(Observer)：是一个抽象类或者接口，包含一个更新自己的抽象方法，当接到具体主题传送的更改通知时，调用该方法。
  • 具体观察者：实现抽象观察者中定义的方法。

image-20210510184030193

demo

点此处下载源码

WeiXin

package observer.demo_WeiXin;

/**
 * @author QiuQian
 * 抽象观察者
 */
public interface Observer {
    public void update(String message);
}


package observer.demo_WeiXin;

/**
 * @author QiuQian
 * 抽象主题
 */
public interface Subject {
    public void registerObserver(Observer observer);
    public void removeObserver(Observer observer);
    public void notifyObserver(String message);
}


package observer.demo_WeiXin;

import java.util.ArrayList;
import java.util.List;

/**
 * @author QiuQian
 * 具体抽象主题
 */
public class SubscriptionSubject implements Subject{
    private List<Observer> observers = new ArrayList<>();
    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        int i = observers.indexOf(observer);
        if ( i > 0 ) {
            observers.remove(i);
        }
    }

    @Override
    public void notifyObserver(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}


package observer.demo_WeiXin;

/**
 * @author QiuQian
 * 具体观察者
 */
public class WeiXinUser implements Observer {
    private String name;

    public WeiXinUser(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " - " + message);
    }
}


package observer.demo_WeiXin;

/**
 * @author QiuQian
 */
public class Client {
    public static void main(String[] args) {
        // 创建具体抽象主题
        SubscriptionSubject subscriptionSubject = new SubscriptionSubject();
        // 创建具体观察者
        WeiXinUser user1 = new WeiXinUser("Jack");
        WeiXinUser user2 = new WeiXinUser("Tom");
        WeiXinUser user3 = new WeiXinUser("Amy");
        // 注册具体观察者
        subscriptionSubject.registerObserver(user1);
        subscriptionSubject.registerObserver(user2);
        subscriptionSubject.registerObserver(user3);
        // 更新时给用户发送通知
        subscriptionSubject.notifyObserver("你关注的公众号更新啦");
    }
}

运行结果

image-20210510190049695

命令模式

什么是命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

命令模式将一个请求封装成一个对象，使发出请求的责任和执行请求的责任分隔开，两者之间通过命令对象进行沟通 ，从而可以用不同的请求对客户进行参数化。

结构

  • 抽象命令角色：定义命令的接口，声明执行的方法。
  • 具体命令角色：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
  • 实现者/接收者角色：接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能实现命令要求的相应功能。
  • 调用者/请求者角色：要求命令对象执行请求，通常会持有命令对象(可List)，这是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。

demo

image-20210513123658741

package command.demo2_order;

import java.util.HashMap;
import java.util.Map;

/**
 * @author QiuQian
 */
public class Order {

    private int diningTable;

    private Map<String, Integer> foodDir = new HashMap<String, Integer>();

    public int getDiningTable() {
        return diningTable;
    }

    public void setDiningTable(int diningTable) {
        this.diningTable = diningTable;
    }

    public Map<String, Integer> getFoodDir() {
        return foodDir;
    }

    public void setFood(String name, int num) {
        foodDir.put(name, num);
    }
}


package command.demo2_order;

/**
 * @author QiuQian
 * 厨师类
 */
public class SeniorChef {

    public void makeFood(String name, int num) {
        System.out.println(num + "份" + name);
    }

}


package command.demo2_order;

import java.util.Map;
import java.util.Set;

/**
 * @author QiuQian
 * 具体命令类
 */
public class OrderCommand implements Command {

    /**
     * 持有接收者对象
     */
    private SeniorChef receiver;
    private Order order;

    public OrderCommand(SeniorChef receiver, Order order) {
        this.receiver = receiver;
        this.order = order;
    }

    @Override
    public void execute() {
        System.out.println("==========#" + order.getDiningTable() + "桌的的订单==========");
        Map<String, Integer> foodDir = order.getFoodDir();
        Set<String> keys = foodDir.keySet();
        for ( String foodName : keys ) {
            receiver.makeFood(foodName, foodDir.get(foodName));
        }

        System.out.println("==========" + order.getDiningTable() + "桌的订单准备完毕" + "==========");
    }
}


package command.demo2_order;

/**
 * @author QiuQian
 * 抽象命令类
 */
public interface Command {
    public void execute();
}


package command.demo2_order;

import java.util.ArrayList;
import java.util.List;

/**
 * @author QiuQian
 * 请求者角色
 */
public class Waiter {

    /**
     * 持有多个命令对象
     */
    private List<Command> commands = new ArrayList<>();

    public void setCommand(Command command) {
        commands.add(command);
    }

    public void orderUp() {
        System.out.println("服务员：有新订单来啦~");
        for (Command command : commands) {
            if ( command != null ) {
                command.execute();
            }
        }
    }
}


package command.demo2_order;

/**
 * @author QiuQian
 */
public class Client {
    public static void main(String[] args) {
        // 创建订单对象
        Order order1 = new Order();
        order1.setDiningTable(1);
        order1.setFood("提拉米苏", 1);
        order1.setFood("冰美式", 1);

        // 创建第二个订单对象
        Order order2 = new Order();
        order2.setDiningTable(2);
        order2.setFood("抹茶慕斯", 1);
        order2.setFood("冷萃咖啡", 1);

        // 创建接收者对象
        SeniorChef receiver = new SeniorChef();
        // 创建命令对象
        OrderCommand orderCommand1 = new OrderCommand(receiver, order1);
        OrderCommand orderCommand2 = new OrderCommand(receiver, order2);

        // 创建调用者
        Waiter invoke = new Waiter();
        invoke.setCommand(orderCommand1);
        invoke.setCommand(orderCommand2);

        // 服务员发起命令
        invoke.orderUp();

    }
}

使用场景

  • 系统需要将请求调用者和接收者解耦合，使得调用者和接收者不直接交互
  • 系统需要在不同的时间指定请求，将请求排队并执行请求
  • 系统需要支持命令的撤销操作和恢复操作

装饰者模式

什么是装饰者模式

装饰者模式允许向一个现有的对象添加新的功能，同时又不改变其结构。

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰者模式相比生成子类更为灵活。

结构

  • 抽象构建角色：定义抽象接口以规范准备接受附加责任的对象。
  • 具体构建角色：实现抽象构建，通过装饰角色为其添加职责。
  • 抽象装饰角色：继承或实现抽象构建，并包含具体构建的实例，可以通过子类扩展具体构建的功能。
  • 具体装饰角色：实现抽象装饰的相关方法，并给具体 构建对象添加附加的责任。

demo

点此处下载源码

两个demo分别来自黑马和尚硅谷，个人认为黑马的这个案例讲解得更加清晰。

快餐店

image-20210512134408717

（图片有小错误，菱形的位置有错）

package decorator.demo_fastFood;

/**
 * @author QiuQian
 * 抽象构建角色
 */
public abstract class FastFood {
    private double price;
    private String desc;

    public FastFood() {
    }

    public FastFood(double price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public abstract double cost();
}


package decorator.demo_fastFood;

/**
 * @author QiuQian
 * 具体构建角色
 */
public class FriedNoodle  extends FastFood{

    public FriedNoodle() {
        super(15, "炒面");
    }

    @Override
    public double cost() {
        return getPrice();
    }
}


package decorator.demo_fastFood;

/**
 * @author QiuQian
 * 具体构建角色
 */
public class FriedRice extends FastFood{
    public FriedRice() {
        super(10, "炒饭");
    }

    @Override
    public double cost() {
        return getPrice();
    }
}


package decorator.demo_fastFood;

/**
 * @author QiuQian
 * 抽象装饰角色
 * 具体加什么配料并不明确，所以定义为抽象类
 */
public abstract class Garnish extends FastFood {
    private FastFood fastFood;

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }

    public Garnish(FastFood fastFood, double price, String desc) {
        super(price, desc);
        this.fastFood = fastFood;
    }
}


package decorator.demo_fastFood;

/**
 * @author QiuQian
 * 具体装饰角色
 */
public class Egg extends Garnish {
    public Egg(FastFood fastFood) {
        super(fastFood, 2, "鸡蛋");
    }

    @Override
    public double cost() {
        // 鸡蛋的价格 + 快餐的价格
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        // 鸡蛋的描述 + 快餐的描述
        return super.getDesc() + " " + getFastFood().getDesc();
    }
}


package decorator.demo_fastFood;

/**
 * @author QiuQian
 * 具体装饰者角色
 */
public class Bacon extends Garnish {
    public Bacon(FastFood fastFood) {
        super(fastFood, 5, "培根");
    }

    @Override
    public double cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}


package decorator.demo_fastFood;

/**
 * @author QiuQian
 */
public class Client {
    public static void main(String[] args) {
        FastFood friedNoodle = new FriedNoodle();
        System.out.println(friedNoodle.getDesc() + " " + friedNoodle.cost() + "元");
        friedNoodle = new Egg(friedNoodle);
        System.out.println(friedNoodle.getDesc() + " " + friedNoodle.cost() + "元");

        System.out.println("===================");

        FastFood fireRice = new FriedRice();
        System.out.println(fireRice.getDesc() + " " + fireRice.cost() + "元");
        fireRice = new Bacon(fireRice);
        System.out.println(fireRice.getDesc() + " " + fireRice.cost() + "元");

    }
}

运行结果

image-20210512140429325

咖啡

package decorator.demo_coffee;

/**
 * @author QiuQian
 * 抽象构建角色
 */
public abstract class Drink {
    public String desc;
    private double price = 0.0;

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public abstract double cost();
}


package decorator.demo_coffee;

/**
 * @author QiuQian
 */
public class Coffee extends Drink {

    @Override
    public double cost() {
        return super.getPrice();
    }
}


package decorator.demo_coffee;

/**
 * @author QiuQian
 * 具体构建角色
 */
public class Espresso extends Coffee {
    public Espresso() {
        setDesc("Espresso");
        setPrice(16);
    }
}


package decorator.demo_coffee;

/**
 * @author QiuQian
 * 具体构建角色
 */
public class Latte extends Coffee {
    public Latte() {
        setDesc("Latte");
        setPrice(25);
    }
}


package decorator.demo_coffee;

/**
 * @author QiuQian
 * 具体构建角色
 */
public class LongBlack extends Coffee {
    public LongBlack() {
        setDesc("LongBlack");
        setPrice(18);
    }
}


package decorator.demo_coffee;

/**
 * @author QiuQian
 * 抽象装饰角色
 */
public class Decorator extends Drink {
    private Drink drink;

    public Decorator(Drink drink) {
        this.drink = drink;
    }

    @Override
    public double cost() {
        // getPrice() Decorator
        return getPrice() + drink.cost();
    }

    @Override
    public String getDesc() {
        return desc + getPrice() + " + " + drink.getDesc();
    }
}



package decorator.demo_coffee;

/**
 * @author QiuQian
 * 具体装饰角色
 */
public class Milk extends Decorator {
    public Milk(Drink drink) {
        super(drink);
        setDesc("Milk");
        setPrice(8);
    }
}



package decorator.demo_coffee;

/**
 * @author QiuQian
 */
public class Client {
    public static void main(String[] args) {
        Drink order = new Latte();
        order = new Milk(order);
        System.out.println(order.getDesc());
        System.out.println(order.cost());

        System.out.println("====================");

        Drink order2 = new Espresso();
        order2 = new Milk(order2);
        System.out.println(order2.getDesc());
        System.out.println(order2.cost());

        System.out.println("====================");

        Drink order3 = new LongBlack();
        order3 = new Milk(order3);
        System.out.println(order3.getDesc());
        System.out.println(order3.cost());

    }
}

运行结果

image-20210512131728660

设计模式

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！