Può spiegare l'implementazione interna del pattern State e come gestisce lo stato dell'oggetto?

Il pattern State consente a un oggetto di modificare il proprio comportamento in base allo stato interno, cambiando la classe di stato durante l'esecuzione.

L'implementazione interna si basa generalmente sui seguenti principi:

• Esiste un contesto (Context) che contiene un riferimento all'oggetto di stato corrente (State).
• L'interfaccia State definisce un insieme di metodi che implementano diversi stati.
• Ogni stato concreto implementa questa interfaccia e definisce il comportamento per quello stato.
• Il contesto delega le chiamate ai metodi allo stato corrente.
• Quando necessario, lo stato può cambiare se stesso modificando il riferimento nel contesto a un altro oggetto di stato.

Esempio in 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("Stato A gestisce la richiesta")
        context.changeState(to: ConcreteStateB())
    }
}

class ConcreteStateB: State {
    func handle(context: Context) {
        print("Stato B gestisce la richiesta")
        context.changeState(to: ConcreteStateA())
    }
}

// Uso:
let context = Context(state: ConcreteStateA())
context.request() // Stato A gestisce la richiesta
context.request() // Stato B gestisce la richiesta

In questo modo, l'oggetto cambia comportamento dinamicamente, semplicemente alternando il suo stato interno.