Les classes

Déclaration & instanciation

Le mot clé class permet de définir la classe. Le nom de la classe commence toujours par une majuscule. (Convention)

Pour instancier une classe (création d'un nouvel objet à partir d'une classe), vous pouvez utilisez le mot clé new

<?php 
<pre>
    <?php 
        class Personne {

        }

        $etu_1 = new Personne(); //   $etu_1 : L'objet créé à partir de la classe `Etudiant`.

        var_dump($etu_1)

    ?>
</pre>

L'utilisation et la déclaration d'une classe en PHP est fort similaire à celle de Java.

Exemple java

    public class BoundingBox {  

        private int x;
        private int y;
        private int width;
        private int height;

        BoundingBox() {
            this.x = 0; 
            this.y = 0;
            this.width = 0; 
            this.height = 0;
        }

        public static BoundingBox ofPosAndDim (int x, int y, int width, int height){
            BoundingBox box = new BoundingBox();
            box.x = x; 
            box.y = y;
            box.width = width; 
            box.height = height;
            return box;
        }

        public int top(){
            return x + height/2;
        }

        public void setX(int x){
            this.x = x;
        }

    }

Exemple php

<?php 
class BoundingBox {
        private $x;
        private $y;
        private $width;
        private $height;

        public function __construct(){
            $this->x = 0;
            $this->y = 0;
            $this->width = 0;
            $this->height = 0;
        }

        public static function ofPosAndDim ($x, $y, $width, $height){
            $box = new BoundingBox();
            $box->x = $x; 
            $box->y = $y;
            $box->width = $width;
            $box->height = $height;
            return $box;
        }

        public function top(){
            return $this->x + $this->height/2;
        }

        public function setX($x){
            $this->x = $x;
        }
}

Les différences majeures de syntaxe de PHP par rapport à Java sont:

l'utilisation de-> au lieu d'un . pour accéder aux propriétés et méthodes d'une instance d'objet,
l'obligation, au sein des méthodes de la classe, de précéder les méthodes et propriétés de l'instance par $this-> alors que c'est facultatif en Java (this.)

Tout comme en Java, une propriété ou méthode privée (private) n'est accessible qu'au sein d'une méthode de la classe.

Propriétés et méthodes

<?php

class Personne //Création d'une classe nommée `Personne`
{

    public string $nom = ""; //Déclaration propriété publique  
    public int $age = 0;  //Déclaration propriété publique  

    public function sePresenter():string //méthode publique
    {
        return 'Je m\'appelle ' . $this->nom . ' et j\'ai ' . $this->age . ' ans';
    }
}

$utilisateur1 = new Personne(); // création d'un objet

$utilisateur1->nom = 'Jules'; // attribution d'une valeur à la propriété nom

$utilisateur1->age = 25; //attribution d'une valeur à la propriété age

echo $utilisateur1->sePresenter(); // appelle la méthode sePrenter

Infos

La -> permet d'accèder à une propriété ou une méthode.

Warning: Pas d'utilisation du $ Ex : $user->name = 'Jules';

Accès aux propriétés : On accède aux propriétés d’un objet avec $objet->propriete.

Accès aux méthodes : On appelle une méthode avec $objet->methode().

Mot clé $this

Le mot clé $this fait référence à l'objet courant. Dans l'exemple précédent, dans la méthode sePresenter, $this->nom fait référence à la propriété nom de l'objet courant.

Constructeur

Un constructeur est une méthode spéciale appelée automatiquement lors de la création d'une instance d'une classe et permet d'initialiser les propriétés de l'objet.

Un constructeur est défini avec la méthode spéciale __construct().

Constructeur

    <?php 
    class Personne {

        public string $nom;
        public int $age;

        // Constructeur
        public function __construct(string $nom = "", int $age = 0) {
            $this->nom = $nom;
            $this->age = $age;
        }
    }

    // Création d'un objet
    $utilisateur1 = new Personne("Alice", 25);
    echo $utilisateur1->nom; // Affiche "Alice"

La méthode __construct() est exécutée automatiquement lors de l'instanciation de classe.

Depuis PHP8, une syntaxe raccourcie est autorisée :

<?php 
class Personne
{
    // Constructeur
    public function __construct(public string $nom = "", public int $age = 0 ) {}
}

// Création d'un objet
$utilisateur1 = new Personne("Alice", 25);
echo $utilisateur1->nom; // Affiche "Alice"

Il est également possible de nommer les paramètres

Paramètres nommés

<?php 
class Personne
{

    public function __construct(public string $prenom = "", public string $nom = "") {}

    public function direBonjour()
    {
        echo "Bonjour ! Je m'appelle $this->prenom $this->nom <br>";
    }


}

$utilisateur1 = new Personne(prenom: 'Jean', nom: 'Dupont');
$utilisateur2 = new Personne(nom: 'Joseph', prenom: 'Marie');

$utilisateur1->direBonjour(); // Bonjour ! Je m'appelle Jean Dupont
$utilisateur2->direBonjour(); // Bonjour ! Je m'appelle Marie Joseph

Il est possible de déclarer une classe sans constructeur. Dans ce cas, aucune initialisation automatique n’est effectuée lors de la création de l’objet.

Dans l'exemple suivant, la classe Utilisateur ne contient aucun constructeur. L’attribut nom n’est pas initialisé automatiquement, il doit être défini après l’instanciation.

Classe sans constructeur

<?php 
class Utilisateur {

    public string $nom = "";
    public string $email = "";

}

$utilisateur1 = new Utilisateur();
$utilisateur1->nom = "Alice"; // On attribue une valeur
$utilisateur1->email = "alice@example.com"; // On attribue une valeur

$utilisateur2 = new Utilisateur();
$utilisateur2->nom = "Bob"; // On attribue une valeur
$utilisateur2->email = "bob@example.com"; // On attribue une valeur


echo $utilisateur1->nom; // Affiche "Alice"

Rem : Une classe sans constructeur peut être utilisée si les valeurs ne sont pas encore disponibles/connues au moment de l’instanciation

Le même exemple avec un constructeur :

Avec un constructeur

<?php 
class Utilisateur {


    public function __construct(public string $nom = "" , public string $email = "") {}

}

$utilisateur1 = new Utilisateur("Alice", "alice@example.com");
$utilisateur2 = new Utilisateur("Bob", "bob@example.com");

echo $utilisateur1->nom; // "Alice"

Visibilité

La visibilité des propriétés et méthodes est définie à l'aide de trois niveaux d'accès :

public : Accessible partout (dans et en dehors de la classe).
private : Accessible uniquement dans la classe elle-même.
protected : Accessible dans la classe et ses classes dérivées (héritage).[non vu dans ce cours]

Public

Une propriété ou une méthode déclarée public peut être utilisée depuis l'intérieur et l'extérieur de la classe.

Public

<?php 
class Utilisateur {

    public function __construct(public string $nom = "", public string $email = "") {
        $this->nom = $nom;
        $this->email = $email;
    }

}

$utilisateur1 = new Utilisateur("Alice", "alice@example.com");

// Accès direct aux propriétés
echo $utilisateur1->nom;   // Alice
echo $utilisateur1->email; // alice@example.com

// Modification directe des propriétés
$utilisateur1->nom = "Alicia";
echo $utilisateur1->nom; // Alicia

Private

Une propriété ou une méthode private n'est pas accessible en dehors de la classe.

Private

<?php 

class Utilisateur {

    public function __construct(private string $nom = "", private string $email = "") {
        $this->nom = $nom;
        $this->email = $email;
    }
}

$utilisateur1 = new Utilisateur("Alice", "alice@example.com");

// ERREUR : Impossible d'accéder aux propriétés privées
// echo $utilisateur1->nom;   // Erreur : Cannot access private property
// echo $utilisateur1->email; // Erreur

// ERREUR : Impossible de modifier directement
// $utilisateur1->nom = "Bob"; //  Erreur

Solution : Utiliser des méthodes getter et setter pour accéder/modifier la valeur.

Getter

<?php 
class Utilisateur
{

    public function __construct(private string $nom = "", private string $email = "") {
    {
        $this->nom = $nom;
        $this->email = $email;
    }

    // Getter pour accéder au nom
    public function getNom(): string
    {
        return $this->nom;
    }

    // Setter pour modifier le nom  
    public function setNom(string $nouveauNom)
    {
        $this->nom = $nouveauNom;
    }

    // Getter pour accéder au mail
    public function getMail(): string
    {
        return $this->email;
    }

    // Setter pour modifier le mail  
    public function setMail(string $nouveauMail)
    {
        $this->email = $nouveauMail;
    }
}

$utilisateur1 = new Utilisateur("Alice", "alice@example.com");

//Accès via le getter
echo $utilisateur1->getNom(); // Alice

//Modification via le setter
$utilisateur1->setNom("Bob");
echo $utilisateur1->getNom(); // Bob

Méthodes magiques

Les méthodes magiques sont des fonctions spéciales qui commencent par __ (double underscore). Elles sont automatiquement appelées dans des situations spécifiques.

Exemples d'utilisation :

Initialisation d’un objet (__construct())
Destruction d'un objet (__destruct())
Gestion de propriétés non définies (__get(),__set())
Gestion d’appels de méthodes inexistantes (__call(),__callStatic())
Conversion d’un objet en chaîne (__toString())
Clonage d’un objet (__clone())

get() set()

__get() est appelé lorsqu'on tente d'accéder à une propriété inexistante ou privée. __set() est appelé lorsqu'on tente d'affecter une valeur à une propriété inexistante ou privée.

Reprenons l'exemple précédent :

Méthode magique

<?php 
class Utilisateur
{

    public function __construct(private string $nom = "", private string $email = "") {}

    public function __get($prop): string
    {
        return $this->$prop;
    }

