Archives par mot-clé : attribut

Récapitulatif PHP Objet

Publié dans PHP objet | Laisser un commentaire

Logo PHP

Ce billet vient récapituler la série sur PHP Objet que j’ai effectuée entre mai à juillet 2009. Le but est de faire le point sur PHP Objet, sur mes connaissances et sur les publications réalisés à ce sujet sur 30minparjour. Désormais, j’essayerai de faire un tel résumé pour toutes les séries que j’aborderai. C’est long et fastidieux, mais je pense que cela m’est utile pour faire le point. J’espère que cela vous servira aussi.

Résumons quelques points importants

Petit résumé sur les classes

[abstract ]class MaClasse [extends AutreClasse implements Interface]
{
	public|protected|private [static] $maVariable [= valeur];
	public static $etat = 1;
	
	/**
	 * Constructeur
	*/
	public|protected|private function MaClass|__construct()
	{
		// Déclaration des variables et autres
	}
	
	/**
	 * Fonction classique
	*/
	public|protected|private [static final abstract] function maMethode()
	{
		// Action de la fonction maMethode
		$this--->maVariable = 'test';
		self::$etat = 0;
		$this->autreMethode();
		[parent::autreMethode();]
	}
	public function $autreMethode()
	{
		echo 'Hello world!';
	}
}

Au passage, je rappelle qu’une classe peut implémenter plusieurs interfaces, mais ne peut hériter que d’une seule classe.

Petit résumé sur les interfaces

interface Interface [extends AutreInterface]
{
	/**
	 * Fonction classique
	*/
	public function $maMethode();
	/**
	 * Autre fonction classique
	*/
	public function $autreMethode();
}

Petit résumé sur les singletons

class Singleton
{
	/**
	 * Variable static valant null si la classe n'est pas encore instanciée
	 * ou contenant l'instance si la classe est instanciée.
	 * On y accède avec self::$_instance
	*/
	private static $_instance = null;
	
	/**
	 * Constructeur private inaccessible en dehors de la classe
	*/
	private function __construct()
	{
		// On instancie ce qu'il faut
	}
	
	/**
	 * Accessor static, donc accessible sans être instancié, renvoyant 
	 * l'instance, en la créant si besoin
	*/
	public static function getInstance()
	{
		if (self::$_instance == null) {
			self::$_instance = new Singleton();
		}
		return self::$_instance;
	}
}

Quelques méthodes magiques utiles

  • __construct() : Appelée lorsqu’on tente de construire la class
  • __destruct() : Appelée lorsqu’on tente de détruire la class
  • __set() : Déclenchée lors de l’accès en écriture à une propriété de l’objet. Exemple d’utilisation
  • __get() : Déclenchée lors de l’accès en lecture à une propriété de l’objet. Exemple d’utilisation
  • __call() : Déclenchée lors de l’appel d’une méthode inexistante de la classe (appel non static). Exemple d’utilisation
  • __callstatic() : Déclenchée lors de l’appel d’une méthode inexistante de la classe (appel static) : disponible depuis PHP 5.3 et 6.0
  • __isset() : Déclenchée si on applique isset() à une propriété de l’objet
  • __unset() : Déclenchée si on applique unset() à une propriété de l’objet -> différence avec __destruct() ?
  • __sleep() : Exécutée si la fonction serialize() est appliquée à l’objet. Exemple d’utilisation
  • __wakeup() : Exécutée si la fonction unserialize() est appliquée à l’objet. Exemple d’utilisation
  • __toString() : Appelée lorsque l’on essaie d’afficher directement l’objet : echo $object;
  • __clone() : Appelé lorsque l’on essaie de cloner l’objet. Exemple d’utilisation

Conclusion

Je crois qu’on vient de faire un tour vraiment rapide mais plus ou moins complet du PHP Objet. A mon sens, il manque 3 notions à ce résumé (mais on ne peut pas tout résumer) :

  • Les exceptions. Il faudrait que je m’y mette un jour. Heureusement il existe un très bon tutoriel sur « Apprendre PHP » : Les exceptions.
  • Un autre chose plutôt cool qu’aborde « Apprendre PHP » est l’interface Iterator, quoi que je ne vois pas trop l’interêt en PHP, mais je sais combien c’est cool en Java !
  • La copie d’une classe. Je l’ai quand même vraiment pas mal résumé ici : Le clônage n’est pas une référence.

