Wenn wir eine objektorientierte Programmierung mit Polymorphismen durchführen, müssen wir berücksichtigen, dass wir eine Instanz einer Klasse oder eines Objekts aufrufen können und dass dies unabhängig von der Klasse, zu der das Objekt gehört, funktioniert und sich gleich verhält. Wenn wir viele Klassen und Objekte haben, müssen wir die Hierarchien von Klassen und abstrakten Klassen gut strukturieren. Ein weiterer Vorteil ist, dass Methoden mit demselben Namen deklariert oder programmiert werden können, obwohl ihre Funktionalität völlig unterschiedlich ist, da wir auf die Instanz der Klasse verweisen.
Als Beispiel sei eine abstrakte Klasse angenommen, die die Menge der Fahrzeuge darstellt, die wie einige gemeinsame Daten den Kraftstoffstand, die Marke und das Fahrzeugmodell teilen.
Die Eigenschaften der Fahrzeugklasse sind dann Kraftstoff, der die Menge an Litern enthält, die in das Fahrzeug geladen sind, sowie Marke und Modell des Fahrzeugs.
<? php Klasse Vehiculo { geschützter $ fuel = 0; // Das leere Fahrzeug startet mit null Litern protected $ marcaymodelo = ''; ?>
Im Folgenden definieren wir die gemeinsamen Methoden für alle Fahrzeuge, die betankt werden, und zeigen, wie viel davon noch verbraucht wird. Außerdem müssen wir in der Lage sein, jedem Fahrzeug eine Marke und ein Modell zuzuweisen und die Marke und das Modell zu überprüfen. Als nächstes definieren wir die Methoden für die Klasse Vehicles.
<? öffentliche Funktion Kraftstoffgebühr ($ Kraftstoff) { $ this-> fuel = $ fuel; } öffentliche Funktion mostrarcombustible () { $ this-> fuel zurückgeben; } öffentliches Funktionszuweisungsfahrzeug ($ brand, $ model) { $ this-> marcaymodelo = $ marca. ' $ model; } öffentliche Funktion mostrarmarcaymodelo () { return $ this-> marcaymodelo; } }?>
Dann werden wir anfangen, die Klassen zu erstellen, die von Fahrzeugen erben, und ihre speziellen Methoden haben. Zum Beispiel erstellen wir die Autos-Klasse, die Eigenschaft muss das Auto vorrücken und jedes Mal, wenn sie voranschreitet, wird ein Liter Kraftstoff verbraucht (damit die Übung auf einfache Weise verstanden wird).
Klasse Cars erweitert Vehiculo { öffentliche Funktion zum Weiterkommen () { // alle 10 kilometer verbraucht man einen liter $ this-> fuel - = 1; } } // Klasse beenden
Jetzt werden wir eine allgemeine Klasse für den Fahrer des Fahrzeugs implementieren, wobei wir berücksichtigen, dass ein Fahrer oder mehrere verschiedene Fahrzeuge fahren können.
In dieser Klasse definieren wir einen generischen oder abstrakten Typkonstruktor
Funktion __construct ($ object_parameter) { $ this-> myobject = $ object_parameter }
Wir können dann jedes Objekt manipulieren, das als Parameter des Konstruktors übergeben wird, damit unsere Klasse die Möglichkeit hat, ein Objekt als Parameter zu empfangen. Dies ist der Polymorphismus, dh wir können vollständige Objekte verwenden, zum Beispiel können wir als Parameter die Klasse cars senden und all verwenden seine Methoden.
Wir werden die Beispiele in PHP 5 implementieren, daher ist es wichtig, sich den Umfang einer Methode und die Variablen zu merken, da sie in den meisten Sprachen sehr ähnlich sind. Um den Gültigkeitsbereich einer Variablen oder Eigenschaft zuzuweisen oder zu ändern, müssen wir das reservierte Wort verwenden, das entspricht, wenn wir die Variable oder die Methode entsprechend dem gewünschten Zugriff oder Gültigkeitsbereich 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 einer anderen.
- protected: Gibt an, dass auf die Variable oder Methode von den Methoden der und auch von einer ihrer Unterklassen zugegriffen werden kann, die zu dieser Klasse gehören.
- public: Gibt an, dass auf die Variablen oder Methoden von einer anderen Methode aus zugegriffen werden kann oder unabhängig davon, wo sie sich befinden oder wem sie gehören. Bei öffentlichen Attributen ist Vorsicht geboten, da sie einen Wert ändern können, der auch eine andere Klasse oder Methode verwendet.
Als Nächstes erstellen wir die Fahrerklasse, die die folgenden Methoden zum Aufladen von Kraftstoff, Zuweisen eines Fahrzeugs, Anzeigen einer Marke und eines Modells, Vorrücken eines Fahrzeugs und Überprüfen der Kraftstoffversorgung während des Voranschreitens enthält.
<? Klasse Fahrer { privates $ Fahrzeug; Funktion __construct ($ object) { $ this-> vehicle = $ object; } öffentliche Funktion Kraftstoffgebühr ($ Kraftstoff) { $ this-> vehicle-> fuel cargo ($ fuel); } öffentliches Funktionszuweisungsfahrzeug ($ brand, $ model) { $ this-> vehicle-> assignvehicle ($ brand, $ model); } öffentliche Funktion marcaymodelo () { return $ this-> vehiculo-> mostrarmarcaymodelo (); } öffentliche Funktion avanzarvehiculo () { $ this-> vehicle-> advance (); } öffentliche Funktion inflammiblerestante () { return $ this-> vehiculo-> mostrarcombustible (); } }?>
Wir können sehen, wie wir in jeder Funktion der Autos-Klasse die gemeinsamen Methoden von Superklasse-Fahrzeugen instanziieren, um Eigenschaften oder Methoden zuzuweisen, die speziell sind und nicht allen Fahrzeugen gemeinsam sind.
Nachfolgend sehen wir, wie diese Klassen und der Polymorphismus selbst verwendet werden.
<? // Wir erstellen eine Variable, die Driver instanziiert, und übergeben sie als Parameter an die Autos-Klasse $ ferrari = neuer Fahrer (neue Autos); // Wir ordnen das Fahrzeug und die Marke zu echo $ ferrari-> assignvehicle ('Ferrari', '550 MARANELLO'). '' <br> '; // Wir zeigen das zugeordnete Fahrzeug echo $ ferrari-> marcaymodelo (). '<br>'; // Wir laden Kraftstoff in das Fahrzeug und geben die Menge in Litern an Echo 'Treibstoffladung'. $ Ferrari-> Treibstoffladung (50). '<br>'; // Lassen Sie uns die aktuelle Kraftstoffmenge anzeigen Echo 'Aktueller Kraftstoff'. $ ferrari-> inflammibleresistant (). ' liter <br> <br> '; Echo 'Avanza vehiculo <br>'; $ ferrari-> advanceVehicle (); echo $ ferrari-> marcaymodelo (). ' Sie haben '. $ ferrari-> brennbar ().' Liter Kraftstoff <br> <br> '; // Wir erstellen eine weitere Instanz mit einem anderen Fahrzeug. Wir können beispielsweise eine Variable erstellen, die die Marke und das Patent ist $ hondaHB0071 = neuer Treiber (neue Autos); echo $ hondaHB0071-> assignvehicle ('Honda', 'ACCORD'). '' <br> '; echo $ hondaHB0071-> marcaymodelo (). '<br>'; Echo 'Treibstoffladung'. $ hondaHB0071-> Treibstoffladung (50). '<br>'; echo 'Aktueller Kraftstoff'. $ hondaHB0071-> brennstoffbeständig (). ' liter <br> <br> '; Echo 'Avanza Honda Fahrzeug <br>'; $ hondaHB0071-> advanceVehicle (); echo $ hondaHB0071-> marcaymodelo (). ' Sie haben '. $ hondaHB0071-> inflammibleresistant () verlassen.' Liter Kraftstoff <br> <br> '; ?>
Lassen Sie uns im Folgenden die wahren Vorteile von Polymorphismus und Klassenvererbung sehen. Wir werden die Klasse hinzufügen
// Motorräder Klasse Motorräder erweitert Vehiculo { öffentliche Funktion zum Weiterkommen () { // alle 10 kilometer verbraucht man einen liter $ this-> fuel - = 1; } } $ moto = neuer Fahrer (neue Motorräder); echo $ moto-> assignvehicle ('Yamaha', 'YBR 125'). '<br>'; echo $ moto-> marcaymodelo (). '<br>'; echo 'Treibstoffladung'. $ moto-> Treibstoffladung (10). '<br>'; echo 'Aktueller Kraftstoff'. $ moto-> inflammibleresistant (). ' liter <br> <br> '; Echo 'Avanza moto moto <br>'; $ moto-> advanceVehicle (); echo $ moto-> marcaymodelo (). ' Sie haben '. $ moto-> inflammibleresistant ()' verlassen. Liter Kraftstoff <br> <br> '; ?>
Hier können wir sehen, wie wir eine Erweiterung derselben Klasse durch Polymorphismus implementieren können, indem wir die übergeordnete Klasse Fahrzeuge und die Methoden und Eigenschaften wiederverwenden, die ein Auto und ein Motorrad gemeinsam haben, obwohl sie sich in diesem Fall unterschiedlich verhalten Kraftstoff ist anders.
Wir könnten die notwendigen Berechnungen einbeziehen, um den Kraftstoffverbrauch je nach Fahrzeug realistischer zu machen.
Der Vorteil der Verwendung von Polymorphismus besteht darin, dass wir ähnliche Methoden erstellen können, jedoch beispielsweise mit unterschiedlichen Parametern.
Implementierung von Schnittstellen mit pHp
Schnittstellen sind Anweisungen, die definieren, welche Methoden von einer Klasse implementiert werden können, und verbergen, wie diese Methoden verwendet oder verwaltet werden. Die in einer Schnittstelle deklarierten Methoden müssen öffentlich sein, damit die von uns implementierten Klassen darauf zugreifen können. Sie ermöglichen eine Einkapselung der Klassen und Polymorphismen.
Um eine Schnittstelle mit PHP zu implementieren, wird das reservierte Wort implements verwendet. Wenn in einer Schnittstelle mehrere Methoden deklariert sind, müssen diese in einer Klasse implementiert werden. Klassen können mehr als eine Schnittstelle implementieren, um auf verschiedene Methoden zuzugreifen, sodass wir verschiedene Funktionen in verschiedenen Klassen haben können.
Wir sehen ein Beispiel für Schnittstellen
<? php Schnittstelle zum Weiterkommen { öffentliche Funktion beschleunigen (); } Schnittstellenstopp { öffentliche Funktionsbremse (); } klasse fahrzeuggeräte vorwärts fahren, anhalten { öffentliche Funktion beschleunigen () { // Code zum Beschleunigen des Fahrzeugs } öffentliche Funktion stop () { // Code zum Stoppen des Fahrzeugs } } ?>
