9. Unterrichtsblock

PHP Objektorientierte Programmierung (OOP)

• Bei der prozeduralen Programmierung geht es darum, Prozeduren oder Funktionen zu schreiben, die Operationen mit den Daten ausführen.
• Bei der objektorientierten Programmierung geht es darum, Objekte zu erstellen, die sowohl Daten als auch Funktionen enthalten.

Die objektorientierte Programmierung hat gegenüber der prozeduralen Programmierung mehrere Vorteile:

• OOP ist schneller und einfacher auszuführen
• OOP bietet eine klare Struktur für die Programme
• OOP hilft, den PHP-Code DRY „Don’t Repeat Yourself“ zu halten, und macht den Code leichter zu warten, zu ändern und zu debuggen
• OOP ermöglicht es, vollständig wiederverwendbare Anwendungen mit weniger Code und kürzerer Entwicklungszeit zu erstellen

Tipp: Beim Prinzip „Don’t Repeat Yourself“ (DRY) geht es darum, die Wiederholung von Code zu reduzieren. Man sollte die Codes, die für die Anwendung üblich sind, extrahieren und sie an einer einzigen Stelle (z. B. separate Datei) platzieren und wiederverwenden (z. B. durch include oder require), anstatt sie zu wiederholen.

---

Was sind Klassen und Objekte?

Klassen und Objekte sind die beiden Hauptaspekte der objektorientierten Programmierung. Folgedes Beispiel zeigt den Unterschied zwischen einer Klasse und den Objekten:

Eine Klasse ist also eine Vorlage für Objekte, und ein Objekt ist eine Instanz einer Klasse.

Wenn die einzelnen Objekte erstellt werden, erben sie alle Eigenschaften und Verhaltensweisen von der Klasse, aber jedes Objekt hat unterschiedliche Werte für die Eigenschaften.

Nehmen wir an, wir haben eine Klasse namens „Tier“. Ein Tier kann Eigenschaften wie Name, Farbe, Gewicht usw. haben. Wir können Variablen wie $name, $farbe und $gewicht definieren, um die Werte dieser Eigenschaften zu speichern.

Wenn die einzelnen Objekte (Katze, Pferd usw.) erstellt werden, erben sie alle Eigenschaften und Verhaltensweisen von der Klasse, aber jedes Objekt hat unterschiedliche Werte für die Eigenschaften.

Definieren einer Klasse

Eine Klasse wird mit dem class Schlüsselwort definiert, gefolgt vom Namen der Klasse und einem Paar geschweifter Klammern ({}). Alle seine Eigenschaften und Methoden gehen in die geschweiften Klammern:

<?php
class Tier {
  // individueller Code...
}
?>

Unten deklarieren wir eine Klasse namens „Tier“, die aus zwei Eigenschaften ($name und $farbe) und zwei Methoden set_name() und get_name() zum Setzen und Abrufen der $name-Eigenschaft besteht:

<?php
class Tier {
  // Eigenschaften (= Variablen)
  public $name;
  public $farbe;

  // Methoden (= Funktionen)
  function set_name($name) {
    $this->name = $name;
  }
  function get_name() {
    return $this->name;
  }
}
?>

Hinweis: In einer Klasse heißen Variablen Eigenschaften und Funktionen Methoden!

Es gibt drei Zugriffsmodifikatoren:

• public– Auf die Eigenschaft oder Methode kann von überall zugegriffen werden. Dies ist Standard
• protected– Auf die Eigenschaft oder Methode kann innerhalb der Klasse und von Klassen, die von dieser Klasse abgeleitet sind, zugegriffen werden
• private– Auf die Eigenschaft oder Methode kann NUR innerhalb der Klasse zugegriffen werden

Objekte definieren

Klassen sind nichts ohne Objekte! Man kann mehrere Objekte aus einer Klasse erstellen. Jedes Objekt hat alle Eigenschaften und Methoden, die in der Klasse definiert sind, aber sie haben unterschiedliche Eigenschaftswerte.

Objekte einer Klasse werden mit dem new Schlüsselwort erstellt.

Im folgenden Beispiel sind $katze und $pferd Instanzen der Klasse Tier:

<?php
class Tier {
  // Eigenschaft
  public $name;
  public $farbe;

  // Methode
  function set_name($name) {
    $this->name = $name;
  }
  function get_name() {
    return $this->name;
  }
}

$pferd = new Tier();
$katze = new Tier();
$pferd->set_name('Pferd');
$katze->set_name('Katze');

echo $pferd->get_name();
echo "<br>";
echo $katze->get_name();
?>

Im folgenden Beispiel wird der Klasse Tier zwei weitere Methoden hinzugefügt, um die Eigenschaft $farbe zu setzen (set_farbe) und zu erhalten (get_farbe):

