Le modèle objet de PHP (première partie)

Programmation impérative

• Orientée autour de la définition de fonctions ;
• Les données sont des variables stockées dans le main ou globales ;
• Inconvénients :
  • les données sont stockées de manière approximative
  • l’utilisation du code peut être complexe ;
  • la modification d’une fonction peut engendrer de lourdes conséquences.

Programmation Orientée Objet

• la protection des données en les encapsulant au sein de structures de plus haut niveau (les objets) ;
• la ré-utilisation du code ;
• la facilité d’utilisation des objets

Objet - instance et classe

• Un objet est un concept (qui peut être vu comme un moule).
• Une instance est une implémentation de ce concept (un produit du moule).
  Exemple : Aristote est un Être Humain ⇒ Être Humain est objet et Aristote est une instance.
• Une classe est le code représentant un objet.

• Encapsulation : C'est une méthode permettant de rassembler les données et les fonctions dans une même structure (l’objet). Pour cela, on va ”interdire” l’accès direct aux données et cacher l’implémentation des fonctions associées à l’objet.
  • Propriétés : caractéristiques de l’objet (appelées « attributs» en Java). Ce sont des variables d'instance
  • Méthodes : actions qui s’appliquent à l’objet
• Héritage : l’objet descend d’un autre, plus général, dont il va hériter des attributs et méthodes
• Polymorphisme : Capacité d’un ensemble d’objets à exécuter des méthodes de même nom, mais dont le comportement est propre à chacune des versions

• Constructeur : appelé lors de la création d’une instance et initialise l’instance. — il DOIT être nommé __construct(...)
• Destructeur : appelé lors de la destruction de l’objet pour libérer la mémoire. ——- il DOIT être nommé __destruct().
• Accesseur : permet d’accéder en lecture ou en écriture à un attribut.

Une classe en PHP

Pièges des objets

Constructeur, destructeur, conversion en chaîne

• Fonction __construct()
• Fonction __destruct() : appelée lorsque l'instance est détruite (utilisation de unset, ou fin de l'exécution du script)
• Fonction __toString() : appelée lorsque l'objet doit être converti en chaîne de caractères
• Attention au double underscore du constructeur, crée des bugs difficiles à trouver !

<?php

class Point {
    public int $x;
    public int $y;

    public function __construct(int $x, int $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function __toString(): string {
        return "({$this->x},{$this->y})";
    }
}

$p = new Point(3, 2);
echo $p."\n";

?>

(3,2)

Méthodes statiques en PHP :

• Dans certains cas, il est très pratique d’accéder aux méthodes et aux propriétés en termes de classe plutôt qu’en objet.
• Cela peut être fait à l’aide du mot clé « static ».
• Toute méthode déclarée comme static est accessible sans la création d’un objet.
• Les fonctions statiques sont associées à la classe, pas une instance de classe.
• Ils sont autorisés à accéder uniquement aux méthodes statiques et aux variables statiques.
• Pour ajouter une méthode statique à la classe, le mot clé « static » est utilisé.

 La valeur suivante est : 1
La valeur suivante est : 2
La valeur suivante est : 3
La valeur suivante est : 4
La valeur suivante est : 5
La valeur suivante est : 6
La valeur suivante est : 7
La valeur suivante est : 8
La valeur suivante est : 9
La valeur suivante est : 10

<?php

class Toto {
    private static int $compteur = 0;
    private string $contenu;

    public function __construct(string $contenu) {
        $this->contenu = $contenu;
        self::$compteur++;
    }

    public function printInstanceStats(): string {
        // Utilisation de $this->dummy au lieu de $this->compteur
        return $this->contenu . " et " . self::$compteur . "\n";
    }

    public static function printClassStats(): string {
        // Commenté pour éviter une fatal error
        // $this->dummy = "toto";
        return "Il y a actuellement " . self::$compteur . " instances de la classe Toto\n";
    }

