Objekt des Staates in der Template-Methode Entwurfsmuster

Question

Hier ist ein Implementierungsbeispiel des algorigthm in der Basis absctract Klasse von http://sourcemaking.com/design_patterns/template_method/php

public final function showBookTitleInfo($book_in) { 
    $title = $book_in->getTitle(); 
    $author = $book_in->getAuthor(); 
    $processedTitle = $this->processTitle($title); 
    $processedAuthor = $this->processAuthor($author); 
    if (NULL == $processedAuthor) { 
     $processed_info = $processedTitle; 
    } else { 
     $processed_info = $processedTitle.' by '.$processedAuthor; 
    } 
    return $processed_info; 
} 

ich es nicht mögen becase Ich denke, dass „showBookTitleInfo“ zu viel weiß über die Methoden, die es anruft.

Hier ist ein weiteres Beispiel abstrakte Klasse template_method { var $ state; öffentliche Funktion __construct() { $ this-> state = 0; }

public function processEvent($event) { 
     $this->doFirstStep($event); 
     $this->doSecondStep($event); 
    } 
    abstract public function doFirstStep(&$event); 
    abstract public function doSecondStep(&$event); 
} 

class CustomLogic extends template_method { 
    public function doFirstStep(&$event) { 
     echo __METHOD__.": state: ".$this->state." event: $event\n"; 
     $this->state++; 
    } 
    public function doSecondStep(&$event) { 
     echo __METHOD__.": state: ".$this->state." event: $event\n"; 
     $this->state++; 
    } 
} 

warum geben wir Ereignis wie Verweis, wenn wir nicht seinen Wert ändern? Wie sollte ich die Logik "meine Schritte" implementieren, wenn sie den aktuellen Status verwenden, ihren Wert ändern können und andere Schritte den geänderten Wert lesen können und ihn auch ändern können?

Zum Beispiel möchte ich Kostenzählmechanismus für geplante Nachricht senden implementieren - einfach und recomcernt (zB: jeden Montag, Freitag bis 23.05.2009).

Also, ich den Algorithmus in der abstrakten Klasse implementieren, wie folgend:

abstract class AbstractCostCounter { 
    public function countNotReccurentSendingCost($messageObj) { 
     $totalMessages = $messageObj->getTotalMessages(); // multiple recipients are allowed 
     $message_cost = 1; // just to give you an idea 
     $this->cost = $totalMessages * $message_cost; 
    } 
    abstract public function countOptional(); 

    // I pass $messageObject not as by-reference, because it hasn't to be modified 
    public function countCost($messageObject) { 
     $this->countNotReccurentSendingCost($messageObject); 
     $this->countOptional($messageObject); 
    } 

} 

class TemplateNotReccurentCostCounting { 
    public function countOptional($messageObj) { 
     // do nothing 
    } 
} 

class TemplateReccurentCostCounting { 
    public function countOptional($messageObj) { 
     $notReccurentSendingCost = $this->cost; 
     $totalMessagesInScheduledPlan = $messageObj->getTotalMessagesInScheduledPlan(); 
     $reccurentSendingPlanCost = $notReccurentSendingCost * $totalMessagesInScheduledPlan; 
     $this->cost = $reccurentSendingPlanCost; 
    } 
} 

Bin ich in der richtigen Richtung? Soll das Entwurfsmuster für die Template-Methode implementiert werden? Bitte lassen Sie mich wissen, wenn mit diesem Code etwas nicht stimmt.

P.S. Kostenzähler ist kein Produktionscode. Ich habe es geschrieben, weil ich dir eine Idee geben wollte.

Vielen Dank im Voraus

Answer 1

Die Vorlage Methode Muster eine Menge Kontrolle der übergeordneten Klasse gibt, hat die übergeordnete Klasse eine Menge über die abstrakten Methoden (ihre Unterschrift) wissen, weil es um den Algorithmus zu ‚Kontrolle‘ hat . BTW die konkrete Methode in der Elternklasse muss endgültig sein.

Sie haben keinen Vorteil mit Firststep secondStep Methoden, konnte ich umsetzen, was ich in StepOne wollen und tun nichts in stepTwo ...

Die Frage ist, wann würden Sie Template-Methode Muster verwenden möchten, nicht, wie man schreiben Sie es um, um mehr Flexibilität zu geben :)