Wir bedienen uns des Plugin-Hooks the-content, da der Inhalt durchsucht werden muss, um dort die Wörter zu ersetzen. Da Sie später einen <span> mit einer Klasse wpstyled ausgeben, haben Sie auch die Möglichkeit, die Ausgabe grafisch über CSS zu steuern. Zunächst erstellen Sie eine Datei mit dem Namen wpErsetzen.php und legen diese in den Hauptordner von wp-content/plugins/. Da Sie in diesem Fall nur eine Datei benötigen, können Sie auf einen Unterordner für das Plugin verzichten. WordPress stellt im Backend beim Aktivieren der Plugins diverse Informationen über den Autoren, das Plugin selbst und die Version bereit. Diese Informationen bezieht WordPress
aus dem Header der Plugin-Datei. Unser Header könnte zum Beispiel so aussehen:

<?php
/*
Plugin Name: WP-Text ersetzen
Plugin URI: http://www.domain.tld
Description: Dieses Plugin ersetzt den Text "WP" durch <span
class='wpstyled'>WordPress</span>
Author: WordPress für Webdesigner
Version: 1.0
Author URI: http://www.domain.tld
*/

Danach folgt die eigentliche Programmierung des Plugins. Zunächst erstellen Sie eine Funktion mit dem Namen wpErsetzen und füllen sie mit nachfolgendem Code:

function wpErsetzen($content) {
$suche = 'WP';
$ersetze = '<span class="wpstyled">WordPress</span>';
$content = str_replace($suche,$ersetze,$content);
return $content;
}

Zur Erklärung: Sie geben der Variablen $suche den Wert WP, nach dem gesucht werden soll. Der Variablen ersetze weisen Sie den einzusetzenden Codeblock zu. Anschließend suchen und ersetzen Sie den Inhalt von $content mit der PHP-Funktion str_replace.$content. Der wird uns später vom Filter-Hook selbst übergeben und enthält den Blog-Beitrag. Als Letztes fehlt noch der sogenannte Filter-Hook, den Sie direkt unter die Funktion schreiben können:

add_filter("the_content","wpErsetzen");
?>

Der Filter wird immer dann ausgeführt, wenn die WordPress-Funktion the-content aufgerufen wird. Als Inhalt übergibt der Filter die Ausgabe von the-content, also den Inhalt des Blog-Beitrags oder einer statischen Seite, und nimmt den ersetzten Inhalt wieder auf, um ihn später auf der Seite auszugeben. Nun sind Sie auch schon fertig mit dem ersten Mini-Plugin und werden jetzt noch die Klasse .wpstyled, die Sie im ersetzten Text genutzt haben, in der CSS-Datei des Themes definieren:

.wpstyled {
background: #ffff66;
padding: 2px 3px;
}

Der Text WordPress wird nun auf allen Seiten mit einem gelben Hintergrund dargestellt. Noch sehen Sie im Frontend keine Änderungen. Sie müssen zunächst das Plugin aktivieren. Dazu gehen Sie genauso vor, wie mit einem heruntergeladenen externen Plugin. Auf der Plugin-Seite im Backend fi nden Sie jetzt das von uns neu hinzugefügte Plugin.

Wenn Sie nun auf Aktivieren klicken und das Frontend aktualisieren, sehen Sie die von Ihnen durchgeführte automatische Textersetzung mit einem WordPress, das einen gelben Hintergrund hat, da wir im Text WP geschrieben haben.

Dieser Text ist dem Buch “WordPress-Themes – Design und Implementierung für WordPress 3” von Jonas Hellwig und Christian Gatzen entnommen, das im August 2010 im Franzis Verlag erscheint. Sie können es hier direkt vorbestellen.

Die Konventionen für das Subject/Observer-Modell

Subject

• Definiert die Schnittstelle für das zu überwachende Objekt.
• Definiert die Schnittstelle für die Überwacherobjekte.

Observer

• Definiert die Schnittstelle für die Überwacherobjekte.

ConcreteSubject

• Enthält die konkrete Objekt-Implementierung des zu überwachenden Objekts.
• Enthält die konkrete Objekt-Implementierung für die Überwacherobjekte.

ConcreteObserver

Um ein Subject/Observer-Entwurfsmuster in PHP zu implementieren, führen Sie folgende Schritte durch:

1.  Definieren Sie eine Schnittstelle für die Observer, die eine Methode bereitstellt, mit der die Beobachter über eine Statusänderung informiert werden können.

2.  Definieren Sie eine Schnittstelle für die zu beobachtenden Objekte (Subjects). Diese Schnittstelle muss das Hinzufügen sowie das Entfernen von Observern erlauben und eine Methode notify() fordern, mit der die Observer über eine Statusänderung informiert werden.

3.  Implementieren Sie im zu beobachtenden Objekt die Subject-Schnittstelle.

4.  Fügen Sie in den Methoden, die den Zustand des Objekts ändern, den Aufruf der notify()-Methode ein.

5.  Implementieren Sie konkrete Objekte.

Wenn Sie diese Schritte befolgen, steht dem Einsatz von Subject/Observer-Entwurfs­mustern nichts im Wege.

Beispieldatei PersonalLift.php

<?php
 
require_once 'Fahrstuhl.php';
require_once 'Subject.php';
 
class PersonalLift implements Fahrstuhl, Subject 
{  
    protected $hersteller; 
    protected $model;   
    protected $meter;
 
    protected $generatorAktiv = false;
    protected $observers = array();
 
    public function __construct($hersteller, $model, $meter = 0) 
	 {
        $this->hersteller = $hersteller;
        $this->model = $model;
        $this->meter = $meter;       
    }
 
    public function __destruct() 
	 {
        if ($this->generatorAktiv) 
		{
        	$this->stopGenerator();
        }
    }
 
    public function startGenerator() 
	 {
        $this->generatorAktiv = true;
    }
 
 
    public function fahren($meter) 
	 {
 
        if ($this->generatorAktiv !== true) 
		{
        	return false;
        }
 
        $this->meter = $this->meter + $meter;
        $this->notify();
        return true;
    }
 
 
    public function stopGenerator() 
	 {
        $this->generatorAktiv = false;
    }
 
 
    public function getHersteller() 
	 {
        return $this->hersteller;
    }
 
 
    public function getModel() 
	 {
        return $this->model;
    }  
 