Billets traitant de PHP Objet

J’ai trié et classé toutes les publications que j’ai fait sur ce blog à propos du PHP Objet.

Apprentissage

Application

Trucs et astuces

Documentation et tutoriels

Je vous présente les quelques sites que j’ai fréquemment utilisé pour comprendre le fonctionnement et les finesses de PHP et du PHP orienté objet.

Classes abstraites et finales

Publié dans PHP objet | 2 commentaires

Les notions de classes abstraites et classes finales permettent de sécuriser notre programmation PHP, dans le sens qu’elles permettent d’éviter qu’un programmeur, reprenant notre code, n’en contourne la logique et s’égare ainsi sur une fausse piste.
En effet :

  • Class abstraite : class qui ne peut être instanciée, il est donc OBLIGATOIRE de créer une class héritante de cette class pour s’en servir. Utile lorsque l’on créé une class générique qui ne servira qu’à créer des sous class et non à être instanciée. Une telle class ne contient donc pas de __construct() puisqu’elle n’est pas instanciée. Mot clef : abstract.
  • Class finale : class qui NE PEUT PLUS avoir de sous-class, c’est-à-dire de class héritante. Les méthodes de cette class ne pourront être surchargées (réécrites, redéfinies). Mot clef : final. De la même manière, on peut aussi déclarer des méthodes abstraites et finales.
  • Méthode abstraite : méthode qui doit OBLIGATOIREMENT être surchargée (réécrite, ou redéfinie). Une class contenant une méthode abstraite doit aussi être abstraite. Mot clef : abstract.
  • Méthode finale : méthode qui NE PEUT ÊTRE surchargée (réécrite, redéfinie). Une class finale s’applique sur toutes les méthodes ou attributs de la classe, alors qu’ici on ne touche qu’à une seule méthode. Mot clef : final. Pour bien comprendre ces 2 notions et en saisir mieux l’intérêt voici plusieurs exemples, un pour chaque cas.

Class et méthodes abstraites

 abstract class Site {
	protected $type;
	protected $name;
	public function getType()
	{
		return $this->type;
	}
	public function getName()
	{
		return $this->name;
	}
}
$monSite = new Site();
echo $monSite->getType(); // Erreur : on tente d'instancier une classe abstraite

Continuer la lecture

Quelques méthodes et constantes magiques ou prédéfinies

Publié dans PHP objet | Laisser un commentaire

Attributs ou méthodes qui n’existent pas ?

Avant de faire un petit récapitulatif magique ou déjà défini (mouahaha), voyons une petite notion importante du PHP objet : il est possible de modifier et de lire la valeur d’un attribut qui n’existe pas (ah horreur), par contre, on ne peut utiliser une méthode qui n’existe pas (ah bah ça tombe bien alors !). Je m’explique en codant :

class Chat { }
$unChat = new Chat();
$unChat->couleur = 'noir';
$unChat->etat = 'sorti ses griffes';
echo 'Mon chat '.$unChat->couleur.' a '.$unChat->etat.'.';

Eh oui, ce petit exemple affichera bien : « Mon chat noir a sorti ses griffes . ». C’est horrible, n’est-ce-pas ? Heureusement avec __set() et __get(), on va pouvoir empêcher ce types d’actions et en profiter pour vérifier le type des valeurs que l’on assigne à nos attributs.
Par contre :

class Chat { } 
$unChat = new Chat();
$unChat->etreGentils();

Nous renverra une jolie petite erreur ! (heu, oui, je n’aime pas tellement les chats. Enfin, cela dit, je n’ai rien contre eux non plus) Heureusement la méthode magique __call() va nous permettre de rattraper ce petit bémol. Mais tout cela est très bien expliqué sur Apprendre PHP, alors sans plus tarder voilà une liste des méthodes et des constantes magiques, ainsi que des fonctions prédéfinies avec à chaque fois une explique, ou des exemples tiré du manuel PHP, de tutoriels sur le Web ou de mes propres mot.
Continuer la lecture

Vocabulaire à connaître de la POO

Publié dans PHP objet | 2 commentaires

