Objektorientierung

PHP ist, was viele nicht wissen, eine objektorientierte Sprache. Dies kommt vor allem daher, da sich viele Grundlagen-Tutorials nicht mit dem Thema der Objektorientierung beschäftigen. In Anbetracht dessen, dass Sie PHP lernen wollen, um damit später vielleicht auch ein größeres Projekt zu erstellen, ist es nützlich, die Möglichkeiten der Objektorientierung zu kennen, da es damit möglich ist, Daten (Werte, Variablen und Funktionen) einfach zu kapseln. In PHP ist es möglich, Programmcode außerhalb von Objekten zu platzieren. Dies ist bei anderen Sprachen oftmals, wie z. B. in C++, nicht möglich.

Bevor wir unser erstes Objekt erzeugen bzw. unsere erste Klasse definieren, müssen wir einige Begriffe erklären. Unter der objektorientierten Programmierung (oder kurz OOP) versteht man eine bestimmte Technik, Daten (dazu zählen Konstanten sowie die sogenannten Eigenschaften und Methoden) zu kapseln, also „auszulagern“ und zu „gruppieren“.

Um ein Objekt zu erzeugen, man spricht hier auch von instanziieren, benötigen wir zuerst eine Art Bauplan. Ein Bauplan wird in der OOP durch eine Klasse repräsentiert. Um eine Klasse zu definieren, notieren wir das Schlüsselwort class gefolgt von einem frei definierbaren Klassennamen. Der Klassenname muss, wie Variablennamen auch, eindeutig sein. Der Name kann dabei Buchstaben, Zahlen oder Unterstriche enthalten. Als gängige Schreibweise wird auch hier die sogenannte Camel-Case-Schreibweise verwendet, bei welcher jeder Anfangsbuchstabe eines Worts groß geschrieben wird. Im Gegensatz zu Variablen- oder Funktionsnamen, beginnen Klassennamen für gewöhnlich mit einem Großbuchstaben. Die Schreibweise ist jedoch nur eine Empfehlung und keineswegs eine Pflicht. Nach dem Klassennamen notieren wir einen Block.

<?php
class MeineKlasse
{
    
}
?>

Innerhalb des Blocks können nun Konstanten, Variablen und Funktionen angegeben werden. Diese gehören damit zur Klasse und können nur innerhalb der Klasse oder über ein instanziiertes Objekt (dazu später mehr) aufgerufen und verwendet werden (abgesehen von zwei Ausnahmen, dazu gleich mehr). Für die Variablen (auch als Eigenschaften bezeichnet) und Funktionen (auch als Methoden bezeichnet) innerhalb einer Klasse kann bzw. sollte ein sogenannter Zugriffsmodifizierer angegeben werden. Hierfür stehen die Schlüsselwörter public, protected und private zur Verfügung. Mit Hilfe des Zugriffsmodifzierers kann die sogenannte Sichtbarkeit von Eigenschaften und Methoden gesteuert werden. Durch das Schlüsselwort public ist ein Zugriff auf die Variable oder Funktion von innerhalb der Klasse als auch von „außerhalb“ möglich. Bei private ist lediglich ein Zugriff von innerhalb der Klasse möglich. protected ist ähnlich wie private, jedoch mit dem Unterschied, dass auf Eigenschaften oder Methoden, die von einer anderen Klasse geerbt wurden und als private markiert sind, von einer anderen Klasse, der sogenannten Kindklasse, zugegriffen werden kann. Wenn Sie innerhalb von einer Klasse auf eine Eigenschaft oder Methode der Klasse zugreifen wollen, so benötigen Sie die Variable $this. $this enthält immer das aktuelle Objekt, also die Instanz der Klasse. Wollen Sie nun z. B. auf die Eigenschaft meineVariable zugreifen, so notieren Sie $this->meineVariable. Das gleiche Prinzip gilt bei Methoden. Die Zeichenfolge -> wird als Pfeiloperator bezeichnet.

<?php
class MeineKlasse
{
    public $MeineEigenschaft;
    
    public meineFunktion()
    {
        $this->MeineEigenschaft = 'Mein Wert';
    }
}
?>

Objekte werden mit Hilfe des Bauplans (also der Klasse) erzeugt. Dieser Vorgang wird als Instanziierung bezeichnet. Das instanziierte Objekt wird auch als Instanz der Klasse bezeichnet. Um eine Instanz zu erstellen, benötigen wir das Schlüsselwort new, den Klassennamen und ein rundes Klammernpaar. Durch das runde Klammernpaar wird der sogenannte Konstruktor aufgerufen. Standardmäßig existiert nur ein parameterloser Konstruktor. Mehr dazu jedoch später. Die erzeugte Instanz kann jetzt z. B. einer Variablen zugewiesen werden. Wollen Sie nun (von „außerhalb“) auf eine der Eigenschaften oder Methoden zugreifen, so verwenden Sie auch hier den Pfeiloperator ->.

