Implementieren von Klassen und Polymorphismus mit pHp

Polymorphismus ist die Fähigkeit einer abstrakten Klasse oder eines bestimmten Objekts, auf dieselbe Methode mit eigenem Verhalten zu reagieren. Polymorphismus gibt an, dass ein übergebener oder erwarteter Parameter oder Objekte mehrere Formen annehmen und sich mit denselben Methoden unterschiedlich verhalten können.
Bei der objektorientierten Programmierung mit Polymorphismen müssen wir bedenken, dass eine Instanz einer Klasse oder eines Objekts aufgerufen werden kann und unabhängig von der Klasse, zu der das Objekt gehört, gleich funktioniert und sich verhält. Wenn wir viele Klassen und Objekte haben, müssen wir die Hierarchien von Klassen und abstrakten Klassen gut strukturieren. Ein weiterer Vorteil besteht darin, Methoden mit gleichem Namen deklarieren oder programmieren zu können, obwohl ihre Funktionalität völlig unterschiedlich ist, da wir uns auf die Instanz der Klasse beziehen.
Nehmen wir als Beispiel eine abstrakte Klasse an, die die Anzahl der Fahrzeuge darstellt, die als einige Daten den Kraftstoffstand, die Marke und das Fahrzeugmodell gemeinsam haben.
Die Eigenschaften der Fahrzeugklasse sind dann Kraftstoff, der die Anzahl der Liter enthält, die in das Fahrzeug geladen werden, und Marke und Modell Fahrzeug.

Im Folgenden definieren wir die gemeinsamen Methoden für alle Fahrzeuge, die Kraftstoff laden und zeigen, wie viel beim Verbrauch noch übrig ist . Als nächstes definieren wir die Methoden für die Vehicles-Klasse.

 Treibstoff = $ Treibstoff; } öffentliche Funktion show fuel () {return $ this-> fuel; } öffentliche Funktion Assignvehicle ($ brand, $ model) {$ this-> brandymodel = $ brand. ' '. $-Modell; } öffentliche Funktion showbrandmodel () {return $ this-> markandmodel; }}?> var13 -> 

Dann werden wir beginnen, die Klassen zu erstellen, die von Fahrzeugen erben, und sie haben ihre besonderen Methoden, zum Beispiel erstellen wir die Klasse Autos, die die Eigenschaft hat, das Auto voranzutreiben und jedes Mal, wenn es vorwärts fährt, wird ein Liter Kraftstoff verbraucht (damit die Übung leicht verständlich ist)

 Klasse Autos erweitert Fahrzeug {öffentliche Funktion Advance() {// alle 10 Kilometer verbraucht einen Liter $ this-> Fuel - = 1; }} // Klasse beenden 

Nun werden wir eine allgemeine Klasse für den Fahrer des Fahrzeugs implementieren, dabei berücksichtigen wir, dass ein Fahrer oder mehrere unterschiedliche Fahrzeuge fahren können.
In dieser Klasse definieren wir einen generischen oder abstrakten Typkonstruktor

 function __construct ($ object_parameter) {$ this-> myobject = $ object_parameter} 

So können wir dann jedes Objekt manipulieren, das als Parameter des Konstruktors übergeben wird, sodass unsere Klasse die Fähigkeit hat, ein Objekt als Parameter zu empfangen, das ist Polymorphismus, das heißt, sie kann vollständige Objekte verwenden, zum Beispiel können wir senden die Klasse autos als Parameter und verwenden alle ihre Methoden.
Wir werden die Beispiele in PHP 5 implementieren, daher ist es wichtig, sich den Umfang einer Methode und der Variablen zu merken, in den meisten Sprachen ist es sehr ähnlich. Um den Geltungsbereich einer Variablen oder Eigenschaft zuzuweisen oder zu ändern, müssen wir das entsprechende reservierte Wort verwenden, wenn wir die Variable oder Methode gemäß dem gewünschten Zugriff oder Geltungsbereich deklarieren:

• Privat: gibt an, dass auf die Variable oder Methode nur von den Methoden der Klasse zugegriffen werden kann, zu der das Objekt gehört, und nicht von anderen.
• geschützt: gibt an, dass die Variable oder Methode von den Methoden der und auch von einer ihrer Unterklassen, die zu dieser Klasse gehört, zugänglich ist.
• öffentlich: gibt an, dass Variablen oder Methoden von jeder anderen Methode aus zugänglich sind oder unabhängig davon, wo sie hingehört oder wem sie gehört. Seien Sie vorsichtig mit öffentlichen Attributen, da sie einen Wert ändern können, der auch von einer anderen Klasse oder einer anderen Methode verwendet wird.

Als Nächstes erstellen wir die Driver-Klasse, die über die folgenden Methoden verfügt: Kraftstoff laden, Fahrzeug zuweisen, Marke und Modell anzeigen, Fahrzeug vorrücken und den verbleibenden Kraftstoff im Verlauf überprüfen.

 Fahrzeug = $ Objekt; } öffentliche Funktion Kraftstoffladung ($ Kraftstoff) {$ dieses-> Fahrzeug-> Kraftstoffladung ($ Kraftstoff); } öffentliche Funktion Assignvehicle ($ Marke, $ Modell) {$ this-> Fahrzeug-> Assignvehicle ($ Marke, $ Modell); } öffentliche Funktion brandymodel () {return $ this-> Vehicle-> showbrandmodel (); } öffentliche Funktion Advancevehicle () {$ this-> Vehicle-> Advance (); } öffentliche Funktion verbleibender Kraftstoff () {return $ dieses-> Fahrzeug-> Kraftstoff anzeigen (); }}?> var13 -> 

