Créée le, 19/06/2015

 Mise à jour le, 12/05/2019

Visiteurs N°  




Accueil
Nouveau Blog Nouveautés Moteur de Recherche Votre Caddie Pour Vos Achats Votre Espace Membre Vos Signets et Vos Jeux Préférés Page de Bienvenue Statique Site en Français Site en Anglais
Sommaires
Électronique Fondamentale Technologie Fondamentale Testez vos Connaissances Électronique Théorique Digitale Électronique Pratique Digitale Lexique Électronique Numérique Data book TTL Data book CMOS Dépannage TVC Mathématique
Micro-ordinateurs
Théorique des Micro-ordinateurs Testez vos Connaissances Pratique des Micro-ordinateurs Glossaires sur les Ordinateurs
Physique
La lumière Champ d'action Rayonnement Électromagnétique
Technologies
Classification des Résistances Identification des Résistances Classification des Condensateurs Identification des Condensateurs
Formulaires Mathématiques
Géométrie Physique 1. - Électronique 1. 2. - Électronique 1. 3. - Électrotechnique 1. 4. - Électromagnétisme
Accès à tous nos Produits
E. T. F. - Tome I - 257 Pages E. T. F. - Tome II - 451 Pages E. T. F. - Tome III - 611 Pages E. T. D. - Tome I - 610 Pages N. B. M. - Tome I - 201 Pages E. T. M. - Tome I - 554 Pages Business à Domicile Ouvrages 34 pages gratuits Nos E-books Logiciel Géométrie Logiciel Composants Électroniques
Aperçu de tous nos Produits
E. T. F. - Tome I - 257 Pages E. T. F. - Tome II - 451 Pages E. T. F. - Tome III - 611 Pages E. T. D. - Tome I - 610 Pages E. T. M. - Tome I - 554 Pages Logiciel Géométrie Logiciel Composants Électroniques
Nos Leçons aux Formats PDF
Électronique Fondamentale Technologie Fondamentale Électronique Théorique Digitale Électronique Pratique Digitale Théorique des Micro-ordinateurs Mathématiques
Informatique
Dépannage Win98 et WinXP et autres Dépannage PC Glossaire HTML et Programmes PHP et Programmes JavaScript (en cours de travaux) Création de plusieurs Sites
Forums
Forum Électronique et Infos Forum Électronique et Poésie
Divers et autres
Formulaire des pages perso News XML Statistiques CountUs Éditeur JavaScript Nos Partenaires et nos Liens Utiles Gestionnaire de Partenariat Nos Partenaires MyCircle Sondages 1er Livre d'Or 2ème livre d'Or

Signets :
  Leçons suivantes        Leçons précédentes     Bas de page
  Cliquez ici pour la leçon suivante ou dans le sommaire prévu à cet effet


Programmation orientée objets (1ère partie) :



Polymorphisme :

Un langage de programmation orienté objets doit supporter le polymorphisme, en ce sens que différentes classes doivent pouvoir présenter des comportements différents pour la même opération. Par exemple, supposez que nous ayons défini une classe voiture et une classe bicyclette. Ces deux classes peuvent avoir des opérations déplacement différentes. Dans l'univers des objets réels, cette différentiation pose rarement problème. Il est peu probable, en effet, qu'une bicyclette soit confondue avec une voiture, et démarrée avec une opération déplacement de voiture au lieu d'une opération déplacement de bicyclette. Par contre, un langage de programmation ne possède pas le sens commun du monde réel : il doit par conséquent supporter le polymorphisme pour qu'il soit possible de distinguer l'opération déplacement appropriée à un objet particulier.

Le polymorphisme est plus une caractéristique des comportements que des objets eux-mêmes. En PHP, les fonctions membres d'une classe peuvent être polymorphiques. Les verbes des langages naturels sont un peu l'équivalent dans le monde réel des fonctions membres d'une classe. Considérez la manière dont peut être utilisée une bicyclette dans la vie réelle. Vous pouvez la nettoyer, la déplacer, la démonter, la réparer, ou la peindre, entre autres choses.

