Archives de catégorie : PHP objet

Cette catégorie regroupe tous les articles des 30 minutes que j’ai passé (presque) chaque jour sur le PHP Objet au tout début de « 30 minutes par jour ». Réflexions, découvertes, tests, exemples et projets, voilà ce que vous y trouvez !

La visibilité tu vois…

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

Je viens de découvrir un nouveau tutoriel sur la POO en PHP sur le site Apprendre PHP. Le site est bien joli, et le tutoriel est bien expliqué. L’auteur s’est donné la peine de donner de nombreux exemples, et c’est ce qui rend ce tutoriel encore plus intéressant à mon sens.
Dans un précédent billet, j’avais expliqué l’utilisation des mots clés private, protected et private, mais avec ce tutoriel, je viens d’apprendre que cette notion s’appelle la visibilité d’attributs ou de méthodes.

Petit rappel sur la visibilité

  • public (valeur par défaut) : l’attribut ou la méthode ainsi défini pourra être utilisé par n’importe qui.
  • protected : l’attribut ou la méthode ainsi défini ne pourra être utilisé que dans la class parente et ses dérivées (bref, celles qui en héritent quoi).
  • private : l’attribut ou la méthode ainsi défini ne pourra être utilisé que dans la class parente.

Un petit exemple d’utilisation :

class MaClass {
  public $var1;
  public function fonction()
  {
    echo 'Coucou';
  }
}

Et une petite erreur renvoyé si on utilise un attribut ou une méthode protégée ou privée à mauvaise escient : Fatal error: Cannot access private property NomClass::$attribut in /path/to/Apprendre-php/magic_methods.php on line X.
Continuer la lecture →

Rendre __construct() comptatible PHP 4

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

La méthode magique __construct() est apparue dans PHP5, par conséquent PHP4 (ou inférieur) ne la reconnait pas. Auparavant, au lieu d’utiliser __construct(), on utilisait une méthode qui portait le même nom que la classe elle-même. Donc pour avoir une compatibilité PHP4 et PHP5, on peut utiliser le code suivant :

<?php
class MaClass
{
  var $app;

  function MaClass($app)
  {
    $this->__construct($app);
  }

  function __construct($app)
  {
    $this->app = $app;
  }
}

Ainsi, si on est en PHP5, le __construct() est bien compris et utilisé. Si on est en PHP4 (ou inférieur), on utilise MaClass() qui utilise une nouvelle méthode que l’on définie : __construct().
Alors pourquoi ne pas laisser tomber __construct() et n’utiliser que MaClass()… __construct() c’est l’avenir le présent. Un développeur de la boîte où j’ai effectué un stage m’a appris que si on est en PHP5, ce dernier va sauter sur le __construct() et lira ensuite plus tard le MaClass() (et donc le zappera), on gagne un peu de temps pour une exécution en PHP5. Par conséquent ce bout de code utilise les avantages du PHP5 et est compatible PHP4 (et inférieur) 😀

Le clonage n’est pas une référence

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

Aujourd’hui j’ai fini le cours de PHP 5 sur Developpez.com consacré au PHP objet. Il y a encore quelques trucs que je détaillerai dans les billets des prochains jours, mais en somme, mis à part mon problème avec self et parent, je pense avoir compris l’essentiel. Il se trouve que je suis actuellement en stage et que je vais avoir l’occasion de me confronter au framework maison de la boîte où je travaille, et, ô miracle, c’est un framework objet ! Il a l’air bigrement complet et bien fichu, mais aussi peut-être un petit peu compliqué pour moi… ça va être l’occasion de voir ce que j’ai compris ! Mais bref… parlons un peu de l’instanciation d’une classe et clonage d’objets.

Instanciation d’une classe et destruction d’objets

Lorsqu’on instancie une classe avec le mot clé new, on créé une référence de cette instanciation. Et si on fait une copie de cet objet avec le symbole =, on créé une nouvelle référence vers cette instanciation. Or pour supprimer une instanciation d’une classe, avec la fonction unset(), il faut que toutes les références de cette classe soient supprimées. Pour bien comprendre, reprenons l’exemple de Développez.com. Pour cela, il faut savoir que la méthode magique __destruct() est déclenchée lorsqu’on supprime une instance d’une classe.

<?php
class Blog {
  function __destruct()
  {
    echo 'Je me meurs !';
  }
}
$monBlog = new Blog();
$monAutreBlog = $monBlog;
echo 'Allons soldats, tuons monBlog !';
unset($monBlog);
echo 'Puisqu\'il résiste, éliminons donc son frère !';
unset($monAutreBlog);

Cet exemple affichera :

Allons soldats, tuons monBlog !
Puisqu'il résiste, éliminons donc son frère !
Je me meurs !

Continuer la lecture →

Interfaces : plus utiles qu’il n’y parait

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

