Implémentation des classes et du polymorphisme avec pHp

Le polymorphisme est la capacité d'une classe abstraite ou d'un objet spécifique à répondre à la même méthode avec son propre comportement. Le polymorphisme spécifie qu'un paramètre ou des objets passés ou attendus peuvent prendre plusieurs formes et avoir un comportement différent avec les mêmes méthodes.
Lorsque nous effectuons une programmation orientée objet avec des polymorphismes, nous devons garder à l'esprit qu'une instance d'une classe ou d'un objet peut être invoquée et qu'elle fonctionnera et se comportera de la même manière quelle que soit la classe à laquelle appartient l'objet. Si nous avons beaucoup de classes et d'objets, nous devons bien structurer les hiérarchies de classes et de classes abstraites. Un autre avantage est de pouvoir déclarer ou programmer des méthodes avec le même nom même si leur fonctionnalité est complètement différente, puisque nous nous référons à l'instance de la classe.
A titre d'exemple, supposons une classe abstraite qui représente le nombre de véhicules, qui partagent comme données en commun le niveau de carburant, la marque et le modèle du véhicule.
Les propriétés de la classe Véhicules seront alors du carburant qui contiendra le nombre de litres qui sont chargés dans le véhicule et marque et modèle véhicule.

Ci-dessous, nous définissons les méthodes communes pour tous les véhicules qui chargeront du carburant et indiquons combien il en reste au fur et à mesure qu'il est utilisé, de plus nous devons pouvoir attribuer à chaque véhicule une marque et un modèle et pouvoir également consulter sa marque et son modèle . Ensuite, nous définissons les méthodes pour la classe Vehicles.

 carburant = $ carburant; } public function show fuel () {return $ this-> fuel; } fonction publique assignvehicle ($ brand, $ model) {$ this-> brandymodel = $ brand. ' '.$ modèle; } public function showbrandmodel () {return $ this-> markandmodel; }} ?> var13 -> 

Ensuite on va commencer à créer les classes qui héritent des véhicules et elles auront leurs méthodes particulières, par exemple on crée la classe Cars, elle aura la propriété de faire avancer la voiture et à chaque fois qu'elle avancera elle consommera un litre de carburant (pour que l'exercice soit facilement compris)

 class Cars étend Véhicule {fonction publique avance () {// tous les 10 kilomètres consomme un litre $ this-> carburant - = 1; }} // Fin de la classe 

Nous allons maintenant implémenter une classe générale pour le conducteur du véhicule, ici nous prenons en compte qu'un conducteur ou plusieurs peuvent conduire des véhicules différents.
Dans cette classe, nous allons définir un constructeur de type générique ou abstrait

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

On peut donc ensuite manipuler n'importe quel objet qui est passé en paramètre du constructeur, ainsi notre classe aura la possibilité de recevoir un objet en paramètre, c'est du polymorphisme, c'est-à-dire qu'elle peut utiliser des objets complets, par exemple on peut envoyer la classe autos en tant que paramètre et utilisent toutes leurs méthodes.
Nous allons implémenter les exemples en php 5 il est donc important de se souvenir de la portée d'une méthode et des variables, dans la plupart des langages c'est très similaire. Pour affecter ou modifier la portée d'une variable ou d'une propriété, nous devons utiliser le mot réservé correspondant lorsque nous déclarons la variable ou la méthode en fonction de l'accès ou de la portée que nous voulons qu'elle ait :

• privé: indique que la variable ou la méthode n'est accessible que par les méthodes de la classe à laquelle appartient l'objet et non par une autre.
• protégé: indique que la variable ou la méthode est accessible par les méthodes du et également à partir de l'une de ses sous-classes appartenant à cette classe.
• Publique: indique que les variables ou les méthodes sont accessibles à partir de toute autre méthode ou indépendamment de l'endroit où elles appartiennent ou à qui elles appartiennent. Soyez prudent avec les attributs publics car ils pourraient modifier une valeur qui est également utilisée par une autre classe ou une autre méthode.

Ensuite, nous créons la classe Driver, qui aura les méthodes suivantes : charger du carburant, attribuer un véhicule, afficher la marque et le modèle, faire avancer le véhicule et vérifier le carburant restant au fur et à mesure de sa progression.

 véhicule = $ objet; } fonction publique charge de carburant ($ carburant) {$ this-> véhicule-> charge de carburant ($ carburant); } fonction publique assignvehicle ($ make, $ model) {$ this-> vehicle-> assignvehicle ($ make, $ model); } public function brandymodel () {return $ this-> vehicle-> showbrandmodel (); } public function advancevehicle () {$ this-> vehicle-> advance (); } fonction publique carburant restant () {return $ this-> vehicle-> show fuel (); }} ?> var13 -> 

