php mit Adi Prinz

OOP Klassen und Objekte

Objektorientierte Programmierung (OOP) in PHP ermöglicht die Strukturierung von Code durch die Verwendung von Klassen und Objekten.

• Klassen: Ein Bauplan für Objekte. Definiert Eigenschaften (Attribute) und Methoden (Funktionen).
• Objekte: Eine Instanz einer Klasse. Eine konkrete Implementierung des Bauplans der Klasse.
• Konstruktor: Eine spezielle Methode, die automatisch aufgerufen wird, wenn ein Objekt erstellt wird.
• Vererbung: Eine Klasse kann von einer anderen Klasse erben, um deren Eigenschaften und Methoden zu übernehmen.
• Abstrakte Klassen: Eine abstrakte Klasse kann nicht instanziiert werden und muss von anderen Klassen abgeleitet werden.
• Schnittstellen (Interfaces): Definiert Methoden, die eine Klasse implementieren muss.
• Statische Eigenschaften und Methoden: Gehören zur Klasse selbst und nicht zu einer bestimmten Instanz der Klasse.

Beispiel: Grundlegende Klasse und Objekt

// Definition der Klasse
class Person {
    // Eigenschaften
    public $name;
    public $age;

    // Konstruktor
    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }

    // Methode
    public function introduce() {
        echo "Hallo, mein Name ist $this->name und ich bin $this->age Jahre alt.";
    }
}

// Erstellen eines Objekts
$person1 = new Person("Alice", 30);
$person1->introduce();
    

OOP Vererbung

Vererbung ist ein zentrales Konzept der objektorientierten Programmierung (OOP), das es ermöglicht, eine neue Klasse (Unterklasse oder abgeleitete Klasse) von einer bestehenden Klasse (Basisklasse oder Superklasse) zu erstellen. Durch Vererbung kann die Unterklasse die Eigenschaften und Methoden der Basisklasse erben, erweitern oder überschreiben. Dies fördert die Wiederverwendbarkeit und Strukturierung des Codes.

Beispiel: Vererbung

// Basisklasse
class Person {
    public $name;
    public $age;

    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }

    public function introduce() {
        echo "Hallo, mein Name ist $this->name und ich bin $this->age Jahre alt.";
    }
}

// Abgeleitete Klasse
class Student extends Person {
    public $grade;

    public function __construct($name, $age, $grade) {
        parent::__construct($name, $age);
        $this->grade = $grade;
    }

    public function study() {
        echo "$this->name lernt für die Klasse $this->grade.";
    }
}

$student = new Student("Bob", 20, "10. Klasse");
$student->introduce();
$student->study();
    

Abstrakte Klassen und Schnittstellen

Abstrakte Klassen

Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann und die als Vorlage für andere Klassen dient. Sie kann abstrakte Methoden enthalten, die in den abgeleiteten Klassen implementiert werden müssen. Abstrakte Klassen ermöglichen es, eine einheitliche Schnittstelle zu definieren, die alle abgeleiteten Klassen implementieren müssen, während sie gleichzeitig einige gemeinsame Funktionalitäten teilen können.

Schnittstellen

Eine Schnittstelle ist eine vollständig abstrakte Klasse, die nur abstrakte Methoden enthalten kann. Schnittstellen definieren eine Reihe von Methoden, die von jeder Klasse, die die Schnittstelle implementiert, definiert werden müssen. Sie ermöglichen es, eine Klasse zur Implementierung bestimmter Methoden zu zwingen, unabhängig davon, wo in der Klassenhierarchie sie sich befindet.

Beispiel: Abstrakte Klassen und Schnittstellen

// Abstrakte Klasse
abstract class Shape {
    abstract public function getArea();
}

// Abgeleitete Klasse
class Circle extends Shape {
    private $radius;

    public function __construct($radius) {
        $this->radius = $radius;
    }

    public function getArea() {
        return pi() * pow($this->radius, 2);
    }
}

// Schnittstelle
interface Drawable {
    public function draw();
}

// Klasse implementiert die Schnittstelle
class Square extends Shape implements Drawable {
    private $side;

    public function __construct($side) {
        $this->side = $side;
    }

    public function getArea() {
        return pow($this->side, 2);
    }

    public function draw() {
        echo "Ein Quadrat mit der Seitenlänge $this->side wird gezeichnet.";
    }
}

$circle = new Circle(5);
echo "Die Fläche des Kreises beträgt: " . $circle->getArea() . "
";

$square = new Square(4);
echo "Die Fläche des Quadrats beträgt: " . $square->getArea() . "
";
$square->draw();
    

Statische Eigenschaften und Methoden

Statische Eigenschaften

Statische Eigenschaften sind Eigenschaften einer Klasse, die mit dem static Schlüsselwort deklariert werden. Sie gehören zur Klasse selbst und nicht zu den Instanzen der Klasse. Daher können sie ohne Erstellung einer Klasseninstanz verwendet werden. Statische Eigenschaften sind nützlich, wenn man einen gemeinsamen Wert über alle Instanzen einer Klasse hinweg teilen möchte.

Statische Methoden

Statische Methoden sind Methoden, die mit dem static Schlüsselwort deklariert werden. Sie können direkt über die Klasse aufgerufen werden, ohne eine Instanz der Klasse zu erstellen. Statische Methoden eignen sich gut für Hilfsfunktionen, die nicht auf Instanzvariablen zugreifen müssen.

Beispiel: Statische Eigenschaften und Methoden

class MathUtil {
    public static $pi = 3.14159;

    public static function square($number) {
        return $number * $number;
    }
}

echo "Der Wert von Pi ist: " . MathUtil::$pi . "
";
echo "Das Quadrat von 4 ist: " . MathUtil::square(4) . "
";