#













#

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

• 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

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

• $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 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

• 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

<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

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

<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

<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

• 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

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

<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

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>

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

• 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