PHP, Klassen und Objekte

Klassen und Objekte in PHP

PHP unterstützt wie Java die objektorientierte Programmierung und verwendet Klassen und Objekte als Kernbausteine. Das Verständnis dieser Konzepte ist für die Beherrschung von PHP unerlässlich. In diesem Leitfaden erfahren Sie alles, was Sie über Klassen und Objekte in PHP wissen müssen.

Eine Klasse definieren

Eine Klasse in PHP ist eine Blaupause zum Erstellen von Objekten. Es definiert die Struktur und das Verhalten der Objekte der Klasse.

Syntax

class ClassName {
    // Properties (Fields)
    // Methods
}

Beispiel

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Objekte erstellen

Objekte sind Instanzen von Klassen. Sie erstellen ein Objekt aus einer Klasse mit dem neuen Schlüsselwort.

Syntax

$objectName = new ClassName();

Beispiel

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Eigenschaften und Methoden

Eigenschaften (auch als Felder bezeichnet) stellen den Zustand eines Objekts dar, während Methoden das Verhalten des Objekts definieren.

Eigenschaften

Eigenschaften sind Variablen, die die Daten eines Objekts enthalten.

Beispiel

class Car {
    public $color;
    public $model;
    public $year;
}

Methoden

Methoden sind innerhalb einer Klasse definierte Funktionen, die das Verhalten der Objekte beschreiben.

Beispiel

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Konstrukteure

Konstruktoren sind spezielle Methoden, die automatisch aufgerufen werden, wenn ein Objekt instanziiert wird. Sie initialisieren das neu erstellte Objekt.

Standardkonstruktor

Wenn kein Konstruktor definiert ist, stellt PHP einen Standardkonstruktor ohne Argumente bereit.

Beispiel

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Parametrisierter Konstruktor

Mit einem parametrisierten Konstruktor können Sie ein Objekt mit bestimmten Werten initialisieren.

Beispiel

class Car {
    public $color;
    public $model;
    public $year;

