Le modèle objet de PHP (deuxième partie)

Affichage debug d'un objet

<?php
class Titi {
    private bool $x = false;
    protected string $y = "";
    public $z = null;

    function methode() { }
}

echo "---- var_export ----\n";
var_export(new Titi());

echo "---- print_r ----\n";
print_r(new Titi());

echo "---- var_dump ----\n";
var_dump(new Titi());
?>

---- var_export ----
\Titi::__set_state(array(
   'x' => false,
   'y' => '',
   'z' => NULL,
))---- print_r ----
Titi Object
(
    [x:Titi:private] => 
    [y:protected] => 
    [z] => 
)
---- var_dump ----
/users/ensweb/www-prod/TW3/pres/oophp/demo/exPrintDebug.php:17:
class Titi#3 (3) {
  private bool $x =>
  bool(false)
  protected string $y =>
  string(0) ""
  public $z =>
  NULL
}

Mot clé final

• final pour une méthode : la méthode ne peut pas être redéfinie dans une classe dérivée
• final pour une classe : la classe ne peut pas être dérivée

<?php

class finalEx {
    private string $donnee = "exemple";
  
    final function maj(): string {
        return strtoupper($this->donnee);
    }
}

final class finalExtend extends finalEx {
    /*
     * Produira une erreur fatale :
     * Fatal error: Cannot override final method finalEx::maj()
     */
    /*
    public function maj(): string {
        return $this->donnee;
    }
    */
}

/*
 * Produira une erreur fatale :
 * Fatal error: Class erreur may not inherit from final class (finalExtend)
 */
/*
class erreur extends finalExtend {
    // impossible
}
*/

$class = new finalEx();
echo $class->maj();
echo "\n";

$classExtend = new finalExtend();
echo $classExtend->maj();

?>

EXEMPLE
EXEMPLE

Classe et méthode abstraite

• Mot clé abstract
• Une classe abstraite ne peut pas être instanciée
• Une méthode abstraite définit sa signature, pas son implémentation
• Une méthode abstraite doit être dérivée avec une visibilité supérieure

<?php

abstract class AbstractClass
{
    // Force la classe étendue à définir cette méthode
    abstract protected function getValue(): string;

    // Méthode commune
    public function printOut(): void
    {
        echo $this->getValue();
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue(): string
    {
        return "ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    protected function getValue(): string
    {
        return "ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();

$class2 = new ConcreteClass2;
$class2->printOut();

ConcreteClass1ConcreteClass2

Interfaces

• Une interface ne peut contenir que les signatures des méthodes ainsi qu’éventuellement des constantes mais pas de propriétés. Cela est dû au fait qu’aucune implémentation n’est faite dans une interface : une interface n’est véritablement qu’un plan ;
• Une classe ne peut pas étendre plusieurs autres classes à cause des problèmes d’héritage. En revanche, une classe peut tout à fait implémenter plusieurs interfaces.

Exemple

Prix de l'abonnement pour Pierre : 7.5
Prix de l'abonnement pour Sophie : 15
Prix de l'abonnement pour Gael : 15

Type Nullable

    //Types Nullable pour les Valeurs de Retour
    function diviser(?float $a, ?float $b): ?float {
        if ($b === 0.0) {
            return null;
        }
        return $a / $b;
    }

    // Exemple d'utilisation
    $resultat = diviser(10.0, 2.0);
    
    //Types Nullable pour les Paramètres de Fonction
    function exemple(?string $parametre) {
        if ($parametre === null) {
            echo "Le paramètre est null.";
        } else {
            echo "Le paramètre est : " . $parametre;
        }
    }

    // Exemple d'utilisation
    exemple("valeur");
    exemple(null);
    
    //Types Nullable pour les Propriétés de Classe
    class Exemple {
        public ?string $propriete;

        public function __construct(?string $valeur) {
            $this->propriete = $valeur;
        }
    }

    // Exemple d'utilisation
    $objet = new Exemple("valeur");
    echo $objet->propriete;
    

Espaces de noms

Les namespaces permettent de définir un nom de package que l'on pourra ensuite charger de manière automatique gràce à un autoloading.

Pour déclarer un namespace, il faut utiliser la commande namespace suivi du nom du namespace à créer.

On prendra l'habitude de créer nos classes dans un namespace pour éviter les collisions ! Par exemple, nous allons placer notre class Exemple dans un namespace MonNamespace.

Héritage vs composition

Un principe important en POO est de favoriser la composition plutôt que l'héritage pour mutualiser du code

En effet l'héritage a des conséquences pénibles, notamment le fait qu'à partir du moment où on a sous-classé une classe, il devient difficile de la faire évoluer (tout changement a des conséquences sur les classes filles)

cela contrevient à la modularisation du code — les classes sont trop dépendantes les unes des autres, alors que le but de la POO est plutôt d'essayer de créer des « boîtes noires » dont le comportement interne n'a pas d'influence à l'extérieur

En utilisant la composition, on garde l'indépendance entre les classes

le prix à payer est une syntaxe un peu plus lourde dans la classe, et l'obligation parfois d'écrire des méthodes de « délégation »

ex autom cell: comportement en fonction de la règle, en fonction de l'affichage voulu

Traits

Les traits de PHP sont (principalement) un moyen de faire de la composition, sans les inconvénients

trait MonTrait {
    function uneMethodeUtile() {
}

class Toto {
    use MonTrait;
}

Méthodes magiques

Itérables

Conventions de nommage en PHP

• Pascal case -> NomEnPascalCase (aussi appelée Upper Camel Case)
  Pascal case c'est quand la première lettre de chaque mot commence par une majuscule sans espaces entre les mots.
• Camel Case -> nomEnCamelCase (aussi appelé Lower Camel Case)
  Camel cas c'est la même chose, sauf que la première lettre du mot commence par une lettre minuscule.

Les bases et les généralités

• Les mots clefs abstract ou static doivent passer avant la visibilité d'une variable de classe
• Déclarez une classe par fichier
• Les propriétés de classe avant les méthodes
• Les méthodes dans cet ordre : publiques, protégées, privées.
• Classe : MaClasse (Upper Camel Case) //Le nom de la classe doit indiquer l'objet créé (User, Article...)
• Fichier (script tout bête sans classe dedans) : mon_script.php
• Fichier de classe : MaClasse.php (Upper Camel Case)
• Fonction : maFonction() (camel Case) //Le nom doit décrire le comportement de la fonction ou de la méthode
• variable : $maVariable, $monArray, $maString, $monEntier (camel Case) Les noms doivent décrire les données dans la variable.
• constante : NOM_DE_CONSTANTE (ALL_CAPS -> tout en majuscule). Il faut utiliser le signe '_' pour séparer les mots dans des constantes
• bool :true, false en minscule
• Une difficile : un fichier doit soit contenir des déclarations de fichiers, mais pas de code executable.
  
  • Entendre par là, vous pouvez déclarer des variables et des fonctions dans un fichier, mais rien qui ne s'exécute à l'inclusion de ce fichier
  • A l'exception du contenu des classes bien entendu