老项目焕发新生，三大设计模式，为您轻松搞定

2023-02-05 14:19:37

老项目焕发新生：三大设计模式让您轻松搞定

身为一名程序员，我们不可避免地会接手那些运行多年的老项目。这些项目往往代码杂乱无章、结构混乱、功能冗余，简直让人头疼不已。不过，掌握了合适的设计模式，这些问题便迎刃而解。下面，我将为您介绍三种实用且强大的设计模式，助您让老项目焕发新生。

工厂模式：模块化开发，代码更清晰

工厂模式是一种创建型设计模式，它将对象的创建过程与对象的具体实现分离。这使得代码更灵活，更容易维护。举个例子，在电商系统中，我们可能需要创建不同类型的订单，如普通订单、秒杀订单、团购订单等。如果我们直接在代码中创建这些订单对象，那么当我们需要添加新的订单类型时，就必须修改代码，非常不方便。

而使用工厂模式，我们就可以将订单的创建过程交给一个工厂类来处理。当我们需要创建一个订单对象时，只需要向工厂类发送一个请求，工厂类就会根据请求创建出相应的订单对象。这样，当我们需要添加新的订单类型时，只需要修改工厂类即可，无需修改其他代码，大大提高了代码的灵活性。

class OrderFactory:
    def create_order(self, order_type):
        if order_type == "normal":
            return NormalOrder()
        elif order_type == "seckill":
            return SeckillOrder()
        elif order_type == "group_buy":
            return GroupBuyOrder()
        else:
            raise ValueError("Invalid order type")

class Order:
    def __init__(self):
        pass

    def get_total_price(self):
        pass

class NormalOrder(Order):
    def __init__(self):
        super().__init__()

    def get_total_price(self):
        return 100

class SeckillOrder(Order):
    def __init__(self):
        super().__init__()

    def get_total_price(self):
        return 50

class GroupBuyOrder(Order):
    def __init__(self):
        super().__init__()

    def get_total_price(self):
        return 80

def main():
    factory = OrderFactory()

    order1 = factory.create_order("normal")
    order2 = factory.create_order("seckill")
    order3 = factory.create_order("group_buy")

    print(order1.get_total_price())  # 100
    print(order2.get_total_price())  # 50
    print(order3.get_total_price())  # 80

if __name__ == "__main__":
    main()

装饰器模式：灵活扩展，功能更强大

装饰器模式是一种结构型设计模式，它允许我们动态地给对象添加新的功能，而无需修改对象本身的代码。这使得代码更易于维护和扩展。比如，在一个游戏系统中，我们可能需要对不同的角色添加不同的技能。如果我们直接在代码中添加这些技能，那么当我们需要添加新的技能时，就必须修改角色的代码，非常麻烦。

而使用装饰器模式，我们就可以将技能的添加交给一个装饰器类来处理。当我们需要给一个角色添加技能时，只需要创建一个装饰器对象，然后将这个装饰器对象与角色对象关联起来即可。这样，当我们需要添加新的技能时，只需要创建一个新的装饰器类即可，无需修改角色的代码，大大提高了代码的可扩展性。

class Role:
    def __init__(self):
        self.skills = []

    def add_skill(self, skill):
        self.skills.append(skill)

    def get_skills(self):
        return self.skills

class Skill:
    def __init__(self, name):
        self.name = name

    def use(self):
        print(f"Using skill: {self.name}")

class AttackSkill(Skill):
    def __init__(self, name, damage):
        super().__init__(name)
        self.damage = damage

    def use(self):
        super().use()
        print(f"Damage: {self.damage}")

class DefenseSkill(Skill):
    def __init__(self, name, defense):
        super().__init__(name)
        self.defense = defense

    def use(self):
        super().use()
        print(f"Defense: {self.defense}")

def main():
    role = Role()
    role.add_skill(AttackSkill("Fireball", 100))
    role.add_skill(DefenseSkill("Shield", 50))

    for skill in role.get_skills():
        skill.use()

if __name__ == "__main__":
    main()

策略模式：算法解耦，代码更简洁

策略模式是一种行为型设计模式，它将算法的实现与算法的调用分离。这使得代码更易于维护和复用。比如，在一个排序系统中，我们可能需要使用不同的排序算法，如冒泡排序、快速排序、归并排序等。如果我们直接在代码中实现这些排序算法，那么当我们需要更换排序算法时，就必须修改代码，非常不方便。

而使用策略模式，我们就可以将排序算法的实现交给一个策略类来处理。当我们需要使用某个排序算法时，只需要创建一个策略对象，然后将这个策略对象与排序系统关联起来即可。这样，当我们需要更换排序算法时，只需要更换策略对象即可，无需修改其他代码，大大提高了代码的可重用性。

class Sorter:
    def __init__(self, strategy):
        self.strategy = strategy

    def sort(self, data):
        return self.strategy.sort(data)

class BubbleSortStrategy:
    def sort(self, data):
        for i in range(len(data)):
            for j in range(i + 1, len(data)):
                if data[i] > data[j]:
                    data[i], data[j] = data[j], data[i]
        return data

class QuickSortStrategy:
    def sort(self, data):
        if len(data) <= 1:
            return data

        pivot = data[len(data) // 2]
        left = [x for x in data if x < pivot]
        middle = [x for x in data if x == pivot]
        right = [x for x in data if x > pivot]

        return self.sort(left) + middle + self.sort(right)

class MergeSortStrategy:
    def merge(self, left, right):
        merged = []
        left_index = 0
        right_index = 0

        while left_index < len(left) and right_index < len(right):
            if left[left_index] <= right[right_index]:
                merged.append(left[left_index])
                left_index += 1
            else:
                merged.append(right[right_index])
                right_index += 1

        merged.extend(left[left_index:])
        merged.extend(right[right_index:])

        return merged

    def sort(self, data):
        if len(data) <= 1:
            return data

        mid = len(data) // 2
        left = self.sort(data[:mid])
        right = self.sort(data[mid:])

        return self.merge(left, right)

def main():
    data = [5, 3, 1, 2, 4]

    bubble_sorter = Sorter(BubbleSortStrategy())
    print(bubble_sorter.sort(data))  # [1, 2, 3, 4, 5]

    quick_sorter = Sorter(QuickSortStrategy())
    print(quick_sorter.sort(data))  # [1, 2, 3, 4, 5]

    merge_sorter = Sorter(MergeSortStrategy())
    print(merge_sorter.sort(data))  # [1, 2, 3, 4, 5]

if __name__ == "__main__":
    main()