====== PHP Programmation Objet ======

  #
  
  
  
  
  
  
  
  
  
  
  
  
  
  #

===== Création d'une classe et création d'objets =====

<sxh php>
<?php
  class MaClasse
  {
    //Une classe est contituée
    
    //D'attribut contenant des valeurs
    private attribut1; //Valeur privée non accessible de l'extérieur
    public attribut2; //Valeur public accessible de l'extérieur (utilisation non recommandée
    
    //De methode contenant des instructions imbriquées dans des fonctions
    public function methode1;
    {
    }
    public function methode2;
    {
    }
  }
  
  //Pour créer les objet $truc1 et $truc2 avec la classe MaClasse
  $truc1 = new MaClasse;
  $truc2 = new MaClasse;
?>

</sxh>

=== Pour résumer ===
  * L'attribut : fait référence à des données
  * La méthode : fait référence à un traitement
  * Une classe est un "moule" qui permet de fabriquer un objet

===== L'accès aux attributs et méthodes =====
Création et utilisation d'une classe :
<sxh php>
  <?php
  class MaClasse
  {
    private $var1;
    public $var2 = 'publique'; //Attribut avec valeur prédéfinie
    private $var3 = 'coucou'; //Attribut avec valeur prédéfinie
    private $var4 = 'hello'; //Attribut avec valeur prédéfinie
    
    public function methode1 ()
    {
      //$this fait référence à : "moi l'objet" je veux ma valeur de $var3
      //Cette instruction affichera "coucou".
      echo $this->var3;
    }
    
    public function methode2 ()
    {
      //"moi l'objet" retourne moi ma valeur de $var4
      //Cette instruction retournera "hello"
      return $this->var4;
    }
  }

  // Création de l'objet "$truc"
  $truc = new MaClasse();
  
  // Exemple d'affichage attribut public dans la classe (non recommandé), les attributs privé ne peuvent pas être affichés.
  // "Moi l'objet $truc" je veux la valeur de mon attribut public $var2: "publique" sera affiché
  echo $truc->var2;
  echo "\n"; //Retour chariot en ligne de commande
  
  // "Moi l'objet $truc" j'exécute ma méthode "methode1": Cette instruction affiche "coucou".
  $truc->methode1();
  echo "\n";
  
  // "Moi l'objet $truc" j'exécute ma méthode "methode2". Rien ne sera affiché puisque return n'affiche rien (return utilisé au lieu de echo)
  $truc->methode2();
 
  // "Moi l'objet $truc" je veux qu'on m'affiche le résultat de la "methode2" que j'exécute : Cette instruction affichera "hello".
  echo $truc->methode2();
  echo "\n";
  ?>
</sxh>

Résultat attendu :
  publique
  coucou
  hello

=== Pour résumer ===
  * **$this** : fait référence à **moi l'objet** je veux (**->**) utiliser cette **methode** : **$this->methode()**
  * La bonne pratique est de n'avoir jamais recours aux attributs "public".
  * Les valeurs des attributs privés peuvent être affichés via des méthodes.


===== Le constructeur =====
Le contructeur est une fonction qui permet de définir les valeurs des attributs que l'on souhaite donner à l'objet que l'on crée
<sxh php>
  <?php
  class MaClasse
  {
    private $var1;
    private $var2;
    
    //Constructeur permettant de définir les valeurs des attribut de l'objet que l'on cré
    public function __construct ($valeur1, $valeur2)
    {
      $this->var1 = $valeur1;
      $this->var2 = $valeur2;
    }
    
    //Cette fonction affichera les valeurs que l'on a défini en créant notre objet
    public function affiche_valeurs()
    {
      echo $this->var1;
      echo "\n";
      echo $this->var2;
      echo "\n";
    }
  }
  $truc = new MaClasse('coucou', 33);
  $truc->affiche_valeurs();
  
  $machin = new MaClasse('hello', 22);
  $machin->affiche_valeurs();
  
  ?>
</sxh>

Résultat attendu :
  coucou
  33
  hello
  22

=== Pour résumer ===
  * Le constructeur est la fonction qui permet de définir les caractéristiques de notre objet.
  * Il ne peut y avoir qu'un seul constructeur dans une classe

===== Interaction entre les objets =====
<sxh php;>
<?php
class MaClasse
{
  private $var1;

  public function __construct ($valeur1)
  {
    $this->var1 = $valeur1;
  }

  public function affiche_ma_valeur1 ()
  {
    echo $this->var1;
    echo "\n";
  }

  public function affiche_la_valeur1 (MaClasse $objet)
  {
    echo $objet->var1;
    echo "\n";
  }
}

