AHRIMAN.FR

SCIENCE - NEO-EVHEMERISME - DONJONSDRAGONS

Design pattern : State

Ecris par :
Mis en ligne le :
Lu :
130 fois
Twitter Facebook Google Plus Linkedin email

La technique du patron de conception (design pattern en anglais), ou encore modèle de conception, comportemental "État" utilisé en génie logiciel est utilisé entre autres lorsqu'il est souhaité pouvoir changer le comportement d'un objet sans pour autant en changer l'instance. Ce type de comportement généralise les automates à états qui sont souvent utilisés comme intelligences artificielles simples.

Principe Général

Le patron "État" propose deux classes principales :

1. la classe État, qui définit l'abstraction des comportements du patron

2. la classe Contexte, qui s'occupe de l'interfaçage du patron avec le reste de son contexte (l'application).

La classe État permet via ses spécialisations de créer et gérer dynamiquement les comportements dont l'application aura besoin. La classe Contexte qui permet éventuellement à l'application de choisir le comportement à mettre en œuvre et surtout d'orchestrer l'exécution des comportements. Il est à noter que la classe Contexte n'a pas l'exclusivité du choix de comportements. Il est en effet possible d'automatiser le changement d'état à la fin de l'exécution de l'état actif. Cela permet le développement d'automates à états à développement rapide (la spécialisation permettant de récupérer le comportement d'un état parent en lui ajoutant le service qui lui manquait). À grande échelle un automate à état peut résoudre des problèmes très complexes ce qui les hisse au rang d'intelligences artificielles simples, notamment très utilisés dans les jeux vidéo (stratégie, cartes, plateaux, ...) et sont un bon compromis entre la formule mathématique et les réseaux de neurones pour bon nombre d'applications industrielles.

La classe Contexte garde un lien vers une classe abstraite État. Chaque comportement est une spécialisation de cet État. Lorsque l'instance de la classe État change, le comportement du patron change. Ce patron permet donc à la classe Contexte de changer de comportement dynamiquement sans changer ni d'instance ni d'interface.

Exemple en Java

L'interface State et deux implémentations. La méthode State a une référence vers l'objet contexte et est capable de changer sont état.



interface Statelike {

void writeName(StateContext context, String name);

}

class StateLowerCase implements Statelike {

@Override
public void writeName(final StateContext context, final String name) {
System.out.println(name.toLowerCase());
context.setState(new StateMultipleUpperCase());
}

}

class StateMultipleUpperCase implements Statelike {
/** Counter local to this state */
private int count = 0;

@Override
public void writeName(final StateContext context, final String name) {
System.out.println(name.toUpperCase());
/* Change state after StateMultipleUpperCase's writeName() gets invoked twice */
if(++count > 1) {
context.setState(new StateLowerCase());
}
}

}

Le contexte a une variable état qui instancie un état initial. Il utilisera la méthode correspondante à l'état.



class StateContext {
private Statelike myState;
StateContext() {
setState(new StateLowerCase());
}

/**
* Setter method for the state.
* Normally only called by classes implementing the State interface.
* @param newState the new state of this context
*/

void setState(final Statelike newState) {
myState = newState;
}

public void writeName(final String name) {
myState.writeName(this, name);
}
}

Images

Bibliographie