Les verbes de la dernière phrase décrivent des actions génériques, parce que le type d'objet auquel ils peuvent être appliqués n'est pas spécifié (ce type d'abstraction concernant les objets et les actions est du reste, une des caractéristiques distinctives de l'intelligence humaine).

Par exemple, le déplacement d'une bicyclette exige des actions complètement différentes de celles qui sont requises pour déplacer une voiture, même si les concepts sont similaires. Le verbe "déplacer" peut être associé à un ensemble particulier d'actions, seulement après que l'objet auquel s'applique le verbe a été défini.

Héritage :

Le concept d'héritage permet de créer une relation hiérarchique entre les classes, au moyen de sous-classes. Une sous-classe hérite des attributs et des opérations de sa super-classe. Par exemple, les voitures et les bicyclettes ont des points commun. Nous pourrions définir une classe véhicule, contenant des attributs tels que la couleur et des opérations telles que le déplacement, qui sont communs à tous les véhicules. Il suffirait ensuite de laisser les classes voiture et bicyclette hériter de la classe véhicule.

Grâce au concept d'héritage, nous pouvons élaborer et enrichir le jeu de classes existantes. A partir d'une simple classe de base, des classes plus complexes et plus spécialisées peuvent être créées, au fur et à mesure des besoins. Cette approche rend le code plus réutilisable, et constitue un des atouts indéniables de la programmation orientée objets.

Création de classes, d'attributs et d'opérations en PHP :

Jusqu'ici, la description que nous avons donnée des classes est plutôt abstraite. Plus concrètement, en PHP, la création d'une classe s'effectue au moyen du mot clé class.

Structure d'une classe :

La définition minimale d'une classe se formule de la manière suivante :

    class nom_de_la_classe

       {

       }

Pour qu'une classe ait une quelconque utilité, elle doit être dotée d'attributs et d'opérations. Pour créer des attributs, il faut déclarer des variables au sein d'une définition de classe, en spécifiant le mot clé var. Le code qui suit crée une classe appelée nom_de_la_classe, dotée des deux attributs $atrribute_1 et $attribute_2 :

    class nom_de_la_classe

       {

          var $attribute_1 ;

          var $attribute_2 ;

       }

La création d'opérations dans une classe s'effectue en déclarant des fonctions au sein de la définition de la classe. Le code qui suit crée une classe dénommée nom_de_la_classe, dotée de deux opérations qui n'effectuent rien de particulier. L'opération operation_1() ne prend aucun paramètre, tandis que operation_2() prend deux paramètres.

    class nom_de_la_classe

       {

          function operation_1()

          {

          }

          function operation_2($parametre_1, $parametre_2)

          {

          }

       }

Constructeurs :

La plupart des classes sont dotées d'un type spécial d'opération appelé "constructeur". Un constructeur est invoqué à la création d'un objet, et normalement il effectue aussi des tâches d'initialisation utiles telles que l'affectation de valeurs de départ aux attributs, ou la création d'autres objets nécessaires à l'objet concerné.

Un constructeur se déclare de la même manière que les autres opérations, si ce n'est qu'il porte le même nom que la classe. Bien qu'un constructeur puisse être invoqué manuellement, son rôle principal est d'être invoqué automatiquement à la création d'un objet. Le code qui suit déclare une classe dotée d'un constructeur :

    class nom_de_la_classe

       {

          function nom_de_la_classe($parametre)

          {

          echo "Constructeur appelé avec paramètre $parametre <BR />" ;

          }

       }

Attention :


Retenez bien que PHP ne supporte pas la surchage (overloading) de fonction, et que vous ne pouvez attribuer le même nom à plusieurs fonctions.


Instanciation :