<?php
$meinObjekt = new MeineKlasse();
?>

Konstanten in Klassen besitzen keinen Zugriffsmodifizierer. Ein Zugriff auf Konstanten ist somit immer möglich. Üblicherweise werden Konstanten in Großbuchstaben geschrieben. Zu beachten ist, dass Konstanten zwar Teil der Klasse, aber nicht Teil des Objekts sind. Bei der Notation einer Konstante geben Sie das Schlüsselwort const gefolgt von dem Konstantennamen an. Anschließend wird der Konstante mit einem Gleichheitszeichen ein Wert zugewiesen.

<?php
class MeineKlasse
{
    const MEINEKONSTATE = 'Mein Wert';
}
?>

Um auf Konstanten einer Klasse zuzugreifen, wird der sogenannte Gültigkeitsbereichsoperator :: verwendet. Dieser Operator wird neben dem Zugriff auf Klassen-Konstanten auch für den Zugriff auf statische Eigenschaften oder Methoden verwendet. Statische Klassenbestandteile kennzeichnen sich durch das Schlüsselwort static, welches nach dem Zugriffsmodifizierer angegeben wird, und sind nicht an eine Objektinstanz gebunden.

<?php
echo MeineKlasse::MEINEKONSTATE;  // Gibt 'Mein Wert' aus
?>

In der Objektorientierung haben sich im Laufe der Jahre einige ungeschriebene Regeln durchgesetzt. So sollte sich jedes Objekt in einer separaten Datei befinden. Wie Sie Dateien einbinden, lernen Sie im Thema Dateizugriffe. Private Eigenschaften und Methoden beginnen üblicherweise mit einem Unterstrich. Des Weiteren gilt es als „schlechte Praxis“, Eigenschaften als public zu kennzeichnen, da Sie so keine Kontrolle über den von „außen“ zugewiesenen Wert haben. Um dieses Problem zu lösen, werden üblicherweise sogenannte Getter- und Setter-Methoden verwendet. Wenn Sie z. B. eine Eigenschaft mit dem Namen Betriebssystem haben, sollten Sie die Methoden getBetriebssystem() und setBetriebssystem() implementieren.

Das folgende Beispiel zeigt die Klasse Computer. Die Eigenschaft Betriebssystem wurde im Beispiel absichtlich auf public gesetzt, um das Beispiel zu vereinfachen. Im unteren Teil des Codes sehen Sie, wie ein Objekt dieser Klasse instanziiert wird:

<?php
class Computer
{
	const OS_WINDOWS_XP = 'Windows XP';
	const OS_WINDOWS_7 = 'Windows 7';
	const OS_WINDOWS_8 = 'Windows 8';
	const OS_WINDOWS_10 = 'Windows 10';
	
	private $_gestartet = false;
	public $Betriebssystem = 'Windows 7';
	
	public function starteComputer()
	{
		if (!$this->_gestartet)
		{
			echo $this->Betriebssystem.' wird gestartet ...<br />';
			$this->_gestartet = true;
		}
		else
			echo 'Computer bereits gestartet!<br />';
	}
	
	public function stoppeComputer()
	{
		if ($this->_gestartet)
		{
			echo $this->Betriebssystem.' wird heruntergefahren ...<br />';
			$this->_gestartet = false;
		}
		else
			echo 'Computer läuft nicht!<br />';
	}
}

$meinComputer = new Computer();
$meinComputer->starteComputer();
$meinComputer->starteComputer();      // Computer läuft bereits
$meinComputer->stoppeComputer();
$meinComputer->stoppeComputer();      // Computer ist bereits heruntergefahren
$meinComputer->Betriebssystem = Computer::OS_WINDOWS_10;
$meinComputer->starteComputer();
?>

Konstruktor

Bei dem Konstruktor handelt es sich um eine spezielle Methode, welcher bei der Instanziierung des Objekts aufgerufen wird. Standardmäßig existiert bereits ein sogenannter Standard-Konstruktor, welcher keine Parameter erwartet. Möchten Sie in Ihrer Klasse einen Konstruktor implementieren, so können Sie auch die Konstruktor-Parameter bestimmen. Natürlich können ein oder mehrere dieser Parameter auch optional sein. Aus Sicht der Programmierung wird ein Konstruktor wie eine Funktion implementiert. Der Funktionsname des Konstruktors ist auf den Namen __construct festgelegt.