	 public function getMeter() 
	 {
        return $this->meter;
    }  
 
 
    public function attach(Observer $observer) 
	 {
        $this->observers[] = $observer;
    }
 
 
    public function detach(Observer $observer) 
	 {		
		for ($i = 0; $i < sizeof($this->observers); $i++) 
		{
		  if ($this->observers[$i] === $observer) 
		  {
			unset($this->observers[$i]);
		  }
		}		
    }
 
 
    public function notify() 
	 {
        foreach ($this->observers as $observer) 
		{
        	$observer->update($this);
        }
    }
}
?>

Beispieldatei Fahrstuhl.php

<?php
 
interface Fahrstuhl 
{
    public function startGenerator();
    public function fahren($meter);
    public function stopGenerator();
    public function getMeter();   
    public function getHersteller();
    public function getModel();    
}
 
?>

Beispieldatei Subject.php

<?php
 
interface Subject 
{
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify();
}
 
?>

Beispieldatei Observer.php

<?php
 
interface Observer 
{
    public function update(Subject $subject);
}
 
?>

Beispieldatei ErsteWartungObserver.php

<?php
 
require_once 'Observer.php';
 
class ErsteWartungObserver implements Observer 
{
 
    private $wartungMeter;
 
    public function __construct($meter = 10000) 
	 {
        $this->wartungMeter = $meter;
    }
 
    public function update(Subject $lift) 
	 {
        if (!$lift instanceof Fahrstuhl) 
		{
            return;
        }
        if ($lift->getMeter() >= $this->wartungMeter) 
		{
            echo "Die erste Wartung ist fällig, da " . $this->wartungMeter . " Meter überschritten wurden.\n";			
            $lift->detach($this);
        }
    }
}
 
?>

Beispieldatei StandardWartungObserver.php

<?php
 
require_once 'Observer.php';
 
class StandardWartungObserver implements Observer 
{
    private $interval;
	 private $naechsteWartung = null;
 
    public function __construct($startWert, $interval) 
	 {
        $this->naechsteWartung = $startWert;
        $this->interval = $interval;
    }
 
    public function update(Subject $lift) 
	 {
        if (!$lift instanceof Fahrstuhl) 
		{
            return;
        }
        if ($lift->getMeter() >= $this->naechsteWartung) 
		{
            echo "Die Standardwartung ist fällig (" . $this->naechsteWartung . " Meter).\n";
            $this->naechsteWartung = $this->naechsteWartung + $this->interval;
        }
    }
}
 
?>

Beispieldatei – Anwendung

<?php
 
require_once 'PersonalLift.php';
require_once 'ErsteWartungObserver.php';
 
$pLift = new PersonalLift('OTIS', 'High-8-Personenlift');
$ersteWartung = new ErsteWartungObserver(10000);
 
$pLift->attach($ersteWartung);
 
$pLift->startGenerator();
 
$pLift->fahren(3500);
printf("Gefahren: %d Meter\n", $pLift->getMeter());
$pLift->fahren(8000);
printf("Gefahren: %d Meter\n", $pLift->getMeter());
 
$pLift->stopGenerator();
 
$pLift->startGenerator();
 
$pLift->fahren(10000);
printf("Gefahren: %d Meter\n", $pLift->getMeter());
 
$pLift->stopGenerator();
 
?>

Ausgabe

Gefahren: 3500 Meter
Die erste Wartung ist fällig, da 10000 Meter überschritten wurden.
Gefahren: 11500 Meter
Gefahren: 21500 Meter

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Um ein Composite-Entwurfsmuster in PHP zu implementieren, führen Sie folgende Schritte durch:

1.  Definieren Sie eine Schnittstelle für ein einzelnes Objekt des Baums, falls sie nicht bereits zuvor definiert wurde.

2.  Implementieren Sie eine neue Klasse, die diese Schnittstelle erfüllt. Fügen Sie dieser Klasse eine weitere Methode hinzu, an die Sie beliebige Objekte übergeben können, die die Schnittstelle erfüllen. Speichen Sie die übergebenen Objekte als Array in einer Objekteigenschaft.

3.  Implementieren Sie sämtliche von der Schnittstelle geforderten Methoden so, dass diese über die Kindobjekte iterieren und den Methodenaufruf der Reihe nach an jedes der Kinder weiterdelegieren.

4.  Erzeugen Sie beliebige Objekte, um diese zu einem Baum zusammenzufügen.

5.  Verwenden Sie in Ihrer Anwendung nun diesen Objektbaum anstelle eines einzel­nen Objekts.

Wenn Sie diese Schritte befolgen, steht dem Einsatz von Composite-Entwurfsmustern nichts im Wege.

Mithilfe des folgenden Anwendungsbeispiels können Sie mehrere Filme in einer Filmliste verwalten. Die Klasse EinFilm stellt jeweils ein konkretes Objekt dar. Die Klasse Diver­seFilme ist eine Gruppe von EinFilm-Objekten.

Beide Klassen können Filminformationen über den Filmtitel und Filmregie ausgeben. EinFilm enthält lediglich Informationen über einen Film, DiverseFilme enthält Infor­ma­tionen über die Filme in der Filmliste.

Beide Klassen verfügen über die Methoden hinzufuegen() und entfernen(). Diese sind jedoch lediglich in der Klasse DiverseFilme einsetzbar. Die EinFilm-Klasse liefert FALSE, falls diese Methoden verwendet werden sollten.

Beispiel – FilmArchiv.php

<?php
 
abstract class FilmArchiv 
{
	abstract protected function getFilmInfo($vorherigerFilm);	
	abstract protected function getFilmAnzahl();
	abstract protected function setFilmAnzahl($neuer_zaehler);	
	abstract protected function hinzufuegen($einFilm);
	abstract protected function entfernen($einFilm);
}
 
?>

Beispiel – EinFilm.php

<?php
 
include_once('FilmArchiv.php'); 
 
class EinFilm extends FilmArchiv 
{
 
    private $titel;
    private $regie;
 
    public function __construct($titel, $regie) 
	 {
      $this->titel = $titel;
      $this->regie = $regie;
    }
 
    public function getFilmInfo($film_auswahl) 
	 {
      if (1 == $film_auswahl) 
	  {
        return $this->titel . " von " . $this->regie;
      } 
	  else 
	  {
        return FALSE;
      }
    }
 
    public function getFilmAnzahl() 
	 {
      return 1;
    }
 
    public function setFilmAnzahl($neuer_zaehler) 
	 {
      return FALSE;
    }
 
