Einfache Klassen (Thema: PHP Beispiele)

1. Einleitung

Eine Klasse dient als eine Art von „Schablone”, die eine Menge von Objekten aus der realen Welt abbildet. Sie ist zugleich ein Modell und lässt daher immer einige irrelevante Informationen weg. Übrig bleiben sollen nur diejenigen, die für das Programm tatsächlich von Bedeutung sind. Über die Klasse können diese (miteinander eng verbundenen) Daten an einem „Ort” abgespeichert und verwaltet werden, statt sie über eine Vielzahl von völlig getrennten Variablen und Funktionen zu managen. Das erhöht die Lesbarkeit und Wartbarkeit des Codes erheblich. Die Verwendung von Klassen wird daher dringend empfohlen.

Da eine Klasse nur eine Schablone ist, können (und müssen) anhand dieser Objekte erzeugt werden, welche die Variablen der Klasse mit konkreten Werten belegen. So könnte man im Code eine Klasse „Laptop” implementieren, welche Variablen für den Hersteller und den Preis des Geräts anbietet. Will man nun einen konkreten Laptop im System abbilden, dann müsste man für diesen entsprechend den Hersteller und den Preis angeben. Genauso könnte man mehrere weitere Laptops mit anderen Herstellern und Preisen erzeugen. Diese können im Code „herumgereicht” werden, sodass andere Funktionen mit diesen konkreten Laptops arbeiten können. (Diese Funktionen könnten sich dann darauf verlassen, dass jeder Laptop einen Preis und eine Herstellerangabe hat.)

Eine Klasse wird mit dem Schlüsselwort class eingeleitet, gefolgt vom Namen. Wie bei Funktionen ist der „Körper” oder „Inhalt” der Klasse von geschweiften Klammern umgeben. Die Klasse kann beliebig viele Funktionen enthalten. (Im Falle der Laptop-Klasse würden sich zum Beispiel Funktionen zum Zurückgeben von Preis/Hersteller anbieten oder auch eine anschalten()/ausschalten()-Funktion.) Ebenso kann die Klasse beliebig viele Variablen enthalten, die auch als Felder bezeichnet werden.

<?php
	class Laptop {
		private $hersteller;
		
		public function anschalten() {
			// ...
		}
	}
?>

2. Klasse Laptop

Nachfolgend wird eine Klasse „Laptop” definiert. Jeder Laptop zeichnet sich hier einzig durch einen Hersteller (manufacturer) und einen Preis (price) aus. Hersteller und Preis werden als Variablen der Klasse (Felder) gespeichert (in $manufacturer und $price). Von außerhalb kann der Preis und Hersteller durch Aufruf der Funktionen (bzw. Methoden) setPrice() sowie setManufacturer() geändert werden. Analog ist ein Abfragen des aktuellen Preises/Herstellers durch getPrice()/getManufacturer() möglich.

Die Klasse hat einen Konstruktor, der Angaben für den Hersteller und Preis erwartet. Der Konstruktor wird beim Erzeugen eines neuen Objekts der Klasse aufgerufen. Er gibt sozusagen die Mindestdaten vor, die im Objekt gespeichert sein müssen, damit dieses Sinn macht. Ein Laptop ohne Hersteller wäre zum Beispiel eher sinnlos. (Beim Preis könnte man argumentieren, dass dieser nicht zwangsweise angegeben werden muss, damit das Objekt Sinn macht. Der Einfachheit halber wird dieser hier aber trotzdem verlangt. Am Ende hängt es immer von den Anforderungen an die Klasse ab, welche Informationen verlangt werden sollten und welche nicht.)

Nach der Definition der Klasse wird ein konkretes Objekt $myLaptop erzeugt, welches einen bestimmten Laptop in der realen Welt repräsentieren soll. Dieser Laptop soll vom Hersteller „Dell” stammen und den Preis 1000 haben. Nach Erzeugen des Objekts werden sein Hersteller und Preis ausgelesen und ausgegeben. Anschließend wird der Preis über setPrice() auf 900 gestellt und noch einmal ausgegeben.

