• Wenn Sie Ihren Computer starten, wird der Betriebsstatus "ausgeführt".
• Wenn Sie den Computer anhalten, wird der Betriebsstatus "Herunterfahren".
• Wenn Sie Ihren Computer neu starten, ändert sich der Betriebsstatus in "Wird ausgeführt".

Geben Sie im Beispielprogramm ** erstes Argument: erste Computeroperation **, ** zweites Argument: zweite Computeroperation ** an.

(Fall 1) Starten und stoppen Sie den Computer

Der Betriebszustand wird zuerst durch Starten auf dem Computer "ausgeführt" und dann durch Stoppen des Computers "heruntergefahren".

$ python Main.py start stop
###PC,[start]Machen
***Der Computer läuft
###Der Personal Computer[running]Ist jetzt in Betrieb

... sleep 5 second

###PC,[stop]Machen
***Der Computer ist gestoppt
###Der Betriebsstatus des PCs[shutdown]wurde

(Fall 2) Starten Sie den Computer und starten Sie ihn neu

Der Betriebszustand wird beim Starten des Computers zuerst "ausgeführt" und beim Neustart des Computers erneut "ausgeführt".

$ python Main.py start restart
###PC,[start]Machen
***Der Computer läuft
###Der Personal Computer[running]Ist jetzt in Betrieb

... sleep 5 second

###PC,[restart]Machen
***Der Computer wird neu gestartet
***Der Computer läuft
###Der Betriebsstatus des PCs[running]wurde

Das Beispielprogramm funktionierte wie erwartet.

■ Details zum Beispielprogramm

Ähnlicher Code wurde in das Git-Repository hochgeladen. https://github.com/ttsubo/study_of_design_pattern/tree/master/State

--Verzeichnisaufbau

.
├── Main.py
└── state
    ├── __init__.py
    ├── context.py
    └── state.py

(1) Die Rolle des Staates

Die Rolle "Staat" dient der Vertretung eines Staates. Definiert eine Schnittstelle, die sich für jeden Status unterschiedlich verhält. Im Beispielprogramm übernimmt die Klasse "State" diese Rolle.

state/state.py

from abc import ABCMeta, abstractmethod

class State(metaclass=ABCMeta):
    @abstractmethod
    def handle(self):
        pass

(2) Die Rolle von ConcreteState

Die Rolle "ConcreteState" repräsentiert einen bestimmten Einzelzustand. Implementieren Sie konkret die durch die Rolle "Staat" definierte Schnittstelle. Im Beispielprogramm

• Klasse "ConcreteStateBooting"
• Klasse "ConcreteStateRun"
• Klasse "ConcreteStateShutDown"
• Klasse "ConcreteStateRestart"

Ich werde diese Rolle jedoch ausprobieren.

state/state.py

class ConcreteState(State):
    def __init__(self, state):
        self.state = state
    
    def getConcreateState(self):
        return self.state


class ConcreteStateBooting(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateBooting, self).__init__(state)

    def handle(self, context):
        print("***Der Computer läuft")
        context.setState(ConcreteStateRun("running"))


class ConcreteStateRun(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateRun, self).__init__(state)

    def handle(self, context):
        print("***Der Computer ist in Betrieb")


class ConcreteStateShutDown(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateShutDown, self).__init__(state)

    def handle(self, context):
        print("***Der Computer ist gestoppt")


class ConcreteStateRestart(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateRestart, self).__init__(state)

    def handle(self, context):
        print("***Der Computer wird neu gestartet")
        context.setState(ConcreteStateBooting("booting"))
        context.handle()

(3) Rolle des Kontexts (Zustand, Kontext, Kontext)

Die Rolle "Kontext" enthält ein Objekt der Rolle "ConcreteState", das den aktuellen Status darstellt. Im Beispielprogramm übernimmt die Klasse "Kontext" diese Rolle.

state/context.py

class Context(object):
    def __init__(self, stateObj):
        self.state = stateObj

    def setState(self, obj):
        self.state = obj
    
    def handle(self):
        self.state.handle(self)

    def getState(self):
        return self.state.getConcreateState()

(4) Die Rolle des Kunden

Im Beispielprogramm übernimmt die Methode "startMain" diese Rolle.

Main.py

import sys
import time
from state.context import Context
from state.state import ConcreteStateBooting, ConcreteStateRun, ConcreteStateShutDown, ConcreteStateRestart


def setConcreteState(operation):
    if operation == "start":
        return ConcreteStateBooting("booting")
    elif operation == "stop":
        return ConcreteStateShutDown("shutdown")
    elif operation == "restart":
        return ConcreteStateRestart("restart")

def startMain(initial_operation, change_operation):
    obj = Context(setConcreteState(initial_operation))
    print("###PC,[{0}]Machen".format(initial_operation))
    obj.handle()
    print("###Der Personal Computer[{0}]Ist jetzt in Betrieb".format(obj.getState()))
    print("")

    print("... sleep 5 second")
    print("")
    time.sleep(5)

    obj.setState(setConcreteState(change_operation))
    print("###PC,[{0}]Machen".format(change_operation))
    obj.handle()
    print("###Der Betriebsstatus des PCs[{0}]wurde".format(obj.getState()))


if __name__ == "__main__":
    startMain(sys.argv[1], sys.argv[2])

■ Referenz-URL

• Entwurfsmuster in Python ~ Py-Entwurf ~ / Statusmuster
• State Design Pattern In Python