Wir können sehen, wie wir in jeder Funktion der Cars-Klasse die gemeinsamen Methoden der Super Vehicles-Klasse instanziieren, um Eigenschaften oder Methoden zuzuweisen, die speziell und nicht allen Fahrzeugen gemeinsam sind.
Sehen wir uns als nächstes an, wie diese Klassen und der Polymorphismus selbst verwendet werden.

 Fahrzeug zuordnen ('Ferrari', '550 MARANELLO'). '
'; // Wir zeigen das zugewiesene Fahrzeug echo $ ferrari-> brandymodel() an. '
'; // Wir laden Kraftstoff in das Fahrzeug und geben die Menge in Litern an echo 'Kraftstoffladung'. $ Ferrari-> Kraftstoffladung (50). '
'; // Wir zeigen die aktuelle Treibstoffmenge echo 'Aktueller Treibstoff'. $ Ferrari-> Treibstoffrest (). ' Liter
'; echo 'Fahrzeug vorrücken
'; $ ferrari-> AdvanceVehicle (); echo $ ferrari-> brandymodel(). ' Sie haben '. $ ferrari-> Kraftstoff übrig ().' Liter Kraftstoff
'; // Wir erstellen eine weitere Instanz mit einem anderen Fahrzeug, zum Beispiel können wir eine Variable erstellen, die die Marke und das Patent ist $ hondaHB0071 = new Driver (new Autos); echo $ hondaHB0071-> Fahrzeug zuweisen ('Honda', 'ACCORD'). '
'; echo $ hondaHB0071-> makeandmodel(). '
'; echo 'Kraftstoffladung'. $ hondaHB0071-> Kraftstoffladung (50). '
'; echo 'Aktueller Kraftstoff'. $ hondaHB0071-> verbleibender Kraftstoff (). ' Liter
'; echo 'Advance Honda Fahrzeug
'; $ hondaHB0071-> AdvanceVehicle (); echo $ hondaHB0071-> makeandmodel(). ' Sie haben '. $ hondaHB0071-> verbleibender Kraftstoff ().' Liter Kraftstoff
'; ?> var13 -> 

Sehen wir uns als nächstes die wahren Vorteile von Polymorphismus und Klassenvererbung an, fügen wir die Klasse zu hinzu

 // Motorräder Klasse Motorräder erweitert Fahrzeug {öffentliche Funktion Advance() {// alle 10 Kilometer verbraucht einen Liter $ this-> Fuel - = 1; }} $ moto = neuer Fahrer (neue Motorräder); echo $ moto-> Fahrzeug zuweisen ('Yamaha', 'YBR 125'). '
'; echo $ moto-> makeymodel(). '
'; echo 'Kraftstoffladung'. $ Motorrad-> Kraftstoffladung (10). '
'; echo 'Aktueller Kraftstoff'. $ moto-> Restkraftstoff (). ' Liter
'; echo 'Fortschrittliches Motorradfahrzeug
'; $ moto-> AdvanceVehicle (); echo $ moto-> makeymodel(). ' Sie haben '.$moto->fuelresting().' Liter Kraftstoff
'; ?> var13 -> 

Hier sehen wir wie wir konnten eine Erweiterung derselben Klasse durch Polymorphismus implementieren Wiederverwendung der Elternklasse Fahrzeuge und der Methoden und Eigenschaften, die ein Auto und ein Motorrad gemeinsam haben, obwohl sie sich unterschiedlich verhalten, können wir in diesem Fall sehen, dass die Kraftstoffkapazität unterschiedlich ist.
Wir könnten die notwendigen Berechnungen einbeziehen, um den Kraftstoffverbrauch je nach Fahrzeug realer zu machen.
Der Vorteil der Verwendung von Polymorphismus besteht darin, dass wir ähnliche Methoden erstellen können, jedoch beispielsweise mit anderen Parametern.
Implementierung von Schnittstellen mit pHp
Schnittstellen sind Deklarationen, die definieren, welche Methoden von einer Klasse implementiert werden können, und verbergen, wie diese Methoden verwendet oder verwaltet werden. Die Methoden, die in einer Schnittstelle deklariert werden, müssen öffentlich sein, damit die von uns implementierten Klassen darauf zugreifen können. Sie erlauben eine Kapselung von Klassen und Polymorphismen.
Um eine Schnittstelle mit PHP zu implementieren, wird das Schlüsselwort implements verwendet. Wenn wir mehrere Methoden in einem Interface deklariert haben, müssen sie in einer Klasse implementiert werden. Klassen können mehr als eine Schnittstelle implementieren, um auf verschiedene Methoden zugreifen zu können, sodass wir in verschiedenen Klassen unterschiedliche Funktionalitäten haben können.
Wir sehen ein Beispiel für Schnittstellen

Hat dir dieses Tutorial gefallen und geholfen?Sie können den Autor belohnen, indem Sie diesen Knopf drücken, um ihm einen positiven Punkt zu geben