    public function __destruct() {
        echo "Destruction d'une instance\n";
        self::$compteur--;
    }
}

echo Toto::printClassStats();

$A = new Toto("instance A");
echo "\$this->compteur n'est pas défini => donne une chaine vide et une Notice\n";
echo "A : " . $A->printInstanceStats();
echo Toto::printClassStats();

$B = new Toto("instance B");
echo "\$this->compteur n'est pas défini => donne une chaine vide et une Notice\n";
echo "B : " . $B->printInstanceStats();
echo Toto::printClassStats();

echo "unset(\$A)\n";
unset($A);
echo Toto::printClassStats();

unset($B);
echo Toto::printClassStats();
?>

Il y a actuellement 0 instances de la classe Toto
$this->compteur n'est pas défini => donne une chaine vide et une Notice
A : instance A et 1
Il y a actuellement 1 instances de la classe Toto
$this->compteur n'est pas défini => donne une chaine vide et une Notice
B : instance B et 2
Il y a actuellement 2 instances de la classe Toto
unset($A)
Destruction d'une instance
Il y a actuellement 1 instances de la classe Toto
Destruction d'une instance
Il y a actuellement 0 instances de la classe Toto

<?php

class MyClass {
    const ma_constante = 'toto';
    
    public function showConstant(): void {
        echo "Voici ma constante: " . self::ma_constante . "\n";
    }
    
    public function chgeConstant(): void {
        // En PHP 8, une constante ne peut pas être modifiée après sa définition.
        // Cela générera une erreur fatale.
        // self::ma_constante = "test d'erreur";
    }
}

$obj = new MyClass();

$obj->showConstant();

echo "MyClass::ma_constante : " . MyClass::ma_constante . "\n";  // Fonctionne
// Les constantes de classe ne peuvent pas être accédées via une instance
//echo "\$obj->ma_constante : " . $obj->ma_constante . "\n";  // Ne fonctionne pas

// Vous pouvez accéder à une constante de classe via une instance en utilisant ::
echo "\$obj::ma_constante : " . $obj::ma_constante . "\n";
?>

<?php

class MyClass
{
    public string $public = 'Public ';
    protected string $protected = 'Protected ';
    private string $private = 'Private ';

    public function printHello(): void
    {
        echo "$this->public $this->protected $this->private\n";
    }
}

$obj = new MyClass();
echo $obj->public; // Fonctionne
//echo $obj->protected; // Erreur fatale
//echo $obj->private; // Erreur fatale
$obj->printHello(); // Affiche Public, Protected et Private


// Classe dérivée
class MyClass2 extends MyClass
{
    // On peut redéclarer la méthode publique et protégée, mais pas la privée
    protected string $protected = 'Protected2 ';