Nous pouvons voir comment dans chaque fonction de la classe Cars nous instancions les méthodes communes de la classe Super Vehicles afin d'attribuer des propriétés ou des méthodes particulières et non communes à tous les véhicules.
Voyons ensuite comment utiliser ces classes et le polymorphisme lui-même.

 attribuer un véhicule ('Ferrari', '550 MARANELLO'). '
'; // Nous montrons le véhicule assigné echo $ ferrari-> brandymodel (). '
'; // Nous chargeons du carburant dans le véhicule en indiquant la quantité en litres echo 'Charge de carburant'. $ Ferrari-> charge de carburant (50). '
'; // Nous montrons la quantité de carburant actuelle echo 'Carburant actuel'. $ Ferrari-> carburant restant (). ' litres
'; echo 'Avance véhicule
'; $ ferrari-> avanceVehicle (); echo $ ferrari-> brandymodel (). ' vous avez '. $ ferrari-> carburant restant ().' litres de carburant
'; // On crée une autre instance avec un autre véhicule, par exemple on peut créer une variable qui est la marque et le brevet $ hondaHB0071 = new Driver (new Autos); echo $ hondaHB0071-> assignvehicle ('Honda', 'ACCORD'). '
'; echo $ hondaHB0071-> makeandmodel (). '
'; echo 'Charge de carburant'. $ hondaHB0071-> charge de carburant (50). '
'; echo 'Carburant actuel'. $ hondaHB0071-> carburant restant (). ' litres
'; echo 'Advance véhicule Honda
'; $ hondaHB0071-> avanceVéhicule (); echo $ hondaHB0071-> makeandmodel (). ' vous avez '.$ hondaHB0071-> carburant restant ().' litres de carburant
'; ?> var13 -> 

Voyons ensuite les vrais avantages du polymorphisme et de l'héritage de classe, ajoutons la classe à

 // Classe de motos Motos s'étend Véhicule {fonction publique avance () {// tous les 10 kilomètres consomme un litre $ this-> carburant - = 1; }} $ moto = nouveau pilote (nouvelles motos); echo $ moto-> assigner un véhicule ('Yamaha', 'YBR 125'). '
'; echo $ moto-> makeymodel (). '
'; echo 'Charge de carburant'. $ moto-> charge de carburant (10). '
'; echo 'Carburant actuel'. $ moto-> carburant restant (). ' litres
'; echo 'Avance véhicule moto
'; $ moto-> avanceVéhicule (); echo $ moto-> makeymodel (). ' vous avez laissé '. $ moto-> fuelremaining ().' litres de carburant
'; ?> var13 -> 

Ici, nous pouvons voir comment nous avons pu implémenter une extension de la même classe par polymorphisme réutiliser la classe parente Véhicules et les méthodes et propriétés qu'une voiture et une moto ont en commun, bien qu'elles se comportent différemment, dans ce cas, nous pouvons voir que la capacité de carburant est différente.
Nous pourrions intégrer les calculs nécessaires pour rendre la consommation de carburant plus réelle selon le véhicule.
L'avantage d'utiliser le polymorphisme est que l'on peut créer des méthodes similaires mais avec des paramètres différents par exemple.
Mise en place d'interfaces avec pHp
Les interfaces sont des déclarations qui définissent quelles méthodes peuvent être implémentées par une classe, cachant comment ces méthodes sont utilisées ou gérées. Les méthodes qui sont déclarées dans une interface doivent être publiques, afin d'être accessibles par les classes que nous implémentons. Ils permettent une encapsulation de classes et de polymorphismes.
Pour implémenter une interface avec php, le mot-clé implements est utilisé. Si nous avons plusieurs méthodes déclarées dans une interface, elles doivent être implémentées dans une classe. Les classes peuvent implémenter plus d'une interface pour pouvoir accéder à différentes méthodes afin que nous puissions avoir différentes fonctionnalités dans différentes classes.
Nous voyons un exemple d'interfaces

Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif