So verwenden Sie das Java-Statusentwurfsmuster, um den Objektstatusübergang zu implementieren

Einführung

Java State Pattern ist ein objektorientiertes Entwurfsmuster, das den Zustand eines Objekts in ein unabhängiges Zustandsobjekt kapselt und das Verhalten des Objekts vom Zustandsobjekt entkoppelt. Es ermöglicht dem Objekt, seinen internen Zustand zu speichern, wenn eine Änderung auftritt. sein Verhalten ändert sich. Dieses Muster kapselt das Verhalten des Objekts in verschiedenen Zustandsobjekten, anstatt alle Verhaltensweisen in einer Klasse zusammenzufassen.

Das Java-Zustandsmuster besteht im Allgemeinen aus den folgenden 3 Rollen:

• Zustandsschnittstelle: Definiert eine Reihe von Methoden in Bezug auf Kontextobjekte, die von bestimmten Objekten in verschiedenen Zuständen implementiert werden.

• Konkreter Zustand: Implementiert die Zustandsschnittstelle, insbesondere Zustandsobjekte sind unterschiedliche Zustandsimplementierungen

• Kontext : Ein Objekt mit mehreren Zuständen. Das Kontextobjekt kann den Zustand zur Laufzeit ändern und dadurch sein Verhalten ändern.

Es ist zu beachten, dass es viele Möglichkeiten gibt, Muster zu implementieren, z. B. die Verwendung von Schnittstellen und abstrakten Klassen Zustände, Verwendung von Aufzählungen zum Implementieren von Zuständen usw. Die spezifische Implementierungsmethode hängt von den spezifischen Anforderungen und Szenarien ab.

Implementierung

Angenommen, wir haben ein einfaches Spiel Zustandsmuster, um das Design dieses Spiels zu implementieren.

Zustandsschnittstelle

public interface State {
    /**
     * 移动
     */
    void move();
    /**
     * 攻击
     */
    void attack();
}

Spezifischer Zustand

public class IdleState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("静止状态下不能移动...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("静止状态下不能攻击...");
    }
}
public class MoveState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("移动中...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("移动状态下不能攻击...");
    }
}
public class AttackState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("攻击状态下不能移动...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("攻击中...");
    }
}

Kontext

public class Context {
    private State state;
    public Context() {
        // 默认静止状态
        this.state = new IdleState();
    }
    public void setState(State state) {
        this.state = state;
    }
    /**
     * 移动
     */
    public void move() {
        state.move();
    }
    /**
     * 攻击
     */
    public void attack() {
        state.attack();
    }
}

Test

public class Demo {
    public static void main(String[] args) {
        // 静止状态
        Context context = new Context();
        context.move();
        context.attack();
        // 移动状态
        context.setState(new MoveState());
        context.move();
        context.attack();
        // 攻击状态
        context.setState(new AttackState());
        context.move();
        context.attack();
    }
}

Im obigen Beispiel definieren wir zuerst eine Zustandsschnittstelle und dann definieren wir Drei spezifische Zustandsklassen, IdleState, MoveState und AttackState, die den Ruhezustand, den Bewegungszustand und den Angriffszustand des Protagonisten darstellen. Als nächstes definieren wir eine Kontextschnittstelle, die ein Zustandsobjekt zur Darstellung des aktuellen Zustands enthält . In der Context-Klasse definieren wir eine setState-Methode, um den Status zu ändern, und die Verschiebungs- und Angriffsmethoden, um entsprechende Vorgänge auszuführen eine neue Zustandsklasse.

Das Zustandsmuster macht den Zustand des Objekts durch die Kapselung der Zustandsübergangslogik in der Zustandsklasse spezifischer und klarer.

• Das Zustandsmuster vereinfacht den Zustandswechsel Die Zustandsübergangsmethode des Objekts.

• Nachteile

• Das Zustandsmuster führt zu einer Erhöhung der Anzahl der Klassen im System, was die Komplexität des Codes erhöhen kann Der Prozess des Zustandswechsels wird kompliziert.

Anwendungsszenarien

• Wenn das Verhalten eines Objekts von seinem Zustand abhängt und der Zustand zur Laufzeit geändert werden kann. Das Zustandsmuster ist eine gute Wahl, wenn Änderungen auftreten

• Das Statusmuster ist nützlich, wenn ein Objekt basierend auf seinem Status unterschiedliche Vorgänge ausführen muss.

Wenn neue Verhaltensweisen dynamisch zum Objekt hinzugefügt werden müssen, ist der Statusmodus eine gute Wahl Einige gängige Anwendungsszenarien sind: Bestellstatus; Benutzer-Login-Status; Spielstatus usw.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das Java-Statusentwurfsmuster, um den Objektstatusübergang zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!