C’est en regardant le détails des interfaces prédéfinies sur le Manuel PHP que j’ai mieux compris l’intérêt des Interfaces. Prenons comme exemple l’interface Traversable : elle signifie que les classes l’implémentant doivent pouvoir parcourir des objets avec foreach. Pour cela, il faut que les classes en question implémentent, par exemple, l’interface prédéfinie Iterator qui définit les itérateurs. Ces itérateurs doivent pouvoir utiliser les fonctions rewind (retour arrière), next (au suivant), current (position actuelle), etc… Et le manuel nous montre des exemples d’implémentations de ces interfaces.
En somme, j’ai envie de dire que les interfaces sont aux classes ce que sont les types aux variables en programmation « classique ». Un peu quoi… En structurant sa manière de programmer (en utilisant des types et/ou des interfaces) on diminue le risque d’erreurs ou de bugs, on améliore la lisibilité, la relecture et la réutilisation du code et ça : c’est quand même tout l’enjeu d’un code durable !!!
Ah, il est à noter qu’une interface peut hériter d’une autre. L’interface Iterator hérite de Traversable par exemple. Si on devait créer cette interface, on écrirait :

<?php
interface Iterator extends Traversable
{ }

Même syntaxe qu’avec les classes en fait !
Et une classe peut aussi implémenter plusieurs interfaces, alors pour faciliter l’écriture, il est possible de séparer les interfaces par des virgules :

<?php
class RecursiveCachingIterator extends CachingIterator implements Countable , ArrayAccess , Iterator , Traversable , OuterIterator , RecursiveIterator
{ }

Comme toujours, le Manuel PHP m’aura été d’une grande aide ! Je l’utilise beaucoup pour le procédural (i.e. la programmation non-objet), j’aurai dû y penser plus tôt pour l’objet !

Je me demande s’il est possible de définir une classe qui hérite de plusieurs autres classes en les séparant par des virgules. En théorie oui. Une classe ne peut hériter de plusieurs classes. Bref l’héritage multiple est impossible en PHP, mais l’interfaçage multiple existe. Nuançons cette seconde partie de ma sentence : une classe ne peut pas implémenter deux interfaces partageant des noms de méthodes.

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 )

Une seule et même fonction pour différents systèmes de gestion de base de données

Publié dans PHP objet | 3 commentaires
03 Juin 2009

Je suis depuis longtemps déjà un féru utilisateur de FluxBB (anciennement PunBB), un système de forum bien fichu, valide W3C, très léger et donc configurable à souhait. En ce moment ce projet open source bat un peu de l’aile, mais de nouvelles mises à jours sortent encore assez régulièrement et la nouvelle version (attendue depuis des années) semble de nouveau repartir sur de bonnes bases. Mais bref, je parle de cela car FluxBB gère les bases de données MySQL, PostgreSQL (ou PgSQL) et même SQLite je crois. Pour se faire, au lieu d’avoir un switch ou des if else à chaque requête à effectuer, ils ont créé une class qui regroupe toutes les fonctions utiles (connect, query, fetch_array, …) et dans le code ils y font appelle après avoir instanciée cette class : $db->query, $db->fetch_array. Reste à sélectionner le type de sa base de données dans la partie administration et hop, on change de SGBD sans rien changer au code ! Pratique ! Je n’ai pas encore fini d’apprendre le PHP objet, mais j’avais envi de pratiquer un peu, alors sans regarder ailleurs, j’ai commencé à coder. Et voici une première version. Ma classe oublie surement pas mal de fonctions, et je n’ai pas pu la tester partout, et puis il manque la gestion des erreurs, j’aurai pu ajouter un compteur de requêtes, mais c’est ma première véritable class, alors soyez indulgent ^^

<?php
class Sgbd {
	public $nom;
	public function __construct($nom) {
		$this->nom = $nom;
	}
	public function connect($hote, $port, $nomBdd, $utilisateur, $mdp) {
		switch ($this->nom) {
			case 'pg':
			$requete = 'host='.$hote.' port='.($port == NULL ? '5432' : $port).' dbname='.$nomBdd.' user='.$utilisateur.' password='.$mdp;
			pg_connect($requete);
			break;
			default:
			mysql_connect($hote.($port == NULL ? ':3307' : ':'.$port), $utilisateur, $mdp);
			mysql_select_db($nomBdd);
		}
	}
	public function close() {
		switch ($this->nom) {
			case 'pg':
			pg_close();
			break;
			default:
			mysql_close();
		}
	}
	public function query($requete) {
		switch ($this->nom) {
			case 'pg':
			$result = pg_query($requete);
			break;
			default:
			$result = mysql_query($requete);
		}
		return $result;
	}
	public function fetch_array($result) {
		switch ($this->nom) {
			case 'pg':
			$arr = pg_fetch_array($result);
			break;
			default:
			$arr = mysql_fetch_array($result, MYSQL_BOTH);
		}
		return $arr;
	}
	public function fetch_row($result) {
		switch ($this->nom) {
			case 'pg':
			$row = pg_fetch_row($result);
			break;
			default:
			$row = mysql_fetch_row($result);
		}
		return $row;
	}
	public function num_rows($result) {
		switch ($this->nom) {
			case 'pg':
			$num_rows = pg_num_rows($result);
			break;
			default:
			$num_rows = mysql_num_rows($result);
		}
		return $num_rows;
	}
}
$sgbd = new Sgbd('mysql');
?>

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

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

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

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
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.