Programmation PHP/La programmation orientée objet

Un livre de Wikibooks.

< Programmation PHP

Aller à : Navigation, Rechercher

Programmation PHP

Département Informatique

Plan

Introduction
Installer PHP
Bases du langage
Apprendre par l'exemple
- Leçon n° 1 : Premier programme en php
- Leçon n° 2 : Utilisation de variables
- Leçon n° 3 : Un sommaire simple
- Leçon n° 4 : Interaction avec un formulaire
- Leçon n° 5 : Afficher le résultat d'une requête
- Leçon n° 6 : Modifier une table
- Leçon n° 7 : Faire un livre d'or
- Leçon n° 8 : Faire un mini CMS
- Leçon n° 9 : Faire un mini forum de discussion
- Leçon n° 10 : Parser du xml avec domXml
Apprendre AJAX
- Leçon n° 1 : Un sommaire sous AJAX
- Leçon n° 2 : Mettre à jour périodiquement un cadre
Dossiers
- Introduction
- La programmation orientée objet
- La librairie PEAR DB
- La librairie ADODB
- La librairie FPDF
- La librairie DOM
- Concevoir du code de haute qualité

Modifier ce modèle

Sections

1 La programmation orientée objet

[modifier] La programmation orientée objet

Pré requis : Maîtrise des bases du PHP

Un objet est un format complexe de variable regroupant des variables et des fonctions. La programmation orientée objet s’effectue en deux étapes : la définition des classes, puis leur utilisation. Une fois la classe définie, il sera possible de créer une infinité d’objets du format de la classe définie.

Les fonctions d’une classe sont appelées les méthodes et les variables les propriétés.

[modifier] Définition des classes

Définir une classe adopte la syntaxe suivante :

class nomObjet
{
  var $variable1;
  var $variable2;
  ...


  function maFonction1()
  {
    ...code
  }

  function maFonction2()
  {

  }

}

Il est possible d’attribuer une valeur par défaut. Le code dans la classe est alors var $variable1 = valeur ;

La définition de fonctions dans une classe est identique à celle de n’importe quelle fonction à la différence que lorsqu’elle fait référence à une variable de la classe, $variable doit être $this->variable. De même pour exécuter une fonction de la classe. ex :

class client
{
  var $aDitBonjour = false;


  function direBonjour()
  {
    $this->message("Bonjour");
  }

  function message($message)
  {
    echo $message;
    $this->aDitBonjour = true;
  }

}

[modifier] Utilisation d’un objet

Attention : la classe est la définition d’un format de variable personnalisable. Le code n’est pas exécuté et il est impensable d’introduire le code suivant qui n’aurait aucun sens :

class client
{

   for ($i=0; $i<5; $i++)
   echo "$i\n";

}

Une fois la classe définie, il va falloir créer des variables objet du format de la classe définie. On crée un objet par le code suivant :

$objet = new client();

Il faut bien entendu avoir préalablement définit la classe client. La variable $objet contient donc un objet. Pour accéder à une variable pour lui faire subir des modifications, il suffit d’entrer le code suivant :

$objet->variable1 = "Hello world";

Il est possible de lui faire subir les mêmes opérations qu’à une variable normale. De même pour exécuter une fonction :

$objet->maFonction();

Autant les méthodes une fois définies ne peuvent pas être modifiées, autant il est possible d’ajouter ou de supprimer des variables dans l’objet :

$objet->variable = "valeur"; //definition de variable

unset( $objet->variable ); //supressions

L’objet est unique, de sorte que s’il est enregistré dans une autre variable et qu’une modification lui est faite, elle sera visible pour les deux variables :

//Le code reprend l'ancien script

$objet = new client();
$objet2 = $objet;
$objet2->direBonjour();
echo $objet->aDitBonjour;

//affiche true

Pour dupliquer une variable, il faut donc entrer le code suivant :

$objet2 = clone $objet;

La nouvelle variable sera différente de l’ancienne mais aura les mêmes valeurs.

Il est également possible d'exécuter la méthode d'un objet sans avoir créé de variable auparavent:

class Message
{
   function direBonjour()
   {
     echo "salut";
   }
}


/* Exécute la méthode */
Message::direBonjour();

[modifier] Les méthodes prédéfinies

Il existe quelques méthodes pré-définies qui s’exécutent à des périodes de la vie de l’objet :

[modifier] Constructeur et destructeur

__construct(): Cette méthode s’exécute lors de la création de l’objet. On entre alors les attributs potentiels de la fonction lors de sa création. Cette méthode est appelée "le constructeur"

__destruct(): Cette méthode s’exécute au contraire au moment de la destruction de la variable. Elle est appelée "le destructeur".

Attention, ces deux méthodes sont précédées de deux underscores. Voici un exemple utilisant les méthodes :

//Definition de la classe

class Humain
{
  public $homme = false;
  public $femme = false;

  function __construct($type)
  {
    if ($type=="homme")
      $this->homme=true;
    if ($type=="femme")
      $this->femme=true;
  }

  function extremeOnction()
  {
     echo 'Amen';
  }
 

  function __destruct()
  {
    $this->extremeOnction();
  }

}


//C'est un garçon !
$homme = new Humain("homme");

if ($homme->homme)
{
  echo "C'est un homme";
}
elseif ($homme->femme)
{
  echo "C'est une femme";
}

//mort de l'homme
unset($homme);


/*
La sortie sera

C'est un homme
Amen

*/

Sous php4, le constructeur avait pour nom celui de la classe. Sous php5, si la fonction __construct() n’est pas trouvée, l’interprêteur cherchera une méthode du même nom que la classe.

[modifier] Copie en profondeur

Il existe une méthode qui s’exécute lors d’une duplication de l’objet. Son nom est __clone() ;

[modifier] Magic function get, set, __call

Ces méthodes permettent de rendre dynamique l'utilisation de la classe

[modifier] __get

Déclaration:

function __get($name) {
// contenu
}

Cette méthode a pour vocation de retourner une donnée dépendant du contenu de la variable $name. A vous de lui faire executer ce que vous voulez. Important: le contenu de la variable $name ne sera pas prioritaire sur le nom d'une variable interne à la classe.
Explication


class test {
public $a;
private $b;

function __construct($a,$b) {
  $this->a=$a;
  $this->b=$b;
}

function __get($name) {
  echo "On a appelé __get(\$$name)";
}

}

// utilisation
$var=new test(5,10);

echo $var->a; // affiche: 5

echo $var->b; // erreur!! b est privée et ne peut donc pas être accédée. Ce n'est pas __get qui est appelé mais l'accès à la variable en direct

echo $var->__get('a'); // affiche: "On a appelé __get($a)"

On voit ici que PHP va, en priorité, chercher de retourner une variable interne. Attention donc si celle ci est privée. Une méthode pour qu'il n'y ait pas de confusion: preceder les variables privée d'un '_'. Dans la méthode __get faire ceci:

function __get($name) {
  $temp='_'.$name;
  return $this->$temp;
}

[modifier] __set

Déclaration:

function __set($name,$value) {
// contenu
}

Cette méthode a pour vocation de modifier une variable (quelle variable: $name) par une nouvelle valeur (laquelle: $value).
En repartant de l'exemple ci-dessus, il est alors possible de l'utiliser en faisant tout simplement:

<pre>

class test {
  private $_a;
  private $_b;
  function __construct($a,$b) {
    $this->_a=$a;
    $this->_b=$b;
  }
  function __get($name) {
    $temp='_'.$name;
    return $this->$temp;
  }
  function __set($name,$value) {
    $temp='_'.$name;
    $this->$temp=$value;
  }
}

$var=new test(5,10);
$var->a=6; // appelle __set('a',6)
echo $var->a; // appelle __get('a')

[modifier] Héritage

Il est possible de faire hériter une classe des propriétés et méthodes d’une autre classe. Ex :

class parent
{
  var $varParent;

  function functionParent()
  {

  }
}