    public function hinzufuegen($einFilm) 
	 {
      return FALSE;
    }
 
    public function entfernen($einFilm) 
	 {
      return FALSE;
    }
 
}
 
?>

Beispiel – DiverseFilme.php

<?php
 
include_once('FilmArchiv.php'); 
 
class DiverseFilme extends FilmArchiv 
{
 
    private $filmListe = array();
    private $filmAnzahl;
 
    public function __construct() 
	 {
      $this->setFilmAnzahl(0);
    }
 
    public function getFilmAnzahl() 
	 {
      return $this->filmAnzahl;
    }
 
    public function setFilmAnzahl($neuer_zaehler) 
	 {
      $this->filmAnzahl = $neuer_zaehler;
    }
 
    public function getFilmInfo($film_auswahl) 
	 {	
      if ($film_auswahl <= $this->filmAnzahl) 
	  {
        return $this->filmListe[$film_auswahl]->getFilmInfo(1);
      } 
	  else 
	  {
        return FALSE;
      }
    }
 
    public function hinzufuegen($einFilm) 
	 {
      $this->setFilmAnzahl($this->getFilmAnzahl() + 1);
      $this->filmListe[$this->getFilmAnzahl()] = $einFilm;
      return $this->getFilmAnzahl();
    }
 
    public function entfernen($einFilm) 
	 {
      $counter = 0;
      while (++$counter <= $this->getFilmAnzahl()) 
	  {
        if ($einFilm->getFilmInfo(1) == 
          $this->filmListe[$counter]->getFilmInfo(1)) 
		  {
          for ($i = $counter; $i < $this->getFilmAnzahl(); $i++) 
		  {
            $this->filmListe[$i] = $this->filmListe[$i + 1];
          }
          $this->setFilmAnzahl($this->getFilmAnzahl() – 1);
        }
      }
      return $this->getFilmAnzahl();
    }
}
?>

Beispiel – Anwendung

<?php
 
include_once('FilmArchiv.php');  
include_once('EinFilm.php');
include_once('DiverseFilme.php');  
 
 
$ersterFilm = new EinFilm("King Kong", "James Cameron");
echo "Erster Film – Filminfo: ";
echo $ersterFilm->getFilmInfo(1);
echo "<br>";
 
 
$zweiterFilm = new EinFilm("Star Wars", "George Lucas");
echo "Zweiter Film – Filminfo: ";
echo $zweiterFilm->getFilmInfo(1);
echo "<br>";
 
 
$dritteFilm = new EinFilm("Indiana Jones", "Steven Spielberg");
echo "Dritter Film – Filminfo: ";
echo $dritteFilm->getFilmInfo(1);
echo "<br>";
 
 
echo "<p>***Filmliste***</p>";
 
 
$filme = new DiverseFilme();
 
 
$filmeCount = $filme->hinzufuegen($ersterFilm);
echo "Erster Film in der Filmliste – Filminfo: <br>";
echo $filme->getFilmInfo($filmeCount);
echo "<br><br>";
 
 
$filmeCount = $filme->hinzufuegen($zweiterFilm);
echo "Zweiter Film in der Filmliste – Filminfo: <br>";
echo $filme->getFilmInfo($filmeCount);
echo "<br><br>";
 
 
$filmeCount = $filme->hinzufuegen($dritteFilm);
echo "Dritter Film in der Filmliste – Filminfo: <br>";
echo $filme->getFilmInfo($filmeCount);
echo "<br><br>";
 
 
$filmeCount = $filme->entfernen($ersterFilm);
echo "Ersten Film aus Filmliste entfernen – Filme Anzahl: <br>";
echo $filme->getFilmAnzahl();
echo "<br><br>";
 
 
echo "Übrige Filme aus der Filmliste – Filminfo zu 1: <br>";
echo $filme->getFilmInfo(1);
echo "<br><br>";
 
 
echo "Übrige Filme aus der Filmliste – Filminfo zu 2: <br>";
echo $filme->getFilmInfo(2);
echo "<br><br>";
 
?>

Ausgabe

Erster Film – Filminfo: King Kong von James Cameron
Zweiter Film – Filminfo: Star Wars von George Lucas
Dritter Film – Filminfo: Indiana Jones von Steven Spielberg
***Filmliste***
Erster Film in der Filmliste – Filminfo:
King Kong von James Cameron
Zweiter Film in der Filmliste – Filminfo:
Star Wars von George Lucas
Dritter Film in der Filmliste – Filminfo:
Indiana Jones von Steven Spielberg
Ersten Film aus Filmliste entfernen – Filme Anzahl:
2
Übrige Filme aus der Filmliste – Filminfo zu 1:
Star Wars von George Lucas
Übrige Filme aus der Filmliste – Filminfo zu 2:
Indiana Jones von Steven Spielberg

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Konventionen der Factory-Methode:

Um ein Factory-Methoden-Entwurfsmuster in PHP zu implementieren, führen Sie folgende Schritte durch:

1.  Implementieren Sie eine abstrakte Klasse, in der Sie eine oder mehrere abstrakte Methoden deklarieren, die die Schnittstelle zum Erzeugen von Objekten vorgeben.

2.  Fügen Sie dieser Klasse weitere Methoden hinzu, deren Logik bei allen konkreten Implementierungen identisch ist. Sie können in diesen Methoden bereits auf die abstrakte Fabrikmethode zugreifen.

3.  Bilden Sie beliebig viele Unterklassen, in denen Sie verschiedene Implementierungen der abstrakten Methode einfügen.

4.  Verwenden Sie nun diese konkreten Unterklassen, um die tatsächlichen Objekte zu instanzieren und Ihren Applikationscode von den konkreten Implementierungen zu lösen.

Wenn Sie diese Schritte befolgen, steht dem Einsatz von Factory-Methoden-Entwurfs­mustern nichts im Wege.

Mithilfe des folgenden Anwendungsbeispiels können Sie einen »virtuellen« Verlag erzeugen. Dieser ist in der Lage, beliebig viele Bücher zu produzieren.

Beispiel – Buch-Klasse (buch.php)

<?php
 
require_once 'Produkte.php';
 
class Buch implements Produkte {
 
	protected $verlag;
	protected $titel;   
	protected $preis;	
	protected $verkauft = false;
	protected $verpackt = false;
 
	public function __construct($verlag, $titel, $preis = 0) 
	{
		$this->verlag = $verlag;
		$this->titel = $titel;
		$this->preis = $preis;
    }
 