<?php
class Computer
{
	const OS_WINDOWS_XP = 'Windows XP';
	const OS_WINDOWS_7 = 'Windows 7';
	const OS_WINDOWS_8 = 'Windows 8';
	const OS_WINDOWS_10 = 'Windows 10';
	
	private $_gestartet = false;
	public $Betriebssystem = 'Windows 7';
	
	public function __construct($betriebssystem)
	{
		$this->Betriebssystem = $betriebssystem;
	}
	
	public function starteComputer()
	{
		if (!$this->_gestartet)
		{
			echo $this->Betriebssystem.' wird gestartet ...<br />';
			$this->_gestartet = true;
		}
		else
			echo 'Computer bereits gestartet!<br />';
	}
	
	public function stoppeComputer()
	{
		if ($this->_gestartet)
		{
			echo $this->Betriebssystem.' wird heruntergefahren ...<br />';
			$this->_gestartet = false;
		}
		else
			echo 'Computer läuft nicht!<br />';
	}
}

$meinComputer = new Computer(Computer::OS_WINDOWS_7);
$meinComputer->starteComputer();
$meinComputer->stoppeComputer();
?>

Vererbung

Bei der Vererbung werden, wie der Name schon vermuten lässt, Daten (also Konstante, Eigenschaften und Methoden) von einer Klasse an eine andere vererbt, also „weitergegeben“. Die Klasse, von welcher Daten geerbt werden, wird als Elternklasse oder auch als Basisklasse bezeichnet. Die Klasse, welche Daten von einer anderen Klasse erbt, wird als Kindklasse bezeichnet. Um die Vererbung anzugeben, wird nach dem Namen der Kindklasse das Schlüsselwort extends (zu Deutsch: erweitern) und anschließend der Name der Elternklasse angegeben. Um von einer Kindklasse auf eine Elternklasse zuzugreifen, nutzen wir das Schlüsselwort parent. Als Operator zum Zugriff wird der Gültigkeitsbereichsoperator :: verwendet. Funktionen, welche innerhalb der Kindklasse angegeben wurden und den gleichen Namen wie die Funktionen der Elternklasse haben, werden überschrieben. Wird nun eine solche überschriebene Funktion der Kindklasse aufgerufen, dann wird lediglich der Programmcode der Funktion der Kindklasse ausgeführt, nicht aber der der Elternklasse. Innerhalb der Kindklasse kann aber hier mit Hilfe des Schlüsselworts parent auf die überschriebene Funktion wieder zugegriffen werden.

Das untere Beispiel zeigt die Klasse Computer und Notebook. Notebook ist eine Kindklasse, dessen Elternklasse die Klasse Computer ist. In der Notebook-Klasse werden der Konstruktor sowie die Funktion starteComputer() überschrieben.

<?php
class Computer
{
	const OS_WINDOWS_XP = 'Windows XP';
	const OS_WINDOWS_7 = 'Windows 7';
	const OS_WINDOWS_8 = 'Windows 8';
	const OS_WINDOWS_10 = 'Windows 10';
	
	private $_gestartet = false;
	public $Betriebssystem = 'Windows 7';
	
	public function __construct($betriebssystem)
	{
		$this->Betriebssystem = $betriebssystem;
	}
	
	public function starteComputer()
	{
		if (!$this->_gestartet)
		{
			echo $this->Betriebssystem.' wird gestartet ...<br />';
			$this->_gestartet = true;
		}
		else
			echo 'Computer bereits gestartet!<br />';
	}
	
	public function stoppeComputer()
	{
		if ($this->_gestartet)
		{
			echo $this->Betriebssystem.' wird heruntergefahren ...<br />';
			$this->_gestartet = false;
		}
		else
			echo 'Computer läuft nicht!<br />';
	}
}

class Notebook extends Computer
{
	public $DisplayGroesse;
	
	public function __construct($betriebssystem, $displayGroesse)
	{
		parent::__construct($betriebssystem);
		
		$this->DisplayGroesse = $displayGroesse;
	}
	
	public function starteComputer()
	{
		parent::starteComputer();
		
		echo 'Ihr Bildschirm mit '.$this->DisplayGroesse.' Zoll wird initialisiert ...<br />';
	}
}

$meinNotebook = new Notebook(Computer::OS_WINDOWS_7, 15.6);
$meinNotebook->starteComputer();
$meinNotebook->stoppeComputer();
?>