strategy pattern

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户端。简单来说，策略模式就是将一个算法（策略）封装起来，使得不同的策略可以相互替换，从而使得算法的变化独立于使用算法的客户端。这样做的好处是，客户端可以根据不同的需求选择不同的策略，从而达到不同的效果。

相关问题

为我介绍这几种设计模式composite pattern, decorator pattern, strategy pattern, template pattern, factory pattern, observer pattern, builder pattern, facade pattern, adapter pattern

1. Composite Pattern：将对象组合成树形结构来表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。常用于处理树形结构中的问题。

2. Decorator Pattern：动态地给对象添加一些额外的职责。可以通过包装一个装饰类来实现对原有类的功能扩展，而不需要修改原有类的代码。常用于需要在运行时动态地添加或删除对象的功能。

3. Strategy Pattern：定义一系列算法，将它们一个个封装起来，并且使它们可以相互替换。使得算法可以独立于使用它的客户端而变化。常用于需要在运行时动态地选择算法的情况。

4. Template Pattern：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。常用于算法的框架已经确定，但某些步骤需要由子类来实现的情况。

5. Factory Pattern：定义一个用于创建对象的接口，让子类决定实例化哪一个类。使得一个类的实例化延迟到其子类。常用于需要根据不同的条件创建不同的对象的情况。

6. Observer Pattern：定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。常用于需要实现对象之间的消息传递或者事件触发机制的情况。

7. Builder Pattern：将一个复杂对象的构造过程分解为多个简单的对象构造过程，使得同样的构造过程可以创建不同的表示。常用于需要创建复杂对象的情况。

8. Facade Pattern：为子系统中的一组接口提供一个统一的接口，使得子系统更加容易使用。常用于需要简化复杂系统使用的情况。

9. Adapter Pattern：将一个类的接口转换成客户端希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以在一起工作。常用于需要将旧接口转换成新接口的情况。

Design a simple Book Seller System with strategy pattern. (25 points) (a)You don’t care all the functions of the system. (b)There are three kinds of client which include VIPMember(0.9*price), NormalMember(1*price), SuperMember(0.8*price). They have the different discount when they buy book from the system. (c)You must use strategy pattern when you design the system. (d)Firstly, you should give the UML class diagram with the strategy pattern. (5 points) (e)Secondly, you should write the code for each class you design in the UML. (15 points) (f)Thirdly, you should write a class named Test which include a main() method, we support there are three clients named Tom(VIPMember), John(NormalMember) and Mike(SuperMember). The class you write can sell a book to the three clients. We support the price of the book is 150.(5 points)

(a) The Book Seller System should have the following functions:
- Add book to inventory
- Remove book from inventory
- Search for book in inventory
- Sell book to customer
- Calculate the price of a book based on the client's membership level

(b) There are three kinds of clients:
- VIPMember: gets a 10% discount (0.9 * price)
- NormalMember: gets no discount (1 * price)
- SuperMember: gets a 20% discount (0.8 * price)

(c) The strategy pattern will be used to define the different discount strategies for each type of client.

(d) UML class diagram with the strategy pattern:

+-------------------------+        +------------------------+
|        BookSeller       |        |      MemberStrategy     |
+-------------------------+        +------------------------+
| - inventory: List<Book> |        | +calculatePrice(price)  |
+-------------------------+        +------------------------+
| +addBook(book: Book)    |                  ^               
| +removeBook(book: Book) |                  |               
| +searchBook(title: str) |                  |               
| +sellBook(client: Member, |                  |               
|            book: Book)  |        +------------------------+
+-------------------------+        |    VIPMemberStrategy    |
                                   +------------------------+
                                   | +calculatePrice(price)  |
                                   +------------------------+
                                   |    NormalMemberStrategy |
                                   +------------------------+
                                   | +calculatePrice(price)  |
                                   +------------------------+
                                   |   SuperMemberStrategy   |
                                   +------------------------+
                                   | +calculatePrice(price)  |
                                   +------------------------+

(e) Code for each class:

class Book:
    def __init__(self, title, author, price):
        self.title = title
        self.author = author
        self.price = price


class Member:
    def __init__(self, name, strategy):
        self.name = name
        self.strategy = strategy

    def setStrategy(self, strategy):
        self.strategy = strategy


class MemberStrategy:
    def calculatePrice(self, price):
        pass


class VIPMemberStrategy(MemberStrategy):
    def calculatePrice(self, price):
        return price * 0.9


class NormalMemberStrategy(MemberStrategy):
    def calculatePrice(self, price):
        return price


class SuperMemberStrategy(MemberStrategy):
    def calculatePrice(self, price):
        return price * 0.8


class BookSeller:
    def __init__(self):
        self.inventory = []

    def addBook(self, book):
        self.inventory.append(book)

    def removeBook(self, book):
        self.inventory.remove(book)

    def searchBook(self, title):
        for book in self.inventory:
            if book.title == title:
                return book
        return None

    def sellBook(self, client, book):
        price = book.price
        price = client.strategy.calculatePrice(price)
        print("Selling book {} to {} for price: {}".format(book.title, client.name, price))


# Example usage
book1 = Book("Harry Potter", "J.K. Rowling", 200)
book2 = Book("Lord of the Rings", "J.R.R. Tolkien", 150)

vip = Member("Tom", VIPMemberStrategy())
normal = Member("John", NormalMemberStrategy())
super = Member("Mike", SuperMemberStrategy())

seller = BookSeller()
seller.addBook(book1)
seller.addBook(book2)

seller.sellBook(vip, book1)  # Selling book Harry Potter to Tom for price: 180.0
seller.sellBook(normal, book2)  # Selling book Lord of the Rings to John for price: 150
seller.sellBook(super, book1)  # Selling book Harry Potter to Mike for price: 160.0

(f) Test class:

class Test:
    def main():
        book1 = Book("Harry Potter", "J.K. Rowling", 200)
        book2 = Book("Lord of the Rings", "J.R.R. Tolkien", 150)

        vip = Member("Tom", VIPMemberStrategy())
        normal = Member("John", NormalMemberStrategy())
        super = Member("Mike", SuperMemberStrategy())

        seller = BookSeller()
        seller.addBook(book1)
        seller.addBook(book2)

        seller.sellBook(vip, book1)  # Selling book Harry Potter to Tom for price: 180.0
        seller.sellBook(normal, book2)  # Selling book Lord of the Rings to John for price: 150
        seller.sellBook(super, book1)  # Selling book Harry Potter to Mike for price: 160.0

Test.main()