<?php
class Tier {
  // Eigenschaften
  public $name;
  public $farbe;

  // Methoden
  function set_name($name) {
    $this->name = $name;
  }
  function get_name() {
    return $this->name;
  }
  function set_farbe($farbe) {
    $this->farbe = $farbe;
  }
  function get_farbe() {
    return $this->farbe;
  }
}

$katze = new Tier();
$katze->set_name('Katze');
$katze->set_farbe('Schwarz');
echo "Name: " . $katze->get_name();
echo "<br>";
echo "Farbe: " .  $katze->get_farbe();
?>

---

---

Das Schlüsselwort $this

Das Schlüsselwort $this bezieht sich auf das aktuelle Objekt und ist nur innerhalb von Methoden (Funktionen) verfügbar.

Folgendes Beispiel:

<?php
class Tier {
  public $name;
}
$pferd = new Tier();
?>

Wo können wir also den Wert der $name-Eigenschaft ändern? Es gibt zwei Möglichkeiten:

1. Innerhalb der Klasse (durch Hinzufügen einer set_name() Methode und Verwendung von $this):

<?php
class Tier {
  public $name;
  function set_name($name) {
    $this->name = $name;
  }
}
$katze = new Tier();
$katze->set_name("Katze");

echo $katze->name;
?>

2. Außerhalb der Klasse (durch direkte Änderung des Eigenschaftswerts):

<?php
class Tier {
  public $name;
}
$hund = new Tier();
$hund->name = "Hund";

echo $hund->name;
?>

---

Instanz von

Man kann das instanceof-Schlüsselwort verwenden, um zu prüfen, ob ein Objekt zu einer bestimmten Klasse gehört:

<?php
class Tier {
  // Eigenschaften
  public $name;
  public $farbe;

  // Methoden
  function set_name($name) {
    $this->name = $name;
  }
  function get_name() {
    return $this->name;
  }
}


$hund = new Tier();
var_dump($hund instanceof Tier);
?>

Die __construct-Funktion

Mit einem Konstruktor kann man die Eigenschaften eines Objekts bei der Erstellung des Objekts initialisieren. Wenn man eine __construct()Funktion erstellt, ruft PHP diese Funktion automatisch auf, wenn man ein Objekt aus einer Klasse erstellt.

Zu beachten ist, dass die Konstruktionsfunktion mit zwei Unterstrichen (__) beginnt!

Im folgenden Beispiel sehen wir, dass uns die Verwendung eines Konstruktors den Aufruf der Methode set_name() erspart, was die Menge an Code reduziert:

<?php
class Tier {
  public $name;
  public $farbe;

  function __construct($name) {
    $this->name = $name;
  }
  function get_name() {
    return $this->name;
  }
}

$pferd = new Tier("Pferd");
echo $pferd->get_name();
?>

Ein anderes Beispiel:

<?php
class Tier {
  public $name;
  public $farbe;

  function __construct($name, $farbe) {
    $this->name = $name; 
    $this->farbe = $farbe; 
  }
  function get_name() {
    return $this->name;
  }
  function get_farbe() {
    return $this->farbe;
  }
}

$katze = new Tier("Katze", "schwarz");
echo $katze->get_name();
echo "<br>";
echo $katze->get_farbe();
?>

Die __destruct-Funktion

Ein Destruktor wird aufgerufen, wenn das Objekt zerstört oder das Skript angehalten oder beendet wird. Wenn man eine __destruct()Funktion erstellt, ruft PHP diese Funktion automatisch am Ende des Skripts auf.

Zu beachten ist, dass die Destruct-Funktion mit zwei Unterstrichen (__) beginnt!

Das folgende Beispiel hat eine __construct()-Funktion, die automatisch aufgerufen wird, wenn man ein Objekt aus einer Klasse erstellt, und eine __destruct()-Funktion, die automatisch am Ende des Skripts aufgerufen wird:

<?php
class Tier {
  public $name;
  public $farbe;

  function __construct($name) {
    $this->name = $name; 
  }
  function __destruct() {
    echo "Das Tier ist ein {$this->name}."; 
  }
}

$pferd = new Tier("Pferd");
?>

Ein anderes Beispiel:

<?php
class Tier {
  // Eigenschaften
  var $name;
  var $farbe;

  // Methoden
  function __construct($name, $farbe) {
    $this->name = $name;
    $this->farbe = $farbe; 
  }
  function __destruct() {
    echo "Das Tier ist ein {$this->name} und die Farbe ist {$this->farbe}."; 
  }
}

$pferd = new Tier("Pferd", "schwarz");
?>

Tipp: Da Konstruktoren und Destruktoren helfen, die Menge an Code zu reduzieren, sind sie sehr nützlich!