Une fois que nous avons déclaré une classe, nous devons créer un objet (c'est-à-dire un individu particulier qui appartient à la classe) avec lequel nous pourrons ensuite travailler. Cette étape est aussi qualifiée de "création d'une instance", ou " d'instanciation d'une classe ". Un objet se crée en spécifiant le mot clé new. Il faut par ailleurs spécifier la classe dont l'objet créé sera l'instance, et fournir les paramètres éventuellement requis par le constructeur de la classe.

Le code qui suit déclare une classe dénommée nom_de_la_classe et contenant un constructeur, puis crée quatre objets de type nom_de_la_classe :

    class nom_de_la_classe

       {

          function nom_de_la_classe ($parametre)

          {

          echo "Constructeur appel&eacute; avec param&egrave;tre $parametre <BR />" ;

          }

       }

       $a = new nom_de_la_classe ("Ligne 1") ;

       $b = new nom_de_la_classe ("Ligne 2") ;

       $c = new nom_de_la_classe ("Ligne 3") ;

       $d = new nom_de_la_classe ("") ;

Etant donné que le constructeur est invoqué à chaque création d'objet, ce code produit le résultat suivant :

    Constructeur appelé avec paramètre Ligne 1

    Constructeur appelé avec paramètre Ligne 2

    Constructeur appelé avec paramètre Ligne 3

    Constructeur appelé avec paramètre

Utilisation d'attributs de classe :

Au sein d'une classe, vous pouvez accéder à un pointeur spécial appelé $this. Si un attribut de la classe courante porte le nom $attribute, vous pouvez faire référence à cet attribut par $this->attribute soit pour ajuster, soit pour accéder à la variable à partir d'une opération au sein de la classe.

Le code qui suit illustre l'ajustement et l'accès à un attribut au sein d'une classe :

    class nom_de_la_classe

       {

          var $attribute ;

          function operation($parametre)

          {

          $this->attribute = $parametre ;

          echo $this->attribute ;

          }

       }

Avec certains langages de programmation, il est possible de limiter l'accès aux attributs, en délarant ces données privées ou protégées. PHP n'offre pas cette possibilité, si bien que tous les attributs et toutes les opérations sont visibles hors de la classe qui les contient (en somme, ils sont publics).

Nous pouvons effectuer la même tâche que celle implémentée plus haut, mais cette fois à partir de l'extérieur de la classe. Il suffit simplement pour cela d'utiliser une syntaxe légèrement différente :

    class nom_de_la_classe

       {

          var $attribute ;

       }

       $a = new nom_de_la_classe() ;

       $a->attribute = "Nom_de_Famille" ;

          echo $a->attribute ;

Il est toutefois déconseillé d'accéder directement aux attributs depuis l'extérieur de la classe contenant les attributs. L'un des avantages de l'approche orientée objets réside dans le fait que l'encapsulation est encouragée. Bien que le masquage de données ne puisse être mise en œuvre en PHP, vous pouvez bénéficier des mêmes avantages, à condition toutefois d'avoir un peu de volonté.

Au lieu d'accéder directement aux attributs d'une classe, vous pouvez écrire des "fonctions accesseurs" de sorte à effectuer tous vos accès par le biais d'une seule section de code. Une fonction accesseur peut initialement se formuler de la manière suivante :

    class nom_de_la_classe

       {

          var $attribute ;

          function get_attribute() // renvoie simplement la valeur de $attribute

          {

             return $this->attribute ;

          }

          function set_attribute ($nouvelle_valeur) // donne une nouvelle valeur à $attribute

          {

             $this->attribute = $nouvelle_valeur ;

          }

       }

Ce code ci-dessus fournit simplement des fonctions qui permettent d'accéder à l'attribut d'une variable $attribute. La fonction dénommée get_attribute() renvoie simplement la valeur de la variable $attribute, tandis que la fonction set_attribute affecte une nouvelle valeur à $attribute.

A première vue, ce code peut sembler de peu d'intérêt. Sous sa forme présente, c'est probablement vrai, mais les fonctions accesseur ont une excellente raison d'être : elles permettent d'effectuer tous les accès à un attribut particulier via une seule section de code.

Avec un point d'accès unique, des vérifications peuvent être implémentées pour s'assurer que seules des données sensées sont stockées. S'il apparaît ultérieurement que la valeur de la variable $attribute doit être limitée à la plage comprise entre 0 et 100, nous pourrons ajouter quelques lignes de code, et opérer une vérification avant d'autoriser toute modification. La fonction set_attribute() pourrait être modifiée de la sorte :

          function set_attribute ($nouvelle_valeur) // donne une nouvelle valeur à $attribute

          {

             if ($nouvelle_valeur >= 0 && $nouvelle_valeur <= 100)

             $this->attribute = $nouvelle_valeur ;

          }

Ce changement est trivial. Toutefois, si nous n'avions pas disposé d'une fonction accesseur, nous aurions été dans l'obligation de parcourir chaque ligne de code, et de modifier chaque accès à la variable $attribute. De telles corrections répétitives sont non seulement fastidieuses, mais aussi source d'erreur.

Avec un point d'accès unique, nous sommes libre de modifier l'implémentation sous-jacente. Si pour une raison ou pour une autre nous choisissons de modifier la manière dont est stockée la variable $attribute, l'existence de fonctions accesseur nous permettra d'effectuer facilement nos modifications, en ne changeant le code qu'en un seul emplacement.

Au lieu de stocker $attribute sous forme d'une variable, nous pourrions décider d'extraire $attribute d'une base de données lorsque c'est nécessaire, ou bien de calculer une valeur actualisée en cas de besoin, ou bien de déduire la valeur à partir des valeurs d'autres attributs, ou bien encore d'encoder nos données avec un type de données plus petit. Quels que soient les changements à apporter, il suffira de modifier nos fonctions accesseur. Les autres sections du code ne s'en trouveront pas affectées, du moins tant que les fonctions accesseur accepteront ou renverront les données attendues par les autres parties du programme.

Appel d'opérations de classe :

L'appel d'une opération de classe s'implémente de la même manière que celui d'un attribut de classe. Si nous déclarons la classe suivante :

    class nom_de_la_classe

       {

          function operation_1()

          {

          echo "Bonjour" ;

          }

          function operation_2 ($parametre_1, $parametre_2)

          {

          echo "Blablabla" ;

          }

       }

Et que nous créons un objet de type nom_de_la_classe par exemple, comme suit :

       $a = new nom_de_la_classe() ;

Alors nous pouvons appeler des opérations à la manière des autres fonctions : en spécifiant leur nom, suivi des paramètres requis, placés entre parenthèses. Parce que ces opérations appartiennent à un objet, au contraire, des fonctions normales, il est toutefois nécessaire de spécifier les objets auxquels elles appartiennent. Le nom de l'objet se spécifie comme dans le cas des attributs d'un objet :

       $a->operation_1() ;

       $a->operation_2(25, "test") ;

Si les opérations renvoient des valeurs, les données renvoyées peuvent être récupérées de la manière suivante :

       $z = $a->operation_1() ;

       $y = $a->operation_2(25, "test") ;

Implémentation de l'héritage en PHP :

Une classe peut être déclarée comme étant une sous-classe d'une autre classe, en spécifiant le mot clé extends. Le code qui suit crée une classe dénommée C qui hérite d'une classe précédemment définie et portant le nom D :

    class C extends D

       {

          var $attribute_2 ;

          function operation_2()

          {

          }

       }

En admettant que la classe D ait été déclarée comme suit :

    class D

       {

          var $attribute_1 ;

          function operation_1()

          {

          }

       }

Tous les accès aux opérations et attributs d'un des objets listés ci-dessous seraient valides :

       $b = new C() ;

       $b->operation_1() ;

       $b->attribute_1 = 40 ;

       $b->operation_2() ;

       $b->attribute_2 = 40 ;

Notez que, parce que la classe C hérite de la classe D, nous pouvons faire référence à operation_1() et $attribute_1 bien que ceux-ci soient déclarés dans la classe D. En tant que sous-classe de D, la classe C possède la fonctionnalité et les données de la classe D. En sus, C contient un attribut et une opération qui lui sont propres.

L'héritage ne fonctionne qu'à sens unique. La sous-classe (l'enfant) hérite de sa super-classe (son parent), mais le parent n'hérite pas de son enfant. Il s'ensuit que les deux dernières lignes du code ci-dessous sont incorrectes :

       $a = new D() ;

       $a->operation_1() ;

       $a->attribute_1 = 40 ;

       $a->operation_2() ;

       $a->attribute_2 = 40 ;

En effet, la classe D ne possède pas d'opération de la fonction operation_2(), ni d'attribut attribute_2.

Redéfinition de classe (Overriding) :

Nous venons de voir le cas d'une sous-classe dans laquelle sont déclarés de nouveaux attributs et opérations. Il est également permis de redéclarer les mêmes attributs et opérations. Une telle redéclaration, qualifiée de "redéfinition" (overriding), est utile lorsqu'il est nécessaire de donner à un attribut d'une sous-classe une valeur par défaut différente de celle du même attribut dans la super-classe, ou bien encore pour donner à une opération d'une sous classe une fonctionnalité différente de la même opération dans la super-classe.

Par exemple, si nous disposons de la classe D suivante :

    class D

       {

          var $attribute = "valeur par d&eacute;faut" ;

          function operation()

          {

          echo " Quelque chose de bien <BR /> " ;

          echo " La valeur de \$attribute est la $this->attribute <BR /> " ;

          }

       }

Et qu'il nous apparaisse nécessaire de modifier la valeur par défaut de la variable $attribute, et de fournir une nouvelle fonctionnalité de la fonction operation(), nous pourrions créer la classe C, en redéfinissant $attribute et operation() comme suit :

    class C extends D

       {

          var $attribute = "valeur differente" ;

          function operation()

          {

          echo " Quelque chose de bien, sinon, je ne suis pas content ! <BR /> " ;

          echo " La valeur de \$attribute est la $this->attribute <BR /> " ;

          }

       }

Déclarer C n'affecte en rien la définition originale de D. Considérez les deux lignes de code suivantes :

       $a = new D() ;

       $a->operation() ;

Elles créent un objet de type D, et invoquent sa fonction operation(). Le résultat obtenu à l'exécution de ces deux lignes de code ci-dessus est le suivant :

       Quelque chose de bien

       La valeur de $attribute est la valeur par défaut

Pour visualiser l'aperçu, en cliquant ici. [Exemple 1].

Ce résultat montre bien que la création de C n'a pas affecté D. Si nous créons un objet de type C, nous obtiendrons un résultat différent.

Les lignes suivantes :

       $b = new C() ;

       $b->operation() ;

conduisent à :

       Quelque chose de bien, sinon, je ne suis pas content !

       La valeur de $attribute est la valeur différente

Pour visualiser l'aperçu, en cliquant ici. [Exemple 2].

De la même manière que de fournir de nouveaux attributs ou opérations dans une sous-classe n'affecte pas la super-classe, la redéfinition d'attributs ou d'opérations dans une sous-classe n'affecte pas la super-classe.

Une sous-classe hérite de tous les attributs et opérations de sa super-classe, à moins de n'opérer des redéfinitions. Lorsqu'une définition de remplacement est fournie, elle devient prépondérante et remplace la définition d'origine.

Contrairement à d'autres langages OO, PHP ne permet pas de redéfinir une fonction tout en gardant la possibilité d'invoquer la version définie dans le parent.

L'héritage peut être implémenté sur plusieurs niveaux. Par exemple, nous pourrions déclarer une classe dénommée E, qui hérite de C, c'est-à-dire qui hérite à la fois des propriétés de C et de celles du parent de C c'est-à-dire de D. Tout comme pour la classe C, nous serions libres de redéfinir et de remplacer dans la classe E des attributs et opérations des parents.

Nous allons voir maintenant la conception de classes afin de bien comprendre cette leçon.

Conception de classes :

Maintenant que nous avons passé en revue les principaux concepts de l'approche orientée objets, concernant les objets et les classes, et la syntaxe de leur implémentation en PHP, nous pouvons examiner comment concevoir des classes qui soient utiles.

Souvent, les classes implémentées dans le code représentent des classes ou des catégories du monde des objets réels. Dans le cadre d'un développement pour le Web, les classes peuvent notamment être utilisées pour représenter des pages Web, des composants d'interface utilisateur, des cartes d'achat, des gestionnaires d'erreur, des catégories de produits, ou des clients.

Les objets peuvent également représenter des instances spécifiques des classes listées plus haut, comme une page d'accueil, un bouton particulier, ou la carte d'achat délivrée à Jean-Pierre à un moment donné. Jean-Pierre lui-même pourrait d'ailleurs être représenté par un objet de type client. Chaque article acheté par Jean-Pierre peut être représenté sous la forme d'un objet, appartenant à une catégorie ou à une classe.

Dans la leçon précédente, en cliquant ici, nous nous sommes servi de fichiers "include" pour donner une apparence cohérente à toutes les pages du site de l'entreprise fictive C.E.I Consultant Électronique-Informatique. Une version plus élaborée encore de ce site peut être obtenue, en utilisant des classes, et en exploitant le concept puissant d'héritage.

Nous voulons être capable d'ajouter rapidement de nouvelles pages Web au site C.E.I, qui aient la même présentation et un comportement similaire. Nous voulons toutefois être en mesure de modifier ces pages, pour les adapter aux différentes partie du site.

Nous allons créer une classe dénommée Page.inc Cette classe aura essentiellement pour rôle de limiter la quantité de code HTML nécessaire à la création d'une nouvelle page. Elle devra nous permettre de modifier les sections qui changent d'une page à l'autre, tout en générant automatiquement les éléments qui se retrouvent dans toutes les pages.

La classe Page devra fournir un cadre flexible pour la création de nouvelles pages, sans compromettre notre liberté.

Etant donné que les pages vont être générées à partir d'un script, et non pas avec du code HTML statique, nous pouvons implémenter diverses possibilités astucieuses, y compris la fonctionnalité suivante :

  • N'autorisez la modification d'éléments de la page qu'en un emplacement seulement. Par exemple, s'il apparaît nécessaire de changer la déclaration de copyright, ou d'ajouter un bouton supplémentaire, nous ne devrions avoir à apporter la modification qu'en un seul point du code.

  • Disposez d'un contenu par défaut pour la plupart des sections de la page, tout en gardant la possibilité de modifier chaque élément si nécessaire, en ajustant des valeurs personnalisées pour des éléments tels que le titre et les méta-balises

  • Identifier la page en cours d'affichage dans le navigateur, et modifier en conséquence les éléments de navigation (par exemple, un bouton permettant de retourner à la page de démarrage n'a pas lieu d'être sur la page de démarrage).

  • Autoriser le remplacement d'éléments standard dans des pages particulières. Par exemple, pour implémenter différents jeux de boutons dans différentes parties du site, nous devons être en mesure de remplacer les boutons standard.

Nous terminons ainsi ce premier chapitre et nous verrons dans le prochain, l'usage de l'implémentation d'une classe.










Nombre de pages vues, à partir de cette date : le 23 MAI 2019

compteur de visite

    




Envoyez un courrier électronique à Administrateur Web Société pour toute question ou remarque concernant ce site Web. 

Version du site : 10. 5. 14 - Site optimisation 1280 x 1024 pixels - Faculté de Nanterre - Dernière modification : 19 MAI 2019.   

Ce site Web a été Créé le, 14 Mars 1999 et ayant Rénové, en MAI 2019.