Archives par mot-clé : POO

L’opérateur cons et les mots-clés self et parent

Publié dans PHP objet | Laisser un commentaire

Hé, je n’écris pas trop en ce moment. La fin d’année scolaire passe par là : les rendus de projets et les examens fusent de partout. Mais j’arrive quand même à passer un petit peu de temps à découvrir le PHP objet.

L’opérateur cons

L’opérateur cons ou double points (on l’appelle cons en CamL, alors pourquoi pas en PHP ?) permet de résoudre un attribut ou une méthode. On le précède d’un mot clé et on le fait suivre d’un nom d’attribut ou de méthode. On va le voir tout de suite en application…

Les mots-clés self et parent

Self permet de résoudre un attribut ou une méthode de sa propre classe, et parent ceux de sa classe parente, une dont on hérite.

Place aux exemples

<?php
class Blog
{
  var $nom;
  var $description;
  var $categorie = 'Billet';

  function __construct($nom, $description)
  {
    $this->nom = $nom;
    $this->description = $description;
  }

  function ecrire_un_billet()
  {
    echo 'Ceci est un billet de blog<br />';
  }

  function modifier_un_billet()
  {
    echo 'Je modifie un billet de blog<br />';
  }
}

class BlogPhoto extends Blog
{
  var $categorie = 'Photo';

  function ecrire_un_billet()
  {
    echo 'Ceci est un billet de blog photo<br />';
  }

  function test_self()
  {
    self::ecrire_un_billet();
    self::modifier_un_billet();
    echo self::$this->nom.'<br />';
    echo self::$this->categorie.'<br />';
  }

  function test_parent()
  {
    parent::ecrire_un_billet();
    parent::modifier_un_billet();
    echo parent::$this->nom.'<br />';
    echo parent::$this->categorie.'<br />';
  }
}
$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
$blogPhoto = new BlogPhoto('Mon blog photo', 'Des tas de photos partout !');
// Testons les mots-clés :
echo 'Self :<br />';
$blogPhoto->test_self();
echo '<br />Parent :<br />';
$blogPhoto->test_parent();

Comme vous pouvez le voir, le mot-clé parent ne semble pas fonctionner sur un attribut. Je pense que je saisi mal quelque chose. J’ai testé self::nom, ou self::$nom, en mettant mes variables en public ou en static. Bref. Cette histoire de self et de parent semble très simple à première vue mais ça à l’air un tout petit peu plus complexe dans la réalité. Mais la suite de mes lectures me dit que je vais finir par comprendre.

Apparation de la visibilité de méthodes prédéfinies en PHP 5

Publié dans PHP objet | Laisser un commentaire

La programmation orientée objet existe dans PHP depuis sa version 3, son implémentation a été amélioré dans la version 4, mais c’est seulement depuis la récente version 5 que l’on peut réellement parler de PHP objet. J’ai commencé à lire la partie objet du cours de PHP 5 de Developpez.com et c’est très intéressant. Il existe par exemple une méthode prédéfinie nommée __construct() qui sert de constructeur d’une classe. Cela permet de changer le nom d’une class sans changer le constructeur associé.

<?php
class Blog {
  var $nom;
  var $description;
  function __construct($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
}
$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
echo $blogDeBN->nom.'<br />';
echo $blogDeBN->description;

Il existe aussi des mots clés comme private, public, protected qui permettent de définir les droits d’accès à des attributs ou à des méthodes. On les utilise à la place du var ou devant le mot clé function.