// On crée les 2 objets en leur donner les valeurs pour les contruires
$truc1 = new MaClasse (11);
$truc2 = new MaClasse (22);

// On affiche la valeur1 de chaque objet
$truc1->affiche_ma_valeur1();
$truc2->affiche_ma_valeur1();

// On demande à l'objet $truc1 de sortir la valeur1 de l'objet $truc2
$truc1->affiche_la_valeur1($truc2);
?>
</sxh>

Résultat attendu :
  11
  22
  22

===== Constantes =====
Les constantes sont des variables qui appartiennent à la classe et non à l'objet. Ce sont ds variable prédéfinie dans l'objet et qui ne changent pas.

<sxh php>
<?php
class MaClasse
{
  private $var1;


  const VAR_PREDEFINIE1 = 11;
  const VAR_PREDEFINIE2 = 22;

  public function __construct ($valeur1)
  {
    $this->var1 = $valeur1;
  }

  public function affiche_ma_valeur1 ()
  {
    echo $this->var1;
    echo "\n";
  }

  public function affiche_la_valeur1 (MaClasse $objet)
  {
    echo $objet->var1;
    echo "\n";
  }
}

// On crée les 2 objets en leur donner les valeurs prédéfinies par la classe
$truc1 = new MaClasse (MaClasse::VAR_PREDEFINIE1);
$truc2 = new MaClasse (MaClasse::VAR_PREDEFINIE2);

// On affiche la valeur1 de chaque objet
$truc1->affiche_ma_valeur1();
$truc2->affiche_ma_valeur1();

// On demande à l'objet $truc1 de sortir la valeur1 de l'objet $truc2
$truc1->affiche_la_valeur1($truc2);
?>
</sxh>

Résultat attendu :
  11
  22
  22

===== Methode et attributs statiques =====
=== Méthode statique ===

<sxh php>
<?php
class MaClasse
{
  private $var = 'toto';

  public static function good_static()
  {

    echo "Hello\n";
  }
  public static function bad_static()
  {
    //Ceci est un mauvais exemple
    //Dans un context de methode static, $this qui fait référence à un objet qui n'a rien à faire là
    $this->var;
  }
}

// Ci-dessous la methode good_static de la classe est exécutée. Elle ne necessite pas la création d'un objet
MaClasse::good_static();

// Ci-dessous on aura une erreur, puisque le $this défini dans la fonction faite référence à un objet qui n'existe pas
MaClasse::bad_static();

?>
</sxh>

Résultat attendu :
  Hello
  PHP Fatal error:  Using $this when not in object context in /var/www/test-php/test/static.php on line 15

=== Attributs statiques ===

<sxh php>
<?php
class MaClasse
{
  // Déclaration de la variable $compteur
  // Cette variable n'est utilisable par aucun objet
  private static $compteur = 0;

  public function __construct()
  {
    // On instancie la variable $compteur qui appartient à la classe (donc utilisation du mot-clé self)
    // Ici le constructeur incrémente $compteur chaque fois qu'il construit un objet
    self::$compteur++;
  }

  public static function getCompteur() // Méthode statique qui renverra la valeur du compteur
  {
    //Attention de bien définir le $ devant l'attribut
    return self::$compteur;
  }
}

$test1 = new MaClasse;
$test2 = new MaClasse;
$test3 = new MaClasse;

// Ceci permet de savoir combien d'objets ont été construit avec MaClasse
echo MaClasse::getCompteur();
echo "\n";
?>
</sxh>

Résultat attendu :
  3

=== Pour résumer ===
  * L'opérateur **->** : cet opérateur permet d'accéder à un élément de tel objet
  * L'opérateur **::** : cet opérateur permet d'accéder à un élément de telle classe