   public function berechneMwst($steuersatz) 
	{
		if ($this->preis < 0) 
		{
			return false;
		}			
		$this->preis = $this->preis + round(($this->preis * $steuersatz),2);
		return true;
	}
 
	public function verpacken() 
	{
		$this->verpackt = true;
		return $this->verpackt;
	}
 
	public function getVerlag() 
	{
		return $this->verlag;
	}
 
	public function getTitel() 
	{
		return $this->titel;
	}
 
	public function getPreis()
	{
		return $this->preis;
	}
 
	public function getVerpackt() 
	{
		return $this->verpackt;
	}
}
 
?>

Beispiel – Produkte-Interface (Produkte.php)

<?php
 
interface Produkte 
{
	public function berechneMwst($steuersatz);   
	public function verpacken();	 
	public function getVerlag();
	public function getTitel();
	public function getPreis();
	public function getVerpackt();
}
 
?>

Beispiel – AbstractHersteller.php

<?php
 
abstract class AbstractHersteller 
{
 
    protected $name;
 
    public function __construct($name) 
	 {
        $this->name = $name;
    }
 
    public function verkaufeBuch($titel, $preis, $steuersatz) 
	 {
        $produkt = $this->produziereBuch($titel, $preis);
        $produkt->verpacken();		
        $produkt->berechneMwst($steuersatz);		
        return $produkt;
    }
 
    abstract protected function produziereBuch($titel, $preis);
}
 
?>

Beispiel – BuchHersteller.php

<?php
 
require_once 'AbstractHersteller.php';
require_once 'Buch.php';
 
class BuchHersteller extends AbstractHersteller 
{
 
    protected function produziereBuch($titel, $preis) 
	 {
        $produkt = new Buch($this->name, $titel, $preis);
        return $produkt;
    }
}
 
?>

Beispiel – Anwendung

<?php
 
require_once 'BuchHersteller.php';
 
$hersteller = new BuchHersteller('Franzis');
 
$flash8Buch = $hersteller->verkaufeBuch('Flash 8', 45.00, 0.07);
 
echo "***Buch gekauft***<br>\n\n";
echo "Produktart: " . get_class($flash8Buch) . "<br>\n";
echo "Verlag: " . $flash8Buch->getVerlag() . "<br>\n";
echo "Titel: " . $flash8Buch->getTitel() . "<br>\n";
echo "Preis: " . $flash8Buch->getPreis() . " (inkl 7% MwSt.)<br>\n";
 
if ($flash8Buch->getVerpackt())
{
	echo "Verpackungszustand: Verpackt!<br>\n";
}
else
{
	echo "Verpackungszustand: nicht Verpackt!<br>\n";
}
 
?>

Ausgabe:

***Buch gekauft***
Produktart: Buch
Verlag : Franzis
Titel : Flash 8
Preis : 48.15 (inkl 7% MwSt.)
Verpackungszustand : Verpackt!

Sie können ohne weiteres noch einen Hersteller hinzufügen. Sie müssen hierfür lediglich noch eine Klasse von Abstract­Hersteller ableiten.

Weitere Hersteller können somit ohne Weiteres implemen­tiert und der Anwendung hinzugefügt werden. Sie haben ganz einfach das Erzeugen der Buch-Objekte aus dem Code entfernt und stattdessen hinter einer Schnittstelle gekapselt. Dabei verwenden Sie lediglich die Schnittstelle der Klasse AbstractHerstel­ler. Sie müssen nicht wissen, welche Klassen dabei instanziert werden und welcher Code dazu notwendig ist.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

]]> http://webdeveloper.franzis.de/php-5x/das-factory-entwurfsmuster-in-php/feed/ 1 http://webdeveloper.franzis.de/php-5x/singleton-muster-in-php/ http://webdeveloper.franzis.de/php-5x/singleton-muster-in-php/#comments Wed, 27 Jan 2010 16:00:05 +0000 Matthias Kannengiesser http://webdeveloper.franzis.de/?p=1457 Das Singleton-Entwurfsmuster ist ein in der Softwareentwicklung eingesetztes Muster und gehört zur Gruppe der Erzeugungsmuster. Es stellt sicher, dass zu einer Klasse lediglich genau ein Objekt erzeugt werden kann, und ermöglicht einen globalen Zugriff auf dieses Objekt. In der Praxis wird diese Technik verwendet, um ressourcenschonend zu programmie­ren. Verbindungen zu Ressourcen, die lediglich einmalig vorhanden sind, wie beispiels­weise Dateien, werden über Singleton-Klassen verwaltet.

Weitere Anwendungsbeispiele für Singleton-Muster sind:

• Ein zentrales Protokollobjekt, das Ausgaben in eine Datei schreibt.
• Datenbankzugriffe, die mit einer Datenbank verbunden werden sollen und lediglich auf ein Verbindungsobjekt zurückgreifen.

Die folgende Singleton-Klasse soll Ihnen den Einstieg in die Welt der Entwurfsmuster erleichtern.

Beispiel für ein Singleton-Entwurfsmuster in PHP:

<?php
 
class Singleton 
{
 
   static private $instance = false;
   private $text = 'Kein Meldung im Objekt';
 
   private function __construct() {}
   private function __clone() {}
 
   public static function getInstance()
   {
       if(!Singleton::$instance)
       {
           Singleton::$instance = new Singleton();
       }
       return Singleton::$instance;
   }
 
   public function setText($text)
   {
       $this->text = $text;
   }
 
   public function getText()
   {
       return $this->text;
   }
}
 
?>

Beispiel für eine Singleton-Anwendung in PHP:

<?php
 
class Einchecken
{
   public function __construct()
   {
       $single = Singleton::getInstance();
       $single->setText('Sie sind herzlich Willkommen!');
   }
}
 
class Auschecken 
{
   public function __construct() 
   {
       $single = Singleton::getInstance();
       $single->setText('Auf wiedersehen!');
   }
}
 
$single = Singleton::getInstance();
echo $single->getText() . "<br />";
 
$passagier = new Einchecken();
echo $single->getText() . "<br />";
 
$passagier = new Auschecken();
echo $single->getText() . "<br />";
 
?>

Ausgabe:

Keine Meldung im Objekt
Sie sind herzlich Willkommen!
Auf Wiedersehen!

Das Beispiel nutzt in jeder Klasse, die ein Singleton verwendet, immer wieder dasselbe Objekt, da eine erneute Erzeugung im Rahmen eines einfachen Methodenaufrufs völlig sinnlos wäre – man hätte am Ende lediglich eine Anzahl verwaister Objekte im Speicher.

