PHP Classes: Die Bausteine der ob­jekt­ori­en­tier­ten Pro­gram­mie­rung

PHP Classes or­ga­ni­sie­ren den Code in un­ab­hän­gi­ge logische Module, die jeweils bestimmte Ei­gen­schaf­ten und Methoden besitzen. Dies fördert die Wie­der­ver­wend­bar­keit und die Ver­wal­tung großer Projekte.

Was sind PHP Classes?

PHP Classes gleichen Vorlagen oder Bauplänen, die zur Er­stel­lung von Objekten verwendet werden. Eine Klasse definiert die Ei­gen­schaf­ten (Variablen oder Attribute) und Methoden (Funk­tio­nen), die ein Objekt haben wird. Klassen sind ein we­sent­li­cher Be­stand­teil der ob­jekt­ori­en­tier­ten Pro­gram­mie­rung und können zum Beispiel in Ver­bin­dung mit anderen PHP-Funk­tio­nen ein­ge­setzt werden. Sie können auch Klassen erstellen, um mit PHP In­for­ma­tio­nen aus einer MySQL-Datenbank abzurufen.

So definiert man PHP Classes

Für die De­fi­ni­ti­on einer Klasse in PHP benutzen wir das Schlüs­sel­wort class, gefolgt von dem Klas­sen­na­men und ge­schweif­ten Klammern. Da­zwi­schen schreiben wir die Ei­gen­schaf­ten und Methoden der Klasse.

class Name {
    // php class example properties and methods
}

Hier ist ein konkretes Beispiel:

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}

Die Klasse „Animal“ besitzt die beiden Ei­gen­schaf­ten „name“ und „color“ sowie zwei Methoden, um den Namen fest­zu­le­gen (set_name) und abzurufen (get_name).

In welcher Ver­bin­dung stehen PHP-Klassen und -Objekte?

Objekte sind Instanzen einer Klasse. Wenn Sie eine Klasse in­stan­zi­ie­ren, erhalten Sie ein konkretes Objekt, das auf die in der Klasse de­fi­nier­ten Ei­gen­schaf­ten und Methoden zugreifen kann. Objekte einer Klasse werden mit dem Schlüs­sel­wort new erstellt:

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}
$dog = new Animal();
$cat = new Animal();
$dog->set_name('Tom');
$cat->set_name('Mickey');
echo $dog->get_name();
echo "<br>";
echo $cat->get_name();

Hier sind „dog“ und „cat“ Instanzen der Klasse „Animal“, denen wir jeweils eigene Namen geben.

Des Weiteren können PHP Classes vererbt werden, was bedeutet, dass Sie von einer be­stehen­den Klasse ableiten dürfen, um eine neue Klasse zu de­fi­nie­ren. Die ab­ge­lei­te­te Klasse erbt die Ei­gen­schaf­ten und Methoden der Ba­sis­klas­se. Dies er­mög­licht die Wie­der­ver­wen­dung und die Er­wei­te­rung von Funk­tio­nen. Objekte der ab­ge­lei­te­ten Klasse sind auch Instanzen der Ba­sis­klas­se und können deren Methoden einsetzen.

class Mammal extends Animal {
function breathesAir() {
      echo "inhale";
    }
}
$horse = new Mammal;
$horse->setName("Louis");

Mit dem Schlüs­sel­wort extends erbt die Klasse „Mammal“ alle Ei­gen­schaf­ten und Methoden der Ober­klas­se „Animal“. Wir können „Mammal“ eine neue Funktion hin­zu­fü­gen, aber auch auf vererbte zugreifen.

Beispiele für die Anwendung von PHP Classes

PHP-Klassen sind viel­sei­tig ein­setz­bar. Im Folgenden stellen wir Ihnen prak­ti­sche Beispiele vor.

PHP in­s­tance­of

In PHP ist in­s­tance­of ein Operator, um zu über­prü­fen, ob ein Objekt einer be­stimm­ten oder einer von ihr ab­ge­lei­te­ten Klasse angehört.

Hier ist ein einfaches Beispiel:

class Animal {
    public function speak() {
        echo "sound";
    }
}
class Dog extends Animal {
    public function speak() {
        echo "bark";
    }
}
$animal = new Dog();
if ($animal instanceof Animal) {
    $animal->speak(); // Output: "bark"
}

Als Erstes über­prü­fen wir mit in­s­tance­of, ob $animal eine Instanz der PHP Class „Animal“ oder einer ihrer ab­ge­lei­te­ten Klasse ist. Da $animal eine Instanz der ab­ge­lei­te­ten Klasse „Dog“ ist (die von Animal erbt), wird die Bedingung erfüllt und der Code im If-Block aus­ge­führt.

Der instanceof-Operator ist hilfreich, wenn Sie si­cher­stel­len möchten, dass Sie auf bestimmte Methoden oder Ei­gen­schaf­ten zugreifen können, ohne dass es zu Fehlern kommt, wenn das Objekt nicht die erwartete Klasse hat.

PHP-Klassen und -Arrays

Klassen können in PHP-Arrays ge­spei­chert werden, um komplexe Da­ten­struk­tu­ren zu entwerfen.

class Product {
    public $name;
    public $price;
    public function __construct($name, $price) {
        $this->name = $name;
        $this->price = $price;
    }
}
$products = [
    new Product("Laptop", 800),
    new Product("Smartphone", 400),
    new Product("Tablet", 300)
];
foreach ($products as $product) {
    echo "Product: " . $product->name . ", Price: $" . $product->price . "<br>";
}

In diesem Beispiel de­fi­nie­ren wir die Klasse „Product“, um ver­schie­de­ne Produkte zu re­prä­sen­tie­ren, und speichern diese in dem Array „products“. Wir können dann das Array mit PHP-Loops wie dem foreach-Konstrukt durch­lau­fen, um die Pro­dukt­na­men und Preise aus­zu­ge­ben.

PHP Class Con­s­truc­tor

Der Kon­struk­tor ist eine spezielle Methode innerhalb einer PHP Class, die au­to­ma­tisch auf­ge­ru­fen wird, wenn ein Objekt dieser Klasse erstellt wird. Der Zweck eines Kon­struk­tors besteht darin, die An­fangs­zu­stän­de eines Objekts zu in­itia­li­sie­ren oder andere Vor­be­rei­tungs­ar­bei­ten durch­zu­füh­ren, die für das korrekte Funk­tio­nie­ren des Objekts er­for­der­lich sind.

class Dog {
    private $name;
    private $color;
    // Constructor
    public function __construct($name, $color) {
        $this->name = $name;
        $this->color = $color;
    }
    public function sayHello() {
        return "Hello, my name is {$this->name} and my color is {$this->color}.";
    }
}
$dog = new Dog("Tom", "brown");
echo $dog->sayHello(); // Output: "Hello, my name is Tom and my color is brown."