===== Héritage =====
==== Déclaration de classes filles et portée des éléments ====
<sxh php>
  <?php
  class ClasseMere
  {
    // Un attribut protected est un attributs pouvant être transmise
    // L'utilisation de protected au lieu de private et conseillé pour faciliter l'accès aux classes filles
    protected $attributProtege = 'protégé';
    private $attributPrive = 'privé';
    public $attributPublic = 'publique';
  }

  // Ceci est une classe qui hérite des attributs et méthode de ClasseMere
  // Elle hérite des éléments public ou protected mais pas private
  class ClasseFille extends ClasseMere
  {
    public function get()
    {
      // Ci dessous aucun problème d'accès à l'attribut
      echo $this->attributPublic."\n";
      // Ci dessous aucun problème d'accès tant que l'on est dans une classe fille
      echo $this->attributProtege."\n";
      // La directive ci-dessous génèrera une erreur car la classe fille ne peut pas hériter d'attributs privés
      echo $this->attributPrive."\n";
    }
  }

  // On peut créer autant de classes fille que l'on veut
  class ClasseGarcon extends ClasseMere
  {
  }

  // On peut créer une arborescence de classe (tous les éléments parents public ou protected seront hérétées)
  class ClassePetiteFille extends ClasseFille
  {
  }

  $truc1 = new ClasseMere;
  $truc2 = new ClasseFille;

  // Ici on lance notre méthode get qui affichera une erreur à cause de l'attribut privé qui ne peut pas être affiché ici
  $truc2->get();

  //Ci-dessous il n'y a aucun problème pour accéder à un attribut public en dehors d'une classe
  echo $truc2->attributPublic."\n";
  //La directive ci-dessous génèrera une erreur car la classe fille ne peut pas hériter d'attributs privés
  echo $truc2->attributProtege."\n";

  ?>
</sxh>

==== Réécrire une méthode héritée ====
<sxh php>
  <?php
  class A
  {
    public function test()
    {
      return "test";
    }
  }

  class B extends A
  {
    public function test()
    {
      // Ici on dit que $retour est égale au resultat de la methode "test" de la classe parente
      $retour = parent::test();
      return $retour." avec des chose en plus\n";
    }
  }

  $trucA = new A;
  $trucB = new B;

  echo $trucA->test();
  echo "\n";
  echo $trucB->test();
  ?>
</sxh>

Resultat attendu :
  test
  test avec des chose en plus

==== Imposer des contraintes ====
Restreindre l'utilisation d'une classe qu'aux classes filles.
<sxh php>
  <?php
  abstract class ClasseMere
  {
  }
  
  class ClasseFille extends ClasseMere
  {
  }
  
  $truc1 = new ClasseFille; //Aucun problème pour utiliser la classe ClasseFille
  $truc2 = new ClasseMere; //En revanche il y a une restriction pour utiliser la classe ClasseMere. Une erreur aura lieu.
  ?>
</sxh>


Obliger les classes filles à réécrire certaines méthodes de la classe parente.
<sxh php>
  <?php
  abstract class ClasseMere
  {
    //Pour définir une méthode comme étant abstraite, il faut que la classe elle-même soit abstraite !
    abstract public function Afficher();
    // Il n'y a pas d'instruction dans cette methode, Elle ne peut pas en contenir
    // Les classes Filles seront toutes obligées de réécrire le methode Afficher()
  }

  class ClasseFille extends ClasseMere
  {
    public function Afficher()
    {
      echo "Methode obligatoirement ecrite dans la classe fille\n";
    }
  }

  $truc = new ClasseFille;
  $truc->Afficher();
  ?>
</sxh>

Restreindre l'héritage d'une classe (classe finale ne pouvant être héritée) et la empêcher réécriture d'une methode. 

<sxh php>
  <?php
  abstract class ClasseMere
  {
    // Ceci est une methode finale ne pouvent être héritée
    final public function Methode()
    {
      echo "Hello\n";
    }
  }

  // Cette classe est déclarée comme finale, aucun classe ne peut en hériter
  final class ClasseFille extends ClasseMere
  {
    // Erreur fatale, car le methode "Methode" était déclarée comme final dans la classe parente.
    public function Methode()
    {
    }
  }

  // Erreur fatale, car notre classe hérite d'une classe finale.
  class ClassePetiteFille extends ClasseFille
  {
  }
  ?>
</sxh>

==== Résolution statique à la volée ====
<sxh php>
  <?php
  class Mere
  {
    public static function lancerLeTest()
    {
       self::quiEstCe();
    }

    public function quiEstCe()
    {
      echo "Je suis la classe Mere !\n";
    }
  }

  class Enfant extends Mere
  {
    public function quiEstCe()
    {
       echo 'Je suis la classe Enfant !';
    }
  }

  Enfant::lancerLeTest();
  ?>
</sxh>

Résultat attendu :
  Je suis la classe Mere !

==== Pour résumer ====
  * Avec l'attribut **protected** il est possible de permettre au classe fille d'utiliser l'attribut contrairement à l'attribut **private**
  * **abstract** dans une classe empèche d'utiliser cette classe en dehors d'une classe fille
  * **abstract** dans une méthode oblige les classes filles à réécrire la méthode.
  * **final** permet de déclarer une méthode ou classe comme non "héritable"
  * **parent::methode()** permet de reprendre les éléments d'une methode parente y ajouter modifier des éléments