  • private : l’attribut ou la méthode ainsi définie ne pourra être utilisée que dans la class parente.
  • protected : l’attribut ou la méthode ainsi définie ne pourra être utilisée que dans la class parente et ses dérivées.
  • public (valeur par défaut) : l’attribut ou la méthode ainsi définie ne pourra être utilisée par n’importe qui.

Pratique pour clarifier du code ! Un autre mot clé est static et il permet de rendre un attribut ou une méthode identique pour tous les objets d’une classe. En somme si je change la valeur d’un attribut ou d’une méthode static dans un objet, alors tous les autres objets de cette class auront la même valeur pour cet attribut ou cette méthode. Il y a aussi une histoire de parent, self, static à utiliser avec l’opérateur double points ::, mais je n’ai pas encore bien assimilé.

Constructeur et notion d’héritage

Publié dans PHP objet | Laisser un commentaire

Continuons avec les bases en nous intéressant au constructeur et à la notion d’héritage.

Constructeur

Dans mon dernier billet, je me suis amusé à remplir mes attributs à la main, pourtant, en utilisant un constructeur, tout serait bien plus simple. Un constructeur est une méthode qui a le même nom que la class. Elle prend en paramètre les attributs que l’on souhaite remplir.

<?php
class Blog {
  var $nom;
  var $description;
  var $url = 'http://url.fr';
  function Blog($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
// On peut afficher les attributs
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Description du blog : '.$blogDeBN->description.'<br />';
echo 'Url du blog : '.$blogDeBN->url.'<br />';
// On utilise les méthodes
$blogDeBN->ajouter_billet();
$blogDeBN->ajouter_categorie(); ?>

Attribut objet

En PHP objet, il est tout à fait possible de créer un attribut qui sera un objet (une instance d’une class), tout comme cet attribut aurait pu être un int, un string, … Il nous faudra donc utiliser deux sélecteurs flêches -> pour accéder aux attributs de cet objet.

<?php
class Categorie {
  var $nom;
  var $description;
  var $sousCat;
  function Categorie($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
}

class Blog {
  var $nom;
  var $description;
  var $categorie;
  var $url;
  function Blog($nom, $description, $categorie) {
    $this->nom = $nom;
    $this->description = $description;
    $this->categorie = $categorie;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

// --- Un attribut peut être un objet
$catCMS = new Categorie('CMS', 'Quelques lignes sur les CMS');
$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.', $catCMS, 'http://30minparjour.la-bnbox.fr');
// On peut afficher les attributs
echo 'Catégorie : '.$catCMS->nom.'<br />';
echo 'Description de la catégorie : '.$catCMS->description.'<br /><br />';
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Description du blog : '.$blogDeBN->description.'<br />';
echo 'Catégorie du blog : '.$blogDeBN->categorie->nom.'<br />';
echo 'Description de la catégorie : '.$blogDeBN->categorie->description.'<br />';
echo 'Url du blog : '.$blogDeBN->url.'<br /><br />';
// --- Un attribut peut aussi être une instance de la même classe que son objet parent
$catDotclear = new Categorie('Dotclear', 'Parlons de Dotclear');
$catCMS->sousCat = $catDotclear;
// On affiche les attributs
echo 'Catégories du blog : '.$blogDeBN->categorie->nom.' / '.$blogDeBN->categorie->sousCat->nom.'<br />';
echo 'Description de la catégorie : '.$catCMS->sousCat->description.'<br />'; ?>

Notion d’héritage

On peut aussi construire des class qui hériteront des attributs et méthodes d’une autre classe. Prenons un exemple. Un blog photo est bien un blog, il a bien un nom, une description, un url, on peut ajouter un billet ou une catégorie. Mais il serait assez pratique de pouvoir préciser aussi le nombre de photos qu’il contient, ou alors une méthode pour ajouter une photo, … tout un tas de choses qu’un blog classique n’a pas besoin. Au lieu de réécrire deux class grandement similaire, on va dire que la class BlogPhoto va hériter de tous les attributs et méthodes de la class Blog grâce au mot clé extends.

<?php
class Blog {
  var $nom;
  var $description;
  var $url;
  function Blog($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

class BlogPhoto extends Blog {
  var $nbDePhoto;
  function ajouter_photo() {
    echo 'J\'ajoute une magnifique photo...';
  }
}

$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
$blogPhoto = new BlogPhoto('Mes photos', '');
$blogPhoto->nbDePhoto = '10';
// On peut afficher les attributs
echo 'Nom du blog de BN : '.$blogDeBN->nom.'<br />';
echo 'Description du blog de BN : '.$blogDeBN->description.'<br />';
echo 'Nb de photos du blog de BN (erreur) : '.$blogDeBN->nbDePhoto.'<br />';
echo 'Nom du blog photo : '.$blogPhoto->nom.'<br />';
echo 'Description du blog Photo : '.$blogPhoto->description.'<br />';
echo 'Nb de photos du blog Photo : '.$blogPhoto->nbDePhoto.'<br />'; $blogPhoto->ajouter_photo(); 

Si je redéfinis un attribut ou une méthode dans ma class BlogPhoto, cet attribut ou cette méthode sera réécris et ce n’est plus celui de la class Blog qui sera utilisé. Bon, fini pour ajourd’hui. Le cours sur Developpez.com a l’air bien complet et plutôt bien expliqué. Par contre, j’ai cru comprendre que PHP 5 avait amené son lot de nouveautés et que du coup mes 2 derniers billets sont peut-être obsolètes. Il existe par exemple un mot clé __construct pour le constructeur. Bref, je vais lire ce cours et je pourrai en dire plus à ce moment là !

Introduction au PHP objet (class, objet, attribut, méthode)

Publié dans PHP objet | Laisser un commentaire

Premier jour sur la programmation orientée objet (POO) en PHP. Nous allons voir ce qu’est un objet et donc détailler toutes ces histoires de class, attribut, méthode et objet. A l’assaut !

Class, attribut et méthode

En PHP, un objet est en fait une instance d’une class. Par exemple, on peut créer une class Blog qui représente les blogs de manière générique en décrivant par exemple le nom d’un blog, sa description rapide… Ce sont ses attributs. Cette class pourrait aussi permettre d’écrire un nouveau billet, ou d’ajouter une catégorie. Ce sont ses méthodes. A partir de là, on va pouvoir instancier cette class Blog afin de définir les objets blogs de Jean-François, blog photos d’Agnés, etc… Si on résume :
* class : objet générique contenant des attributs et des méthodes. Le nom d’une class commence en général par une majuscule. Définie par le mot clef class.
* attribut : variable d’une class. Définie par le mot clef var, const ou rien du tout.
* méthode : fonction d’une class. Définie par le mot clef function.
* objet : instance d’une class. Définie par le mot clef new. Maintenant, nous allons créer une class Blog avec ses différents attributs et méthodes.

<?php
class Blog {
  var $nom;
  var $description;
  var $url;
  const COPYRIGHT = 'Bnbox';
  function ajouter_billet() {
     echo 'Ceci est mon premier billet.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie.<br />';
  }
}

Reste à l’instancier avec le mot clé new pour pouvoir l’utiliser. On accédera aux attributs et aux méthodes à l’aide du sélecteur flêche ->. Toutefois, on ne peut pas accéder aux constantes avec le sélecteur flêche, par contre avec le sélecteur cons ::, pas de problème : MaClass::CONSTANTE. En général, on nomme les constantes tout en majuscule.

<?php
$blogDeBN = new Blog();
// On remplie les attributs
$blogDeBN->nom = '30 minutes par jour';
$blogDeBN->description = '30 minutes par jour au coeur de l\'informatique.';
$blogDeBN->url = 'http://30minparjour.la-bnbox.fr';
// On peut les afficher
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Copyright : '.Blog::COPYRIGHT.'<br />';
// On utilise les méthodes $blogDeBN->ajouter_billet();
$blogDeBN->ajouter_categorie();
// On peut aussi en créer un autre $blog = new Blog();
$blog->nom = 'Un blog'; $blog->ajouter_billet();
$blog->ajouter_categorie();
echo 'Nom du blog : '.$blog->nom.'<br />';
echo 'Copyright : '.Blog::COPYRIGHT.'<br />';
// Mais le nom du blog de BN n'a pas changé
echo 'Nom du blog de BN : '.$blogDeBN->nom.'<br />';

Pour appeler un attribut à l’intérieur d’une méthode, on utilisera $this->attribut, affin de préciser que l’on parle de l’attribut que l’on utilise actuellement. (et non de celui d’un autre objet que l’on aurait pu instancier.

<?php
class Blog {
  var $nom;
  var $description;
  var $url;
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

$blogDeBN = new Blog();
// On remplie les attributs
$blogDeBN->nom = '30 minutes par jour';
$blogDeBN->description = '30 minutes par jour au coeur de l\'informatique.';
$blogDeBN->url = 'http://30minparjour.la-bnbox.fr';
// On peut les afficher
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
// On utilise les méthodes
$blogDeBN->ajouter_billet(); $blogDeBN->ajouter_categorie(); 

Je suis en pleine recherche d’un tutoriel ou d’un livre sur le PHP objet. Pour l’instant j’ai lu l’introduction à la POO sur le tutoriel de PHPCake du Site du Zéro, et je vais voir ce que donne les autres cours que j’ai pu trouver comme celui sur Developpez.com.

PHP et la programmation orientée objet

Publié dans Informations | Laisser un commentaire

Après avoir passé plusieurs jours sur Joomla et un jour sur WordPress, je vais finalement migré vers Dotclear. La communauté Dotclear est certes moins grande que celle de WordPress, de même pour la galerie de thèmes (il faut dire que celle de WordPress est carrément impressionnante !), mais certaines petites choses me font plutôt pencher vers ce CMS pour l’instant. On verra sur le long terme ! (éh puis, si les thèmes de Dotclear ne me plaise pas, j’en ferai un moi même ^^)

Pour l’heure, je vais mettre en stand by l’apprentissage de Joomla et la familiarisation avec d’autres CMS afin de pouvoir me concentrer sur le PHP orienté objet. Depuis la version 5, PHP gère très bien la programmation orienté objet (enfin, c’est ce que j’en ai lu) et savoir programmer de cette manière est à la fois très intéressant, particulièrement demandé par les entreprises ou les professionnels en général, et puis cela me permettra de m’initier à tout un pans de la programmation moderne !
Je finirai la migration Joomla-Dotclear dans les jours à venir, mais pour l’heure : place à l’objet ! PHP time !

Joomla est-il réellement la bonne solution

Publié dans Informations | Laisser un commentaire

J’ai actuellement 3 projets de cours qui se rapprochent de leur version finale. (enfin, en théorie ;-)) Dans les jours qui viennent, je vais donc avoir plus de temps pour trimer des heures dessus, que pour cogiter 30 minutes sur Joomla. Je suis en train de réfléchir actuellement sur le choix de Joomla pour héberger ce blog. Je ne connaissais pas ce CMS auparavant, et maintenant que j’en aperçois les contours, je me rends bien compte que ce n’est pas ce que je recherche pour animer et utiliser quotidiennement un site comme celui-ci. Trop long, trop lourd. J’envisage (peut-être) de mettre en pause l’apprentissage de Joomla quelques temps pour passer à un autre CMS que j’utiliserai pour ce blog. Je reprendrai alors sûrement Joomla plus tard puisqu’il est très demandé par des entreprises, c’est donc un outils à bien connaitre. Enfin, j’avoue que je préfèrerai me pencher sur la programmation orientée objet en PHP, ou sur le framewrok jQuery pour Javascript. Ces deux notions sont aussi très demandés dans le milieu professionnel et cela me parait plus intéressant. Mais bon, on verra ! Tout ceci n’est qu’au stade de la réflexion, et en attendant, je continuerai à bidouiller sur Joomla.