Design pattern Strategy expliqué par Dexter

Le jour, je fais de la programmation. Le soir (ces temps-ci), je me tappe un marathon de visionnement de la série Dexter en DVD. Dans mes temps libres, j'essaie de faire le pont entre les deux. Alors voyons voir comment le design pattern Strategy peut être implémenté si on est un tueur en série.

Définir une famille d'algorithmes, les encapsuler individuellement et de les rendre interchangeables. Strategy permet à l'algorithme de varier indépendamment des clients qui l'utilisent.

Le choix me semble tout à fait approprié, n'est-ce pas ?

D'abord, il doit faire les choses proprement en respectant le code de son père Harry. C'est pourquoi on définira une interface que toutes les stratégies devront suivre.

interface KillInterface{
    public function kill($person);
}

Ensuite, parce que le protagoniste a plus d'un tour dans son sac, il a paufiné plusieurs stratégies pour arriver à ses fins.

class StabThroughHeart implements KillInterface{
    public function kill($person){
        echo $person->getName() . ' has been killed by a stab through heart';
    }
}

class SliceThroat implements KillInterface{
    public function kill($person){
        echo $person->getName() . ' has been killed by a sliced throat';
    }
}

class Strangulation implements KillInterface{
    public function kill($person){
        echo $person->getName() . ' has been killed by strangulation';
    }
}

Dexter laisse un peu de place à l'improvisation lorsque vient le temps d'agir. Mais il sait qu'il devra réfléchir vite et choisir une stratégie selon le contexte.

class KillStrategy{
    private $strategy = null;

    public function __construct($type){
        switch($type){
            case 'stabThroughHeart' :
                $this->strategy = new StabThroughHeart();
                break;
            case 'sliceThroat' :
                $this->strategy = new SliceThroat();
                break;
            case 'strangulation' :
                $this->strategy = new Strangulation();
                break;
        }
    }

    public function kill($person){
        return $this->strategy->kill($person);
    }
}

J'allais oublier les victimes! Ici, on n'a pas besoin d'en savoir plus que leur nom.

class Victim{
    private $_name;

    public function __construct($name){
        $this->_name = $name;
    }

    public function getName(){
        return $this->_name;
    }
}

Enfin, le justicier passe à l'action en sélectionnant minutieusement des méchants antagonistes.

$strategy = new KillStrategy('sliceThroat');
$strategy->kill( new Victim('Ice Truck Killer') );

$strategy = new KillStrategy('stabThroughHeart');
$strategy->kill( new Victim('Lila West') );

$strategy = new KillStrategy('strangulation');
$strategy->kill( new Victim('Miguel Prado') );

C'est tout pour ce soir. J'ai encore deux saisons à regarder. Bonne soirée!

À lire aussi : design pattern Observer appliqué au hockey.