Darüber hinaus wird durch die private-Deklaration für den Konstruktor (__construct) und die __clone()-Methode verhindert, dass doch noch mehr Objekte erzeugt werden.

Singleton-Konventionen:

Um ein Singleton in PHP zu implementieren, sind folgende Schritte durchzuführen:

1.  Deklarieren Sie eine statische Klasseneigenschaft, die das Exemplar der Klasse spei­chert.

2.  Implementieren Sie eine statische Methode, die das gespeicherte Exemplar zurück­gibt und gegebenenfalls dieses Exemplar erstellt, falls es noch nicht vorhanden ist.

3.  Stellen Sie sicher, dass keine weiteren Instanzen durch Verwendung des new-Operators möglich sind, indem Sie den Konstruktor als private oder protected deklarieren.

4.  Stellen Sie sicher, dass das Exemplar der Klasse nicht geklont werden kann, indem Sie die __clone()-Methode als private deklarieren.

Wenn Sie diese Schritte befolgen, steht dem Einsatz von Singleton-Entwurfsmustern nichts im Wege.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Pattern: Chain of Responsibility (Zuständigkeitskette)

Ziel: Vermeidet die Koppelung des Auslösers einer Anfrage an seinen Empfän­ger, indem mehr als ein Ob­jekt die Möglichkeit erhält, die Anfrage zu erledigen.

Auswirkungen: Das Pattern verkettet die empfangenen Objekte und leitet die Anfrage von Objekt zu Objekt, bis ein Objekt sie erledigt. Jeder Teilnehmer der Kette kennt lediglich seinen Nachfolger. Die Kettenstruktur ist dynamisch aufbau­bar und änderbar. Es gibt keine Empfangsgarantie, Anfragen daher auch können unbehandelt bleiben.

Pattern: Command (Befehl)

Ziel: Kapselt einen Auftrag als Objekt.

Auswirkungen: Das Objekt, das eine Anfrage schickt, muss nicht wissen, wie diese abgear­beitet wird. Anfragen können in eine Warteschlange ge­stellt oder rückgängig gemacht wer­den. Anfragen können parametrisiert oder erweitert werden.

Pattern: Interpreter (Dolmetscher)

Ziel: Erstellt für eine gegebene Sprache eine Grammatik und interpretiert die Sätze in der Sprache.

Auswirkungen: Bestehende Grammatiken sind ein­fach zu ändern und zu erweitern. Die Regeln der Grammatik werden durch Klassen repräsentiert. Durch Anpassen der zugehörigen Klasse kann eine Regeländerung über­nommen werden. Zusätzliche Operationen sind leicht hinzuzufügen.

Pattern: Iterator

Ziel: Ermöglicht sequenziellen Zugriff auf die Elemente eines Objekts, ohne dessen Struktur zu offenbaren.

Auswirkungen: Das Pattern vereinfacht die Schnittstelle des Aggregats. Ermöglicht die parallele Iteration des Aggregats. Ermöglicht unterschiedliche Arten der Iteration über dasselbe Aggregat.

Pattern: Mediator (Vermittler)

Ziel: Definiert ein Objekt, welches das Zusammenspiel einer Menge von Objekten in sich kapselt.

Auswirkungen: Vermittler fördern lose Koppelung, indem sie verhindern, dass Objekte aufeinander explizit Bezug neh­men. Sie ermöglichen ihnen, das Zusam­menspiel der Objekte voneinander unabhängig zu variieren.

Pattern: Memento

Ziel: Erfasst und externalisiert den internen Zustand eines Objekts, ohne seine Kapse­lung zu verletzen, sodass das Objekt später in diesen Zu­stand zurückversetzt werden kann.

Auswirkungen: Externe Speicherung von Zuständen, ohne interne Details zu verraten. Performance-intensive Zustands­wechsel.

Pattern: Subject/Observer (Beobachter)

Ziel: Definiert 1:n-Abhängigkeit zwischen Subjekt und Beobachterobjekten

Auswirkungen: Das Subjekt kann ohne Beobachter ein­gesetzt werden. Lose Koppelung zwischen Subjekt und Beobachtern. Einfache Operationen können kaskadierende Aktionen in den Beobachtern auslösen.

Pattern: State (Zustand)

Ziel: Ermöglicht es einem Objekt, sein Verhalten zu ändern, wenn sein interner Zustand sich ändert.

Auswirkungen: Zustandsabhängiges wird Verhalten in eine eigene Klassenhierarchie ausgelagert. Zustandsänderungen werden expli­zit durchgeführt. Relativ leichte Erweiterbarkeit.

Pattern: Strategy (Strategie)

Ziel: Definiert eine Familie von Algorithmen, kapselt jeden einzelnen und macht sie austauschbar.

Auswirkungen: Polymorphismus statt Fallunter­scheidung (if-, elseif etc.). Auswahl verschiedener Implemen­tationen desselben Verhaltens. Relativ leichte Erweiterbarkeit.

Pattern: Template-Methode (Schablonenmethode)

Ziel: Definiert die Schritte eines Algorithmus und überlässt die Implementierung der Schritte den Unterklassen.

Auswirkungen: Erhöht die Wiederverwendbarkeit von Code. Herausfaktorieren gemeinsamen Verhaltens.

Pattern: Visitor (Besucher)

Ziel: Fügt neue Operationen einer Objektstruktur hinzu und kapselt diese in einer Klasse.

Auswirkungen: Verhindert, dass zusammengehörige Operationen über mehrere Klassen verteilt sind. Ermöglicht Zugriff auf Daten, die ansonsten verborgen bleiben. Erschwert das Hinzufügen neuer Elemente zur Datenstruktur.

Was Entwurfsmuster nicht sind:

Für eine Vielzahl von Entwicklern sind Entwurfsmuster aus der Anwendungsentwicklung nicht mehr wegzudenken. Sollten auch Sie sich näher mit Entwurfsmustern auseinan­dersetzen wollen, dann gilt es Folgendes zu beachten, um Missverständnisse von vorn­herein zu vermeiden:

• Entwurfsmuster sind keine Algorithmen – Algorithmen lösen Probleme (Suchen, Sortie­ren, etc.) und bieten weniger Flexibilität in der Implementierung.
• Entwurfsmuster sind kein Allheilmittel – Erfindungsreichtum ist bei der Anwendung von Entwurfsmustern immer noch gefragt.
• Entwurfsmuster sind keine Frameworks – Frameworks setzen sich als wiederver­wendba­rer Code zusammen, Entwurfsmuster enthalten lediglich Beispiele von Code. Frameworks werden für festgelegte Anwendungsbereiche eingesetzt, Ent­wurfsmuster hingegen können überall eingesetzt werden.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Pattern: Adapter

Ziel: Passt eine Schnittstelle an die vom Client erwartete Schnitt­stelle an. Objekte können an­dere Objekte nutzen, indem man ein Adapter-Objekt da­zwischenschaltet.

Auswirkungen: Ursprünglich nicht kompatible Klassen werden kompatibel. Die Zielklasse kann trotz unterschiedli­cher Nutzung unverändert bleiben. Schnittstellen werden entkoppelt. Die Wiederverwendbarkeit ist erhöht. Die Spezialisierung der adaptierten Klassen ist schwerer. Die Verwendung des Musters kann zu recht unterschiedlichem Aufwand führen.

Pattern: Bridge (Brücke)

Ziel: Entkoppelt eine Abstraktion von ihrer Implementierung, sodass beide unabhängig voneinander variiert werden können. Bildet eine Brücke zwischen zwei Klassenhierarchien.

Auswirkungen: Die Implementierung kann dynamisch ausgetauscht werden. Trennung von Interface- und Implementierungshierarchien.

Pattern: Composite (Kompositum)

Ziel: Fügt mehrere Objekte zu einer Baumstruktur zusammen, um Kompositionen von Objekten einheitlich zu behandeln.

Auswirkungen: Neue Komponenten können leicht eingefügt werden. Der Entwurf wird sehr schnell allgemein.

Pattern: Decorator (Dekorateur)

Ziel: Erweitert Objekte zur Laufzeit um neue Funktionalitäten.

Auswirkungen: Die Klassen werden schlanker. Das Muster schafft größere Flexibilität als der Einsatz von Vererbung. Die Anzahl der Klassen in einer Anwen­dung wird erhöht.

Pattern: Facade (Fassade)

Ziel: Bietet eine abstrakte Schnitt­stelle, die die Verwendung eines Subsystems vereinfacht.

Auswirkungen: Reduziert die Anzahl der Klassen, die vom Client verwendet werden müssen. Fördert lose Koppelung zwischen den Subsystemen und den Klassen, die diese nutzen.

Pattern: Flyweight (Fliegengewicht)

Ziel: Nutzt Gemeinsamkeiten von Objekten und lagert diese in zusätzliche Objekte aus, um eine große Anzahl von Objekten effi­zient verwenden zu können.

Auswirkungen: Führt zur Redundanzreduzierung in der Datenhaltung. Führt zu kompakten und speicher­sparenden Objekten.

Pattern: Proxy (Stellvertreter)

Ziel: Kontrolliert den Zugriff auf ein Objekt mithilfe eines Stellver­treters. Zugriff auf ein Objekt auf einem anderen Server (Remote-Proxy). Erzeugen des Objekts beim ers­ten Zugriff (virtueller Proxy). Durchführen von Verwaltungs­aufgaben (Schutz-Proxy).

Auswirkung: Führt Indirektion beim Zugriff auf Objekte ein.

Tipp: Sobald Sie mit den Entwurfsmustern dieser Gruppe vertraut sind, stehen Ihnen bereits die wich­tigsten Werkzeuge zur Verfügung, um durch Komposition eine flexible Architektur von unterschiedlichen Objekten zu erschaffen.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Wenn der Einsatz von Entwurfsmustern dokumentiert wird, ergibt sich ein weiterer Vorteil: Durch Dokumentation des Musters wird ein Bezug her­gestellt zur dort vor­han­denen Diskussion des Problemkontexts und der Vor- und Nachteile der Lösung.

Moderne Hochsprachen wie Java, aber durchaus auch PHP, unterstützen einige der gängigen Entwurfsmuster bereits mit bestimmten Sprachmitteln, sodass man sich in der Praxis vor allem bei der Nutzung moderner Sprachen im Prozess der objektorientierten Analyse (OOA) und des objekt­orientierten Designs (OOD) der Entwurfsmuster bedient, die dort unter Umständen noch immer implementationsneutral in der unified modeling language (UML) ange­wendet werden.

Im Lauf der Zeit wurden Lösungen für bestimmte Probleme gefunden, die erfolgreich eingesetzt wurden und somit einen Katalog mit insgesamt 23 Entwurfsmustern bildeten. Laut der Gang of Four (GoF) lassen sich sämtliche Entwurfsmuster in drei grundlegenden Muster­gruppen zusammenfassen:

• Creational Patterns (Erzeugungsmuster) lösen die Probleme beim Erzeugen von Objekten.
• Structural Patterns (Strukturmuster) befassen sich mit der Komposition von ver­schiedenen Objekten, um eine größere Struktur zu entwickeln.
• Behavioral Patterns (Verhaltensmuster) regeln die Inter­aktion zwischen verschie­denen Objekten.

Zu den bekanntesten Entwurfsmustern gehören unter anderem der Iterator-Pattern und der Singleton-Pattern.

Hinweis: Muster sollen den Entwickler bei seiner Arbeit unterstützen. Die Aufgabe des Ent­wicklers besteht somit nicht mehr darin, das Rad neu zu erfinden, sondern das passende Rad zu verwenden.

Gültigkeitsbereich der Muster

Strukturen, denen ein klassenbasiertes Muster zu Grunde liegt, sind durch Klassenver­erbung entstanden und somit zur Übersetzungszeit festgelegt.

Analog hierzu nutzen objektbasierte Muster die Objektkomposition. Die von ihnen ver­wendeten Strukturen entstehen zur Laufzeit und sind dynamisch. Dieser Unterschied ist stets zu beachten.

Gruppe der Erzeugungsmuster

Erzeugungsmuster werden verwendet, um Objekte zu konstruieren.

Pattern: Singleton.

Stellt sicher, dass von einer Klasse ausschließlich eine In­stanz existiert, und stellt einen globalen Zugriffspunkt für diese Instanz zur Verfügung.

Auswirkungen: Verhindert, dass mehr als eine In­stanz erzeugt werden kann. Ermöglicht Zugriffskontrolle auf die Instanz. Reduziert die Verwendung globaler Variablen.

Pattern: Prototyp.

