模版方法模式

内容：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 角色： 抽象类(AbstractClass)：定义抽象的原子操作（钩子操作）；实现一个模 板方法作为算法的骨架。 具体类 (ConcreteClass 实现原子操作

模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个算法的骨架，将一些步骤的具体实现延迟到子类。这意味着模板方法模式允许在父类中定义算法的结构，同时允许子类提供算法的具体实现。

模板方法模式通常包括以下角色：

1. 抽象类（Abstract Class）：抽象类定义了算法的骨架，包括算法的结构和一些抽象方法，这些方法由子类实现。
2. 具体类（Concrete Class）：具体类继承自抽象类，并实现了抽象方法，提供了算法的具体实现。

from time import sleep
from abc import ABCMeta, abstractmethod


class Window(metaclass=ABCMeta):

    def start(self):
        pass

    def repaint(self):
        pass

    def stop(self):
        pass

    def run(self):
        self.start()
        while True:
            try:
                self.repaint()
                sleep(1)
            except KeyboardInterrupt:
                break
        self.stop()


class MyWindows(Window):
    def __init__(self, msg):
        self.msg = msg

    def start(self):
        print("窗口开始运行")

    def stop(self):
        print("窗口结束运行")

    def repaint(self):
        print(self.msg)


MyWindows("hello -----").run()


# 抽象类
class AbstractClass:
    def template_method(self):
        self.step1()
        self.step2()

    def step1(self):
        pass

    def step2(self):
        pass


# 具体类1
class ConcreteClass1(AbstractClass):
    def step1(self):
        print("ConcreteClass1 - Step 1")

    def step2(self):
        print("ConcreteClass1 - Step 2")


# 具体类2
class ConcreteClass2(AbstractClass):
    def step1(self):
        print("ConcreteClass2 - Step 1")

    def step2(self):
        print("ConcreteClass2 - Step 2")


concrete1 = ConcreteClass1()
concrete1.template_method()
"""
输出:
ConcreteClass1 - Step 1
ConcreteClass1 - Step 2
"""

concrete2 = ConcreteClass2()
concrete2.template_method()
"""
输出:
ConcreteClass2 - Step 1
ConcreteClass2 - Step 2
"""