    // Parameterized constructor
    public function __construct($color, $model, $year) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Verwendung des parametrisierten Konstruktors

class Main {
    public function run() {
        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Konstruktorüberladung

PHP unterstützt das Überladen von Methoden nicht nativ wie Java, aber Sie können es mithilfe optionaler Parameter oder durch manuelles Verarbeiten von Argumenten innerhalb eines einzelnen Konstruktors simulieren.

Beispiel

class Car {
    public $color;
    public $model;
    public $year;

    // Simulating constructor overloading
    public function __construct($color = "Unknown", $model = "Unknown", $year = 0) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Verwendung des simulierten überladenen Konstruktors

class Main {
    public function run() {
        $defaultCar = new Car();
        $defaultCar->displayInfo();

        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Kapselung, Zugriffsmodifikatoren und statische Member in PHP

Verkapselung

Kapselung in PHP ist die Praxis, Daten (Eigenschaften) und Methoden (Funktionen) innerhalb einer Klasse zu bündeln. Es stellt sicher, dass der interne Zustand eines Objekts vor Eingriffen und Missbrauch von außen geschützt ist.

Zugriffsmodifikatoren

Zugriffsmodifikatoren in PHP steuern die Sichtbarkeit und Zugänglichkeit von Eigenschaften, Methoden und Konstruktoren. PHP unterstützt drei Hauptzugriffsmodifikatoren:

• Öffentlich:Von überall aus zugänglich.
• geschützt:Zugriff innerhalb der Klasse, Unterklassen und demselben Paket.
• privat: Nur innerhalb der definierenden Klasse zugänglich.

Beispielverwendung:

class ClassName {
    // Properties (Fields)
    // Methods
}

Statische Mitglieder

Statische Mitglieder in PHP sind mit der Klasse selbst und nicht mit einer bestimmten Instanz verknüpft. Auf sie kann zugegriffen werden, ohne ein Objekt der Klasse zu erstellen.

Statische Eigenschaften:

Statische Eigenschaften werden von allen Instanzen einer Klasse gemeinsam genutzt. Sie werden mit dem Schlüsselwort static deklariert.

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Statische Methoden:

Statische Methoden werden mit dem Schlüsselwort static deklariert. Sie gehören zur Klasse und nicht zu einer Instanz.

$objectName = new ClassName();

Zugriff auf statische Mitglieder:

Auf statische Mitglieder wird über den Klassennamen zugegriffen, nicht über ein Objekt.

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Zugriffsmodifikatoren in PHP

Zugriffsmodifikatoren in PHP steuern die Sichtbarkeit von Klassenmitgliedern, stellen die Kapselung sicher und erzwingen Zugriffsbeschränkungen.

Arten von Zugriffsmodifikatoren

1. öffentlich
2. geschützt
3. privat

1. öffentlich

• Zugriff von:Überall.
• Verwendung: Öffentlich für Mitglieder verwenden, die allgemein zugänglich sein müssen.

class Car {
    public $color;
    public $model;
    public $year;
}

2. geschützt

• Zugriff über: Innerhalb der Klasse und ihrer Unterklassen.
• Verwendung: Verwenden Sie protected für Mitglieder, auf die nur innerhalb der Klassenhierarchie zugegriffen werden sollte.

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

3. privat

• Zugriff von:Nur ​​innerhalb der Klasse.
• Verwendung: Verwenden Sie „private“ für Mitglieder, auf die außerhalb der definierenden Klasse nicht zugegriffen werden soll.

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Nichtzugriffsmodifikatoren in PHP

Nichtzugriffsmodifikatoren in PHP ändern das Verhalten von Klassenmitgliedern, ohne ihre Sichtbarkeit zu beeinträchtigen.

Arten von Nichtzugriffsmodifikatoren

1. statisch
2. endgültig
3. Zusammenfassung

1. statisch

• Verwendung:Deklariert Eigenschaften und Methoden, die zur Klasse und nicht zu einer Instanz gehören.
• Beispiel:

class ClassName {
    // Properties (Fields)
    // Methods
}

2. endgültig

• Verwendung: Verhindert die weitere Änderung von Methoden oder die Vererbung von Klassen.
• Variablen: PHP unterstützt keine endgültigen Variablen.
• Methoden: Endgültige Methoden können nicht überschrieben werden.
• Kurse: Abschlusskurse können nicht verlängert werden.
• Beispiel:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

3. abstrakt

• Verwendung:Deklariert Klassen und Methoden, die unvollständig sind und in Unterklassen implementiert werden müssen.
• Abstrakte Klassen:Kann nicht instanziiert werden.
• Abstrakte Methoden: Ohne Körper deklariert und muss von Unterklassen implementiert werden.
• Beispiel:

$objectName = new ClassName();

Vererbung in PHP und Zugriffsmodifikatoren

Nachlass

Vererbung in PHP ist ein Mechanismus, bei dem eine Klasse (Unterklasse) die Eigenschaften und Methoden einer anderen Klasse (Superklasse) erben kann. Es erleichtert die Wiederverwendung von Code und ermöglicht die Erstellung einer hierarchischen Beziehung zwischen Klassen.

Syntax für die Vererbung

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Beispiel

class Car {
    public $color;
    public $model;
    public $year;
}

In diesem Beispiel:

• Animal ist die Superklasse mit einer Eigenschaft $name und einer Methode eat().
• Dog ist die Unterklasse, die $name und eat() von Animal erbt und ihre eigene Methode bark() hinzufügt.

Zugriffsmodifikatoren in der Vererbung

Zugriffsmodifikatoren in PHP bestimmen die Sichtbarkeit von Klassenmitgliedern in Unterklassen und anderen Teilen des Programms. Sie spielen eine Schlüsselrolle bei der Vererbung.

Zugriffsmodifikatoren für normale Attribute und Methoden

• Öffentlich:Von überall aus zugänglich.
• geschützt:Zugriff innerhalb der Klasse, Unterklassen und innerhalb desselben Pakets.
• privat: Nur innerhalb der Klasse zugänglich, in der es deklariert ist.

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Zugriffsmodifikatoren für statische Attribute und Methoden

Statische Mitglieder in PHP sind mit der Klasse und nicht mit einer bestimmten Instanz verknüpft. Sie folgen den gleichen Zugriffsregeln wie nicht-statische Mitglieder bei der Vererbung.

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Werden statische Methoden vererbt?

Statische Methoden werden in PHP vererbt, können aber nicht im gleichen Sinne wie Instanzmethoden überschrieben werden. Wenn eine Unterklasse eine statische Methode mit demselben Namen definiert, verbirgt sie die statische Methode der übergeordneten Klasse.

class ClassName {
    // Properties (Fields)
    // Methods
}

Zugriffsmodifikatoren für abstrakte Methoden

Abstrakte Methoden in PHP müssen in abstrakten Klassen definiert werden. Die Sichtbarkeit einer abstrakten Methode in der Oberklasse bestimmt ihre Sichtbarkeit in Unterklassen. Unterklassen müssen abstrakte Methoden mit denselben oder weniger restriktiven Zugriffsmodifikatoren implementieren.

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Zugriffsmodifikatoren für endgültige Attribute und Methoden

Finale Methoden in PHP können nicht durch Unterklassen überschrieben werden und finale Klassen können nicht erweitert werden.

• Endgültige Methoden:Verhindern Sie das Überschreiben von Methoden.
• Abschlussklassen: Vererbung verhindern.

$objectName = new ClassName();

Syntax zum Deklarieren von Top-Level-Klassen in PHP

In PHP folgt die Deklaration von Klassen der obersten Ebene (Klassen, die nicht in anderen Klassen verschachtelt sind) einer bestimmten Reihenfolge von Schlüsselwörtern. Die Deklaration kann Zugriffsmodifikatoren, abstrakte oder endgültige Schlüsselwörter und das Klassenschlüsselwort enthalten.

Schlüsselwörter, die verwendet werden können:

1. Zugriffsmodifikator:öffentlich
2. Klassentyp: abstrakt oder endgültig

Befehl:

class ClassName {
    // Properties (Fields)
    // Methods
}

Syntax:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Wichtige Hinweise:

1. PHP geht davon aus, dass „public“ der Standardzugriffsmodifikator ist, wenn keiner angegeben ist.
2. Eine Klasse kann nicht gleichzeitig abstrakt und endgültig sein.
3. geschützte und private Zugriffsmodifikatoren sind für Klassen der obersten Ebene nicht zulässig.

Beispiel:

$objectName = new ClassName();

---

Syntax zum Deklarieren von Attributen in Klassen in PHP

Schlüsselwörter, die verwendet werden können:

1. Zugriffsmodifikatoren: öffentlich, geschützt, privat
2. Statischer Modifikator: statisch
3. Unveränderlicher Modifikator: schreibgeschützt (eingeführt in PHP 8.1)

Befehl:

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Syntax:

class Car {
    public $color;
    public $model;
    public $year;
}

Wichtige Hinweise:

1. Attribute sind standardmäßig öffentlich, wenn kein Zugriffsmodifikator angegeben ist.
2. Statische Attribute gehören zur Klasse und nicht zu Instanzen.
3. Readonly-Attribute können nur einmal initialisiert werden, entweder während der Deklaration oder im Konstruktor (PHP 8.1).

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

Syntax zum Deklarieren von Methoden in Klassen in PHP

Schlüsselwörter, die verwendet werden können:

1. Zugriffsmodifikatoren: öffentlich, geschützt, privat
2. Statischer Modifikator: statisch
3. Endgültiger Modifikator: final
4. Abstrakter Modifikator: abstrakt

Befehl:

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Syntax:

class Car {
    public $color;
    public $model;
    public $year;

    // Parameterized constructor
    public function __construct($color, $model, $year) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Wichtige Hinweise:

1. Wenn kein Zugriffsmodifikator angegeben ist, ist die Methode standardmäßig öffentlich.
2. Statische Methoden gehören zur Klasse, nicht zu Instanzen.
3. Endgültige Methoden können in Unterklassen nicht überschrieben werden.
4. Abstrakte Methoden müssen in einer abstrakten Klasse deklariert werden und dürfen keinen Körper haben.

Beispiel:

class Main {
    public function run() {
        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

Abstrakte Klassen in PHP

Abstrakte Klassen in PHP ähneln ihren Gegenstücken in Java und werden zum Definieren eines Entwurfs für andere Klassen verwendet. Sie enthalten sowohl abstrakte Methoden (Methoden ohne Implementierung) als auch konkrete Methoden (Methoden mit Implementierung). Abstrakte Klassen werden mit dem Schlüsselwort abstract deklariert und können nicht direkt instanziiert werden.

---

1. Einführung in abstrakte Klassen

Eine abstrakte Klasse dient als Basisklasse für abgeleitete Klassen. Es definiert allgemeine Verhaltensweisen für seine Unterklassen und ermöglicht gleichzeitig die Implementierung spezifischer Methoden in diesen Unterklassen.

---

2. Deklarieren einer abstrakten Klasse

Um eine abstrakte Klasse in PHP zu deklarieren, verwenden Sie das Schlüsselwort abstract vor dem Schlüsselwort class.

Beispiel:

class ClassName {
    // Properties (Fields)
    // Methods
}

---

3. Abstrakte Methoden

Abstrakte Methoden werden in der abstrakten Klasse definiert, haben aber keinen Körper. Unterklassen müssen alle abstrakten Methoden implementieren.

Beispiel:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

4. Konkrete Methoden

Konkrete Methoden in einer abstrakten Klasse haben einen Körper und können unverändert von den Unterklassen geerbt oder überschrieben werden.

Beispiel:

$objectName = new ClassName();

---

5. Unterklassen erstellen

Unterklassen einer abstrakten Klasse müssen alle ihre abstrakten Methoden implementieren, es sei denn, die Unterklasse ist auch als abstrakt deklariert.

Beispiel:

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

6. Instanziieren abstrakter Klassen

Abstrakte Klassen können nicht direkt instanziiert werden. Sie müssen eine konkrete Unterklasse verwenden, um eine Instanz zu erstellen.

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;
}

---

7. Konstruktoren in abstrakten Klassen

Abstrakte Klassen können Konstruktoren haben und ihre Konstruktoren werden aufgerufen, wenn eine Unterklasse instanziiert wird.

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

8. Abstrakte Klassen mit Feldern und Methoden

Abstrakte Klassen können Instanzvariablen und konkrete Methoden enthalten und so wiederverwendbare Funktionen für Unterklassen bereitstellen.

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

9. Statische Methoden in abstrakten Klassen

Abstrakte Klassen können statische Methoden enthalten. Statische Methoden gehören zur Klasse und können aufgerufen werden, ohne sie zu instanziieren.

Beispiel:

class ClassName {
    // Properties (Fields)
    // Methods
}

---

Syntax zum Deklarieren abstrakter Klassen in PHP

Schlüsselwörter, die verwendet werden können:

1. abstrakt
2. öffentlich, geschützt, privat (Zugriffsmodifikatoren)

Befehl:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

Beispiele:

Abstrakter Kurs mit abstrakten und konkreten Methoden

$objectName = new ClassName();

Abstrakte Klasse mit Feldern und endgültigen Methoden

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

Wichtige Hinweise:

1. Abstrakte Klassen können nicht direkt instanziiert werden.
2. Abstrakte Methoden müssen durch nicht abstrakte Unterklassen implementiert werden.
3. Unterklassen, die nicht alle abstrakten Methoden implementieren, müssen ebenfalls als abstrakt deklariert werden.
4. Konkrete Methoden in abstrakten Klassen können von Unterklassen optional überschrieben werden.
5. Abstrakte Klassen können Konstruktoren, Eigenschaften und Konstanten haben.
6. Abstrakte Klassen können beliebige Sichtbarkeitsmodifikatoren für ihre Methoden und Eigenschaften verwenden.

Schnittstellen in PHP

Eine Schnittstelle in PHP definiert einen Vertrag für Klassen, die sie implementieren. Es gibt die Methoden an, die eine Klasse implementieren muss, stellt jedoch selbst keine Methodenimplementierungen bereit. Schnittstellen ermöglichen einen flexibleren und modulareren Code, sodass Klassen unabhängig von ihrer Vererbungshierarchie einem gemeinsamen Satz von Methodensignaturen folgen können.

---

1. Einführung in Schnittstellen

Eine Schnittstelle in PHP ähnelt einer abstrakten Klasse, kann jedoch nur Methodensignaturen ohne Implementierung definieren. Eine Klasse, die eine Schnittstelle implementiert, muss die Implementierungen für alle in der Schnittstelle deklarierten Methoden bereitstellen. Eine Klasse kann mehrere Schnittstellen implementieren, wodurch Schnittstellen ein wichtiger Bestandteil der PHP-Unterstützung für die Mehrfachvererbung von Verhalten sind.

---

2. Deklarieren einer Schnittstelle

Um eine Schnittstelle zu deklarieren, verwenden Sie das Schlüsselwort interface. Schnittstellen können nur Methodendeklarationen (keine Methodenkörper), Konstanten und abstrakte Methoden enthalten.

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;
}

---

3. Implementierung einer Schnittstelle

Eine Klasse, die eine Schnittstelle implementiert, muss Implementierungen für alle in der Schnittstelle deklarierten Methoden bereitstellen. Eine Klasse kann mehrere Schnittstellen implementieren und diese durch Kommas trennen.

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

4. Signaturen der Schnittstellenmethode

Methoden in Schnittstellen dürfen keinen Körper haben und müssen öffentlich sein. Wenn eine Klasse eine Schnittstelle implementiert, muss sie diese Methoden genau so implementieren, wie sie in der Schnittstelle deklariert sind, einschließlich der Methodensignatur.

Beispiel:

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

5. Implementierung mehrerer Schnittstellen

Eine Klasse in PHP kann mehrere Schnittstellen implementieren. Dies ermöglicht mehr Flexibilität beim Entwerfen von Systemen, bei denen Klassen unterschiedliche Verträge einhalten können.

Beispiel:

class ClassName {
    // Properties (Fields)
    // Methods
}

---

6. Schnittstellenkonstanten

Schnittstellen können Konstanten enthalten. Diese Konstanten sind automatisch öffentlich und können von jeder Klasse aufgerufen werden, die die Schnittstelle implementiert.

Beispiel:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

7. Schnittstellenvererbung

Eine Schnittstelle kann eine andere Schnittstelle erweitern. Dies bedeutet, dass die untergeordnete Schnittstelle alle Methoden (Signaturen) von der übergeordneten Schnittstelle erbt und auch neue Methoden hinzufügen kann. Eine Klasse, die die untergeordnete Schnittstelle implementiert, muss alle Methoden sowohl der übergeordneten als auch der untergeordneten Schnittstelle implementieren.

Beispiel:

$objectName = new ClassName();

---

8. Statische Methoden in Schnittstellen

Schnittstellen dürfen keine statischen Methoden enthalten. Alle in einer Schnittstelle deklarierten Methoden müssen Instanzmethoden sein. Statische Methoden sind in Schnittstellen nicht zulässig, da Schnittstellen Verträge auf Instanzebene für die implementierenden Klassen definieren.

---

Syntax zum Deklarieren und Implementieren von Schnittstellen in PHP

Schlüsselwörter, die verwendet werden können:

1. Schnittstelle
2. öffentlich

Befehl:

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

Beispiele:

Schnittstelle mit Methodensignaturen

class Car {
    public $color;
    public $model;
    public $year;
}

Schnittstelle mit mehreren Implementierungen

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

Wichtige Hinweise:

1. Schnittstellenmethoden: Methoden in einer Schnittstelle müssen öffentlich sein und dürfen keinen Körper haben.
2. Implementieren mehrerer Schnittstellen: Eine Klasse kann mehrere Schnittstellen implementieren und diese durch Kommas trennen.
3. Zugriffsmodifikatoren: Alle Methoden in einer Schnittstelle sind implizit öffentlich. Zugriffsmodifikatoren wie „private“ oder „protected“ sind nicht zulässig.
4. Schnittstellenkonstanten: Schnittstellen können Konstanten deklarieren, die automatisch öffentlich sind und auf die durch die Implementierung von Klassen zugegriffen werden kann.
5. Schnittstellenvererbung: Eine Schnittstelle kann eine oder mehrere Schnittstellen erweitern und ihre Methodensignaturen kombinieren.
6. Statische Methoden: Schnittstellen können keine statischen Methoden enthalten.
7. Implementieren aller Methoden: Eine Klasse muss alle Methoden implementieren, die durch die von ihr implementierten Schnittstellen definiert werden.

Das obige ist der detaillierte Inhalt vonPHP, Klassen und Objekte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!