Bestimmt die Arten zu erzeu­gender Objekte durch die Ver­wendung eines prototypischen Exemplars und erzeugt neue Objekte durch Kopieren dieses Prototypen.

Auswirkungen: Reduziert die Verwendung globaler Variablen. Dynamische veränderbare Objekter­zeugung. Aggregation statt Vererbung. Klonen statt Instanzierung.

Pattern: Builder (Erbauer).

Klassenhierarchien von Erbau­ern implementieren verschie­dene Bauvarianten.

Auswirkungen: Fördert die Programmierung gegen Schnittstellen. Anzahl der Klassen in einer Anwen­dung wird erhöht.

Pattern: Factory-Methode (Fabrikmethode)

Delegiert die Erzeugung von Objekten an Unterklassen. Defi­niert eine Schnittstelle zur Er­zeu­gung eines Objekts, legt aber erst in den Unterklassen fest, welche Klasse zu instanzieren ist.

Auswirkungen: Fördert die Programmierung gegen Schnittstellen. Ermöglicht das Einfügen speziali­sierter Klassen. Anzahl der Klassen in einer Anwen­dung wird erhöht.

Pattern: Abstract-Factory (abstrakte Fabrik)

Definiert Schnittstellen für die Erzeugung von Familien verwandter Objekte, ohne sich auf konkrete Klassen festlegen zu müssen.

Auswirkungen: Stellt sicher, dass Objekte lediglich zusammen mit den Objekten ver­wendet werden, mit denen sie kompatibel sind. Das Hinzufügen neuer Produkte ist auf­wendig.

Im nächsten Teil dieser Reihe wird es um die Strukturmuster gehen. Ein weiterer Teil der Reihe wird sich mit den Verhaltensmustern beschäftigen.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Dem abgeleiteten Objekt können neue Variablen und Methoden hinzuge­fügt werden, somit ist eine Wiederverwendung realisiert. Diese Technik der Wieder­ver­wen­dung ist auch als White-Box-Wiederverwendung bekannt, da die Struktur des Eltern­objekts eingebunden wird und somit bekannt ist.

Die Objektkomposition hingegen basiert auf der Technik, Objekte bestehender Klassen in eine Struktur einzubeziehen, beispielsweise durch Aggregation. Da hier lediglich die Schnittstelle des Objekts bekannt ist, wird diese Art von Wiederverwendung auch als Black-Box-Wiederverwendung bezeichnet.

Die Klassenvererbung ist Teil der Programmiersprache und einfach zu realisieren. Die geerbten Methoden können beibehalten oder überschrieben werden, die Variablen werden ergänzt, genutzt oder ignoriert. Hier lässt sich schon erahnen, dass die Klassen­vererbung zu unsauberem Programmierstil verleiten kann.

Die Vorteile der Objektkomposition liegen ganz klar in der Flexibilität. Beziehungen zwischen Objekten lassen sich, im Gegensatz zu denen zwischen Klassen, zur Laufzeit dynamisch erzeugen und verwerfen. Darüber hinaus sind die beteiligten Objekte ledig­lich durch die Schnittstelle bekannt und können somit gegen eine ähnliche Schnittstelle ausgetauscht werden, ohne dass auf die unterschiedlichen Implementierungen Rücksicht genommen werden muss – sofern die Spezifikation erfüllt bleibt. Für die Nutzung der Wiederverwendung durch Objektkomposition spricht auch, dass die Klassenvererbung die Klassenhierarchie verkompliziert und es dabei zu weiteren Abhängigkeiten kommt: Jede Ver­änderung der Implementierung oder der Struktur einer Oberklasse wirkt sich auf die abgeleitete Unterklasse aus.

Der Vergleich zwischen Klassenvererbung und Objektkomposition ist eigentlich nicht notwendig, da beide Techniken zur Anwendung kommen müssen. Schließlich muss eine Klassenhierarchie existieren, um überhaupt Objekte zur Objektkomposition ableiten zu können. Da jedoch die Erfahrung lehrt, dass selten der kompliziertere Weg der Objekt­kom­position gewählt wird, sollte jeder Entwickler die Möglichkeiten und Konsequenzen beider Techniken kennen. Das Wissen um den richtigen Einsatz beider Techniken bedarf einer gewissen Erfahrung, die letzten Endes den Experten ausmacht.

Tipp: Das Durcharbeiten der Entwurfsmuster ist vor allem für unerfahrene Entwickler sinn­voll, um für die Feinheiten des objektorientierten Softwareentwurfs »sensibilisiert« zu werden.

Delegation

Mithilfe der Delegation von Anfragen kann auch mittels Objektkomposition ein Ver­halten simuliert werden, welches andernfalls lediglich über Vererbung realisiert werden kann.

Um dies zu erklären, verwende ich ein Beispiel, welches bereits auf ein Ent­wurfsmuster zurückgreift. Es handelt es sich dabei um das Zustandsmuster (State-Pattern).

In einer Software wird eine Datei mittels eines Objekts repräsentiert. Da sich der Zustand einer Datei ändern kann (offen/geschlossen), muss sich auch das Verhalten des entsprechenden Objekts ändern. Eine Möglichkeit, dies in einem objektorientierten Entwurf zu implementieren, besteht darin, eine abstrakte Klasse namens Datei einzuführen, von der eine konkrete Klasse namens OffeneDatei und eine andere namens GeschlosseneDatei abgeleitet werden. So werden die abstrakten Metho­den wie beispielsweise oeffnen() oder schliessen() überschrieben und das unter­schied­liche Verhalten ist realisiert.

In dieser starren Hierarchie stellt die Änderung des Dateizustandes eine Hürde dar. Ein Objekt müsste die Klasse wechseln, was nicht möglich ist. Man müsste ein Objekt der jeweils gewünschten Klasse erzeugen, die Variablen umkopieren etc. Und selbst dann bekommt man in einem komplexen Entwurf eventuell noch Probleme mit vorhandenen Referenzen und wird so zu weiteren Änderungen gezwungen.

Der Lösungsansatz des Zustandsmusters besteht darin, ein Dateiobjekt einzuführen, welches diejenigen Daten bzw. Operationen enthält, die kontextunabhängig sind. Darüber hinaus erhält dieses Objekt eine Referenz auf ein Zustandsobjekt, in welchem die zustandsabhängigen Operationen implementiert sind.

Hinweis: Die verschiedenen Zustandsklassen stammen dabei von einer abstrakten Klasse ab.