Voici quelques mots de vocabulaire qu’il peut être utile de connaître pour s’y retrouver en programmation orientée objet. Je complèterai cette liste au fil du temps. (en fonction de mes souvenirs et de mes découvertes)

  • Classe : Permet de définir la structure d’un objet qui pourra ensuite être utilisé plusieurs fois avec des options différentes, et dupliqué à loisir par le biais de classes filles. Mot clef : class
  • Instance : Une classe définie et chargée. Une instance (un objet) est donc utilisable concrètement, alors qu’une classe. Mot clef : new
  • Objet : Instance d’une classe
  • Attribut ou Propriété : Variable d’une classe. Mot clefs : var ou const
  • Méthode : Fonction d’une classe. Mot clefs : function
  • Surcharge ou polymorphisme Ad hoc : Permet de définir des méthodes avec le même nom et ayant des fonctionnalités similaires (ex : afficher(), supprimer()) dans des classes héritant d’une même classe mais n’ayant pas d’autres liens entres elles. On parle ainsi de surcharge d’une méthode lorsque l’on redéfinie une méthode qui avait déjà été définie dans une classe parente. Ex : fonction trier() qui fonctionnera pour trier des livres ou des CD sans que le programmeur se souci du nom de la méthode.
  • Attribut ou méthode magique : Attribut ou méthode commençant généralement par deux underscores (__) , étant apparu dans PHP 5, et ayant des fonctionnalités impossible à coder « à la main » comme par exemple le déclenchement d’une méthode lors de l’instanciation d’une classe ou la suppression d’une instance. Ex : __construct, __clone, __toString
  • Méthode prédéfinie : Méthode déjà définie par PHP. Ex : get_parent_class, class_exists
  • Héritage : Notion permettant qu’une classe (dites fille) hérite des attributs et des méthodes d’une autre classe (dites parente). Mot clef : extends
  • Constructeur : Méthode permettant de créer un objet en instanciant une classe. Mot Clef : __construct($params)
  • Interface : Définie une liste de méthodes que doit contenir les classes qui implémentent cette interface. Mot clef : interface

Utiliser les méthodes et les attributs d’une autre class

Publié dans PHP objet | Laisser un commentaire

Ah, je viens enfin de mieux comprendre à quoi servait l’opérateur cons ::. Dans le précédent billet où j’en parlais je disais qu’il permet de résoudre un attribut ou une méthode, éh bien c’est tout à fait vrai !

  • Pour appeler un attribut ou une méthode d’une class dans cette même class, on utilise $this->methodeOuAttribut.
  • Pour appeler un attribut ou une méthode d’une class lorsqu’on a instancié cette class, on utilise $nomInstance->methodeOuAttribut.
  • Pour appeler un attribut ou une méthode d’une class dans une autre class, on utilise NomDeLaClass::methodeOuAttribut. Les deux class doivent bien sûr se trouver dans le même fichier, ou on peut inclure l’une dans le fichier de l’autre avec include() ou require().

Dans le cas d’un attribut, si l’on tente d’y accéder avec le nom d’une class, cela signifie que notre attribut doit être static, il reste identique pour toutes les instances de cette class.
Prêt pour un petit exemple (débile) ?

<?php
class DitBonjour {
	protected static $fr = 'Coucou le monde !';
	public static $en = 'Hello world!';
	public static $de = 'Guten tag!';
	function saluer()
	{
		return 'Guten tag!'.'<br />';
	}
	function saluer_en_langue($langue)
	{
		return $langue;
	}
	function fr()
	{
		return self::$fr;
	}
	function de()
	{
		return $this->de;
	}
}

class Appeler {
	function dire_bonjour()
	{
		echo DitBonjour::saluer();
	}
	function dire_bonjour_en_langue()
	{
		echo DitBonjour::saluer_en_langue(DitBonjour::fr()).'<br />';
		echo DitBonjour::saluer_en_langue(DitBonjour::$en).'<br />';
		echo DitBonjour::saluer_en_langue(DitBonjour::de()).'<br />';
	}
}

$appel = new Appeler();
$appel->dire_bonjour();
$appel->dire_bonjour_en_langue();

Ceci renverra :

Guten tag!
Coucou le monde !
Hello world!
Notice: Undefined property: Appeler::$de in F:\bn\Web\Test\PHPObjet\test2.php on line 26

Continuer la lecture

La visibilité tu vois…

Publié dans PHP objet | Laisser un commentaire

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

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.