    public function __set($prop, $valeur) {
        $this->$prop = $valeur;
    }
}


$utilisateur1 = new Utilisateur();
$utilisateur1->nom = 'Alice'; // `__set()` est appelé
echo $utilisateur1->nom; // `__get()` retourne 25

Static

Les propriétés et méthodes statiques appartiennent directement à la classe et non à une instance. Elles ne sont donc pas accessibles via un objet.

Une propriété statique est partagée par toutes les instances de la classe, garantissant une valeur commune.
Une méthode statique ne peut pas utiliser $this, car elle n’est pas liée à une instance spécifique, mais à la classe elle-même.
Une méthode statique est une fonction qui peut être appelée sans instancier la classe. Elle s’exécute via NomClasse::methodeStatic(), sans nécessiter la création d’un objet.

Exemple méthode static

<?php 

class Utilisateur {
    public static int $compteur = 0;

    public function __construct() {
        self::$compteur++; // Incrémente à chaque création de personne
    }

    public static function nombreUtilisateurs() {
        return self::$compteur;
    }
}

// Création de plusieurs objets
$utilisateur1 = new Utilisateur();
$utilisateur2 = new Utilisateur();
$utilisateur3 = new Utilisateur();

// Affichage du nombre d'utilisateur
echo "Le nombre d'utilisateur est de " . Utilisateur::nombreUtilisateurs(); // "3"

Points d'attention dans cet exemple :

Partage entre toutes les instances : La valeur de self::$compteur est partagée.
Appel sans instanciation : Utilisateur::getCompteur() est appelé sans créer d’objet.
Pas d’accès à $this dans une méthode statique.

Différence entre $this et self::

Mot-clé	Utilisation	Accessible depuis
`$this->`	Pour les propriétés et méthodes d'un objet	Une méthode non statique
`self::`	Pour les propriétés et méthodes static	Une méthode statique

$this vs self::

   <?php 

   class Personne
   {
       public string $prenom; // Non statique
       public static string $statique = "Classe 1I7"; // Statique

       public function afficherNom()
       {
           return $this->prenom; // Utilisation de `$this` dans une méthode normale
       }

       public static function afficherStatique()
       {
           return self::$statique; // Utilisation de `self::` dans une méthode `static`
       }
   }

   // Appel normal avec un objet
   $etudiant1 = new Personne();
   $etudiant1->prenom = 'Jules';
   echo $etudiant1->afficherNom(); // "Objet"

   // Appel statique sans objet
   echo Personne::afficherStatique(); // "Classe"

Comparaison d'un exemple en java et en php

Java

public class Taxation {
    public static double tva = 0.21;
    public static String changeTVA(double tva) {
        Taxation.tva = tva;
        return getString();
    }
    public static String getString() {
        return "Taux officiel : " + tva;
    }
}
System.out.print("Le taux : " + Taxation.tva);
System.out.print(Taxation.changeTVA(0.06));

Php

<?php 
class Taxation {
    static $tva = 0.21;
    static function changeTVA($tva){
        self::$tva = $tva;
        return self::getString();
    } 
    static function getString(){
        return 'Taux officiel : '.self::$tva;
    }
}
echo 'Le taux : ', Taxation::$tva; //Le taux : 0.21
echo Taxation::changeTVA(0.06);    //Taux officiel : 0.06
?>

Constantes de classe

Une constante de classe est la combinaison d'une constante et d'une variable statique; en d'autres termes, c'est une variable statique dont la valeur ne peut être modifiée une fois celle-ci initialisée (valeur fixe et immuable).

Une constante est définie à l’intérieur d’une classe avec const NOM = valeur;.
Elle ne peut pas être modifiée après sa définition.
Elle est accessible avec NomClasse::NOM sans instancier la classe.

Constantes

<?php 
class Utilisateur {
    const ROLE = "Admin"; // Déclaration d'une constante

    public function afficherRole() {
        return self::ROLE; // Accès à la constante depuis une méthode
    }
}

// Accès direct sans créer d'objet
echo Utilisateur::ROLE; // Affiche : Admin

// Accès depuis une instance
$user = new Utilisateur();
echo $user->afficherRole(); // Affiche : Admin

Comparaison d'un exemple en java et en php

Java

Constante de classe

class Circle {
    final static double PI = 3.1415;
    private  double radius = 0;
    public void setRadius(double r){
       radius = r;   
    }
    public double getCircumference(){
        return 2 * this.radius * PI;
    }

    System.out.print("Pi = " + Circle.PI);
    Circle c = new Circle();
    System.out.print(c.PI);
    c.setRadius(5);
    System.out.print("Circumference = "+c.getCircumference()); 

}

Php

Constante de classe

<?php 
class Circle {
    const PI = 3.1415;   //public par défaut !
    private $radius = 0;
    public function setRadius($r) {
        $this->radius = $r;
    }
    public function getCircumference() {
        return 2 * $this->radius * self::PI;    
    }
}
echo 'Pi = ', Circle::PI;                           //Pi = 3.1415
$c = new Circle();
echo $c::PI;                                        //3.1415
$c->setRadius(5);
echo 'Circumference = ', $c->getCircumference(); //Circumference = 15.7075
?>

Les classes

Déclaration & instanciation

Propriétés et méthodes

Mot clé $this

Constructeur

Visibilité

Public

Private

Méthodes magiques

__get() __set()

Static

Constantes de classe

get() set()