Pouvez-vous expliquer l'implémentation interne du pattern State et comment il gère l'état de l'objet?

Le patron State permet à un objet de changer son comportement en fonction de son état interne, en modifiant la classe d’état pendant l’exécution.

L’implémentation interne est généralement basée sur les principes suivants :

• Il existe un contexte (Context) qui contient une référence à l’objet d’état actuel (State).
• L’interface State définit un ensemble de méthodes qui implémentent différents états.
• Chaque état concret implémente cette interface et définit le comportement pour cet état.
• Le contexte délègue les appels de méthodes à l’état actuel.
• Lorsqu’il est nécessaire, l’état peut se changer lui-même en modifiant la référence dans le contexte vers un autre objet d’état.

Exemple en Swift (iOS) :

protocol State {
    func handle(context: Context)
}

class Context {
    private var state: State

    init(state: State) {
        self.state = state
    }

    func request() {
        state.handle(context: self)
    }

    func changeState(to newState: State) {
        self.state = newState
    }
}

class ConcreteStateA: State {
    func handle(context: Context) {
        print("État A gère la requête")
        context.changeState(to: ConcreteStateB())
    }
}

class ConcreteStateB: State {
    func handle(context: Context) {
        print("État B gère la requête")
        context.changeState(to: ConcreteStateA())
    }
}

// Utilisation :
let context = Context(state: ConcreteStateA())
context.request() // État A gère la requête
context.request() // État B gère la requête

Ainsi, l’objet change de comportement dynamiquement, en basculant simplement entre ses états internes.