    public function printHello(): void
    {
        echo "$this->public $this->protected $this->private\n";
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // Fonctionne
//echo $obj2->private; // Indéfini (propriété privée)
//echo $obj2->protected; // Erreur fatale
$obj2->printHello(); // Affiche Public, Protected2

?>

Public Public  Protected  Private 
Public Public  Protected2  

<?php

class Rectangle {
    protected float $longueur;
    protected float $largeur;

    public function __construct(float $longueur, float $largeur) {
        $this->longueur = $longueur;
        $this->largeur = $largeur;
    }

    // Accesseurs

    // Getters
    public function getLongueur(): float {
        return $this->longueur;
    }

    public function getLargeur(): float {
        return $this->largeur;
    }

    // Setters
    public function setLongueur(float $longueur): void {
        $this->longueur = $longueur;
    }

    public function setLargeur(float $largeur): void {
        $this->largeur = $largeur;
    }
}

class Carre extends Rectangle {
    public function __construct(float $cote) {
        parent::__construct($cote, $cote);
    }

    public function setLongueur(float $cote): void {
        parent::setLongueur($cote);
        parent::setLargeur($cote);
    }

    public function setLargeur(float $cote): void {
        parent::setLongueur($cote);
        parent::setLargeur($cote);
    }
}

echo "Définition d'un rectangle 5x2 :\n";
$R = new Rectangle(5, 2);
// echo $R->longueur; produit Fatal error
// Utiliser les accesseurs :
echo "Longueur : " . $R->getLongueur() . "\n";
echo "Largeur : " . $R->getLargeur() . "\n";

echo "Définition d'un carré de côté 4\n";
$C = new Carre(4);
echo "Côté :  " . $C->getLargeur() . "\n";

echo "Changement du côté : \n";
$C->setLargeur(8);
echo "Côté :  " . $C->getLargeur() . "\n";

?>

Définition d'un rectangle 5x2 :
Longueur : 5
Largeur : 2
Définition d'un carré de côté 4
Côté :  4
Changement du côté : 
Côté :  8

Catch multiple

Polymorphisme en php

<?php

abstract class Forme {
    abstract public function aire(): float;
}

class Point extends Forme {
    protected float $x;
    protected float $y;

    public function __construct(float $x, float $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function getX(): float {
        return $this->x;
    }

    public function getY(): float {
        return $this->y;
    }

    public function aire(): float {
        return 0; // Un point n'a pas d'aire
    }
}

class Ligne extends Forme {
    protected Point $point1;
    protected Point $point2;

    public function __construct(Point $point1, Point $point2) {
        $this->point1 = $point1;
        $this->point2 = $point2;
    }

    public function aire(): float {
        return 0; // Une ligne n'a pas d'aire
    }
}

class Triangle extends Forme {
    protected Point $sommet1;
    protected Point $sommet2;
    protected Point $sommet3;

    public function __construct(Point $sommet1, Point $sommet2, Point $sommet3) {
        $this->sommet1 = $sommet1;
        $this->sommet2 = $sommet2;
        $this->sommet3 = $sommet3;
    }

    public function aire(): float {
        // Calcul de l'aire d'un triangle (exemple simple, non réaliste)
        $x1 = $this->sommet1->getX();
        $y1 = $this->sommet1->getY();
        $x2 = $this->sommet2->getX();
        $y2 = $this->sommet2->getY();
        $x3 = $this->sommet3->getX();
        $y3 = $this->sommet3->getY();

        // Formule de l'aire d'un triangle
        return abs(($x1 * ($y2 - $y3) + $x2 * ($y3 - $y1) + $x3 * ($y1 - $y2)) / 2);
    }
}

class Rectangle extends Forme {
    protected Point $coinSuperieurGauche;
    protected Point $coinInferieurDroit;

    public function __construct(Point $coinSuperieurGauche, Point $coinInferieurDroit) {
        $this->coinSuperieurGauche = $coinSuperieurGauche;
        $this->coinInferieurDroit = $coinInferieurDroit;
    }

    public function aire(): float {
        // Calcul de l'aire d'un rectangle (exemple simple, non réaliste)
        $x1 = $this->coinSuperieurGauche->getX();
        $y1 = $this->coinSuperieurGauche->getY();
        $x2 = $this->coinInferieurDroit->getX();
        $y2 = $this->coinInferieurDroit->getY();

        return abs(($x2 - $x1) * ($y1 - $y2));
    }
}

class Carre extends Rectangle {
    public function __construct(Point $coinSuperieurGauche, float $cote) {
        $coinInferieurDroit = new Point($coinSuperieurGauche->getX() + $cote, $coinSuperieurGauche->getY() - $cote);
        parent::__construct($coinSuperieurGauche, $coinInferieurDroit);
    }
}

class Cercle extends Forme {
    protected Point $centre;
    protected float $rayon;

    public function __construct(Point $centre, float $rayon) {
        $this->centre = $centre;
        $this->rayon = $rayon;
    }

    public function aire(): float {
        // Calcul de l'aire d'un cercle (exemple simple, non réaliste)
        return M_PI * $this->rayon * $this->rayon;
    }
}

// Fonction générique utilisant le polymorphisme
function afficherAire(Forme $forme): void {
    echo "Aire : " . $forme->aire() . "\n";
}

// Utilisation du polymorphisme
$sommet1 = new Point(1, 2);
$sommet2 = new Point(3, 4);
$sommet3 = new Point(5, 6);

$ligne = new Ligne($sommet1, $sommet2);

$triangle = new Triangle($sommet1, $sommet2, $sommet3);
$rectangle = new Rectangle($sommet1, $sommet3);

// Création d'un nouvel objet Point pour représenter le coin supérieur gauche du carré
$coinSuperieurGaucheCarre = new Point(7, 8);
$carre = new Carre($coinSuperieurGaucheCarre, 10);

$cercle = new Cercle($sommet1, 5);

afficherAire($sommet1);
afficherAire($ligne);
afficherAire($triangle);
afficherAire($rectangle);
afficherAire($carre);
afficherAire($cercle);

?>