Archives par mot-clé : class

Interface, les Mousquetaires sont toujours de la partie

Publié dans PHP objet | Laisser un commentaire
09 Juin 2009

Je n’ai pas encore bien saisi l’intérêt des Interfaces dans la POO. Si je comprend bien, une interface liste toutes les méthodes que doivent impérativement « connaître » les classes si elles veulent implémenter cette Interface. Pour moi, cela permet de structurer légèrement le code (si on a plusieurs classes qui implémentent une Interface, il suffit d’aller voir cette Interface pour connaitre toutes les méthodes importantes), et … bah franchement, non, je ne vois pas. A voir…
On créé une Interface avec le mot clé interface ! Facile jusqu’ici 🙂 Puis il reste à préciser qu’une classe l’implémente avec le mot clé implements.

<?php
interface Joli
{
  public function design();
  public function autoCompleter();
}

class BlogDeBN implements Joli
{
  public function design()
  {
    echo 'Je suis un joli design !';
  }
  public function autoCompleter()
  {
    // Appel à l'auto-completer de Scriptaculous :D
  }
}

Des Interfaces sont prédéfinies en PHP, et il est possible de les connaitre à l’aide du code suivant :

<?php
print_r(get_declared_interfaces());

Qui affichera :

<?php
Array (
    [0] => Traversable
    [1] => IteratorAggregate
    [2] => Iterator
    [3] => ArrayAccess
    [4] => reflector
    [5] => RecursiveIterator
    [6] => SeekableIterator )

Il existe aussi des class prédéfinies :

<?php
print_r(get_declared_classes());

Qui affichera :

<?php
Array (
    [0] => stdClass
    [1] => __PHP_Incomplete_Class
    [2] => Directory )

Constructeur et notion d’héritage

Publié dans PHP objet | Laisser un commentaire
20 Mai 2009

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
19 Mai 2009

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.