<?php
	/**
	 * Klasse, die zum Abbilden aller möglichen Laptops dient.
	 */
	class Laptop {
		// Variablen der Klasse bzw. Felder
		// Sie speichern den Hersteller und den Preis ab
		// Von außen soll nicht auf sie zugegriffen werden, daher "private"
		private $manufacturer;
		private $price;
		
		/**
		 * Konstruktor, der immer aufgerufen wird, wenn ein neues konkretes Objekt der
		 * Klasse Laptop erzeugt wird.
		 * Der Konstruktor erwartet eine Herstellerangabe und einen Preis für den neuen konkreten Laptop.
		 */
		public function __construct($manufacturer, $price) {
			// Über $this greift das Objekt auf sich selbst zu,
			// entsprechend wird über $this->manufacturer = "test" der Hersteller
			// dieses Objekts auf "test" gesetzt
			$this->manufacturer = $manufacturer;
			$this->price = $price;
		}
		
		// gibt den Hersteller zurück
		public function getManufacturer() {
			return $this->manufacturer;
		}
		
		// ändert den Hersteller des Laptops
		public function setManufacturer($manufacturer) {
			$this->manufacturer = $manufacturer;
		}
		
		// gibt den Preis zurück
		public function getPrice() {
			return $this->price;
		}
		
		// ändert den Preis des Laptops
		public function setPrice($price) {
			$this->price = $price;
		}
	}
	
	// Einen neuen Laptop vom Hersteller "Dell" zum Preis 1000 erzeugen
	$myLaptop = new Laptop('Dell', 1000);
	
	// Hersteller und Preis des konkreten Objekts ausgeben
	var_dump($myLaptop->getManufacturer());
	var_dump($myLaptop->getPrice());
	
	// Preis ändern und noch einmal ausgeben
	$myLaptop->setPrice(900);
	var_dump($myLaptop->getPrice());
?>

string(4) "Dell"
int(1000)
int(900)

3. Eine Klasse "Haustier"

Als nächstes wird eine kleine Klasse „Haustier” definiert. Diese bildet ein beliebiges Haustier ab. Objekte der Klasse müssen den Namen des Haustiers und seine Tierart vorgeben. Entsprechend können Name und Tierart jeweils über eine set- und eine get-Methode definiert und abgefragt werden. Ebenso kann ein Haustier mit einem beliebigen Nahrungsmittel über die fuetternMit()-Methode gefüttert werden. Diese macht allerdings nicht mehr als nur einen kurzen Hinweis auszugeben, dass das Tier etwas gegessen hat.

Im Anschluss an die Definition wird ein Objekt der Klasse erzeugt. Dieses Haustier wird ein mal gefüttert und ein mal umbenannt.

<?php
	/**
	 * Die Klasse Haustier.
	 * Jedes Haustiert wird hier anhand seines Namens und der Tierart abgespeichert.
	 * (Je nach Zweck kann man noch viel mehr abspeichern.)
	 */
	class Haustier {
		private $name;
		private $tierart;
		
		/**
		 * Der Konstruktor. Er wird immer aufgerufen, wenn ein neues Objekt
		 * der Klasse Haustier erzeugt wird und nimmt Name und Tierart des
		 * Haustiers entgegen. So hat jedes Objekt der Klasse Haustiert immer
		 * einen Namen und eine zugewiesene Tierart.
		 */
		public function __construct($name, $tierart) {
			$this->name = $name;
			$this->tierart = $tierart;
		}

		/**
		 * Über diese Methode kann der Name des Tiers nachträglich geändert werden.
		 * @param string $name
		 */
		public function setName($name) {
			$this->name = $name;
		}

		/**
		 * Über diese Methode kann der Name des Tiers abgefragt werden.
		 * @return string
		 */
		public function getName() {
			return $this->name;
		}
		
		/**
		 * Über diese Methode kann die Tierart abgefragt werden.
		 * Es wurde keine setTierart()-Methode festgelegt, sodass die
		 * Tierart nicht mehr im Nachhinein geändert werden kann.
		 * @return string
		 */
		public function getTierart() {
			return $this->tierart;
		}

		/**
		 * Über diese Methode kann das Haustiert mit einem Nahrungsmittel
		 * gefüttert werden.
		 * @param string $mit
		 */
		public function fuetternMit($mit) {
			echo('Mmmmh '.$mit.'! Mampf, Mampf!');
		}
	}

	
	// Ein neues Objekt der Klasse Haustiert wird erzeugt
	$tigger = new Haustier('Tigger', 'Hauskatze');

	// Die Katze wird gefüttert
	$tigger->fuetternMit('Katzenfutter');

	// Der Name der Katze wird ausgegeben. Anschließend wird er geändert und noch mal ausgegeben.
	var_dump($tigger->getName());
	$tigger->setName('Schleckermaul');
	var_dump($tigger->getName());
?>

Mmmmh Katzenfutter! Mampf, Mampf!string(6) "Tigger"
string(13) "Schleckermaul"