class enfant extends parent
{
  var $varEnfant;

  function functionEnfant()
  {

  }
}

L’objet enfant bénéficiera des propriétés et des méthodes de la classe parent.

[modifier] Restriction d’accès

Il est possible depuis PHP5 d’empêcher d’accéder à une variable par un autre biais que celui d’une méthode de l’objet. Il suffit de remplacer var par private lors de la définition de la variable. De même avec une méthode :

class CompteEnBanque
{

  private $argent = 0;

  private function ajouterArgent($valeur)
  {
    $this->argent += $valeur;
  }

  function gagnerArgent($valeur)
  {
    $this->ajouterArgent($valeur);
  }
}


$compte = new CompteEnBanque()

//les actions suivantes sont impossibles:

$compte->argent = 3000;
$compte->ajouterArgent(3000);

//l'action suivante est possible

$compte->gagnerArgent(3000);

En effet, il faut gagner de l’argent avant d’en ajouter à la banque (quoique...)

Attention : ce code retournera un message d’erreur si il est exécuté sous PHP5 ou une version ultérieure

[modifier] La gestion des erreurs

Une classe de gestion des erreurs nommée Exception est gracieusement mise à votre disposition par l’interpréteur php. Voici un exemple d’utilisation. Attention, elle n'est disponible qu'à partir de PHP5.

class Humain
{
  var $age;

  function __construct($combien)
  {
    $this->age = $combien;
   
    try
    {
      if ($this->age<0)
      throw new Exception('Un peu jeune')
      if ($this->age>200)
      throw new Exception('Un peu vieux')
    }
    catch (Exception $e)
    {
      echo $e->getMessage();
      exit();
    }
  }

}

//Retournera un message d'erreur
$humain = new Humain(700);
$humain = new Humain(-3);

//Sans erreur
$humain = new Humain(16);

[modifier] Quelques fonctions intégrées

Voici quelques fonctions en relation avec la programmation orientée objet qui peuvent vous être utiles.

- class_exists( string )

Vérifie qu’une classe existe. Renvoie une valeur booleenne. ex :

if( class_exists('myClass'))
$var = new myClass();

- get_class_methods( class )

Retourne les méthodes d’une classe sous forme de tableau. ex :

$maClasse = new Classe();
$methods = get_class_methods( $maClasse );
print_r($methods);

- get_class_vars( class )

Retourne les variables ainsi que leurs valeurs par défaut sous forme de tableau ex :

$maClasse = new Classe();
$methods = get_class_vars( $maClasse );
print_r($methods);

Récupérée de « http://fr.wikibooks.org/wiki/Programmation_PHP/La_programmation_orient%C3%A9e_objet »

Catégorie : Programmation PHP (livre)

Programmation PHP/La programmation orientée objet

Un livre de Wikibooks.

Sections

[modifier] La programmation orientée objet

[modifier] Définition des classes

[modifier] Utilisation d’un objet

[modifier] Les méthodes prédéfinies

[modifier] Constructeur et destructeur

[modifier] Copie en profondeur

[modifier] Magic function get, set, __call

[modifier] __get

[modifier] __set

[modifier] Héritage

[modifier] Restriction d’accès

[modifier] La gestion des erreurs

[modifier] Quelques fonctions intégrées

Affichages

Outils personnels

Navigation

Site

Rechercher

Boîte à outils

Programmation PHP/La programmation orientée objet

Un livre de Wikibooks.

Sections

[modifier] La programmation orientée objet

[modifier] Définition des classes

[modifier] Utilisation d’un objet

[modifier] Les méthodes prédéfinies

[modifier] Constructeur et destructeur

[modifier] Copie en profondeur

[modifier] Magic function __get, __set, __call

[modifier] __get

[modifier] __set

[modifier] Héritage

[modifier] Restriction d’accès

[modifier] La gestion des erreurs

[modifier] Quelques fonctions intégrées

Affichages

Outils personnels

Navigation

Site

Rechercher

Boîte à outils

[modifier] Magic function get, set, __call