Nun ist die Existenz eines Dateiobjekts unabhängig von seinem Zustand gesichert. Lediglich bei Veränderungen des Zustands sind Veränderungen in der Objektstruktur nötig. Diese Struktur ist zur Laufzeit dynamisch und hat somit das übergeordnete Ziel des objektorientierten Entwurfs erreicht.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.

Grundlagen

Erich Gamma, Mitte der 1990er Jahre Wissenschaftler an der Hochschule in Zürich, promovierte über die Übertragung dieser Methode auf die Softwareentwicklung. Im Anschluss ging er nach Amerika, wo er zusammen mit Richard Helm, Ralph Johnson und John Vlissides das Buch »Design Patterns – Elements of Reusable Design« heraus­brachte, in dem 23 Entwurfsmuster beschrieben sind. Dieses Autorenquartett ist auch unter dem Spitznamen »Gang of Four« (Viererbande) bekannt. GoF wird gelegentlich auch als Verweis für besagtes Buch verwendet. Anders als Christopher Alexander, der seine Muster vor allem für Laien geschrieben hat, richten sich die GoF-Muster an Entwickler und nicht an Benutzer.

Grundsätzlich ist der objektorientierte Soft­wareentwurf wesentlich aufwendiger als der prozedurale Entwurf. Der Entwickler muss zahlreiche Festlegungen treffen, die sich nicht direkt aus der Problemstellung ableiten. Um Ihnen dies nochmals zu verdeutlichen, sollten Sie folgende Zusammenstellung betrach­ten:

• Bildung von Klassen – Hier muss der Entwickler die Daten und die auf sie anzuwenden­den Operationen in Klassen abbilden. Im Rahmen der Fragestellung der Objektgranularität ist in erster Linie festzulegen, wie detailliert die Aufteilung der Daten und Methoden auf die verschiedenen Klassen erfolgen soll.

• Vererbungshierarchie – Die gebildeten Klassen verbindet eine zu gestaltende Ver­erbungshierarchie. Der Entwickler hat zu entscheiden, welche Klassen sinnvoller­weise voneinander erben sollen. Darüber hinaus sind ggf. abstrakte Klassen zu bilden. Die Vererbungshierarchie wird beim Softwareentwurf oft auch als »Ver­wandschaftsbeziehung« bezeichnet.

• Schnittstellengestaltung – Im Rahmen der Schnittstellengestaltung muss festgelegt wer­den, welche Daten ein Objekt einer Klasse mithilfe welcher Methoden welchen anderen Objekten anderer Klassen zur Verfügung stellen soll.

• Beziehungen zwischen Objekten – Neben Verwandschaftsbeziehungen der Klassen muss es selbstverständlich auch Beziehungen zwischen den Objekten der Klassen geben. Ein Objekt kann beispielsweise ein anderes Objekt erzeugen, besitzen oder eine Referenz auf dieses verwalten. Diese Beziehungen sind ebenso wichtig wie die Vererbungsbeziehungen, da durch sie erst ein guter, objektorientierter Softwareent­wurf mit flexibler Struktur entsteht.

Hinweis: Sie sollten darauf achten, die einzelnen Festlegungen nicht in der angegebe­nen Reihenfolge, sondern vielmehr parallel zueinander festzulegen.

Diesem Mehraufwand, der sich während der Entwicklungsarbeit ergibt, steht ein enormer Nutzen gegenüber, der die Popularität objektorientierter Entwicklung be­gründet. Objektorientierte Entwürfe sind flexibler. Veränderungen in der Problemstel­lung sind leicht zu realisieren, das Gleiche gilt für Erweiterungen. Diese Flexibilität beruht hauptsächlich darauf, dass der Entwickler bei seiner Arbeit wiederverwendbare Entwürfe entwickelt hat, die durch diverse Techniken verändert werden können.

Der gedankliche Brückenschlag zu den Entwurfsmustern gelingt, wenn man erkennt, dass verschiedene Softwarebestandteile ähnliche oder sogar gleiche Strukturen enthal­ten. Wenn man diese Strukturen hinreichend abstrahiert, kann man sie als Muster bezeichnen.

Die Technik der Gang Of Four besteht daher nicht nur im Entwurf von Mustern, son­dern in der Art, sie zu beschreiben und somit anwendbar zu machen.

Hinweis: Vollkommen analog hierzu wurden in der Vergangenheit auch bewährte Algorith­men katalogisiert, veröffentlicht und standardisiert. Sortieralgorithmen sind hierfür ein typi­sches Beispiel.

Objektorientierung für Fortgeschrittene

Das Verständnis für die Grundsätze und Techniken der objektorientierten Programmie­rung, wie beispielsweise der Kapselung oder Vererbung, bereitet normalerweise keine großen Schwierigkeiten. Damit ist es jedoch noch nicht getan. Die eigentliche Leistung des Entwicklers besteht darin, die bereitgestellten Techniken sinnvoll einzusetzen. Im Folgenden werde ich wichtige Aspekte der objektorien­tierten Entwicklung aufgreifen, die für Verständnis und Gebrauch der Entwurfs­muster wichtig sind.

Unterschiedung zwischen Klassenvererbung und Schnittstellenvererbung

Diese Unterscheidung wird in verschiedenen Programmiersprachen unterschiedlich reali­siert bzw. nicht realisiert.

Bei der Klassenvererbung erhält das abgeleitete Objekt sämtliche Variablen sowie die Methoden. Analog hierzu erhält das abgeleitete Objekt bei der Schnittstellenvererbung ausschließlich die Signaturen der Methoden, nicht aber deren Implementierung. Dies wird auch als Subtyping bezeichnet, da eine Klasse, die die abgeleitete Schnittstelle imple­mentiert, vom selben Typ wie die beerbte Schnittstelle ist und somit sämt­liche ihrer Anfragen erfüllt.

In den Mustern und in objektorientierten Programmiersprachen, die keinen expliziten Unterschied bei der Vererbung machen, wird die Schnittstellenvererbung durch das Erben von abstrakten Klassen nachgebildet.

Der nächste Teil dieser Reihe widmet sich Techniken wie der Klassenvererbung und Objektkomposition sowie der Delegation und deren Bedeutung für die objektorientierte Entwicklung.

Dieser Abschnitt wurde dem Buch “PHP 5 – Objektorientierte Programmierung” von Matthias Kannengiesser entnommen, das im Franzis Verlag erschienen ist. Sie können es hier direkt bestellen.