Informatique · PHP

La programmation orientée objet en PHP

Un élève, un compte en banque, une connexion à une base : décris une fois une classe, puis crée autant d'objets qu'il en faut.

Déjà à l'aise ? Aller au quiz

Après cette fiche, tu sais

  • écrire une classe avec propriétés typées, constructeur et méthodes, et créer des objets avec new ;
  • prévoir ce que fait $b = $a avec un objet, et quand utiliser clone ;
  • protéger les données avec private, protected et des méthodes qui valident ;
  • employer l'héritage, les interfaces, static, les traits et les espaces de noms, et interroger une base avec PDO et des requêtes préparées.
Je te pose une question : si tu écris $b = $a; avec un objet, puis que tu changes $b->prenom, est-ce que $a change aussi ?

Attends, tu veux dire que $a change aussi ? Je pensais le contraire.

Garde ta réponse en tête : la notion 2 la vérifie avec un vrai code.

Un plan, puis des objets

Notion 1 · Classe et objet

Une classe décrit, les objets existent

Une classe commence par class, puis son nom, puis des accolades qui contiennent ses propriétés (les données) et ses méthodes (les fonctions).1

class Eleve $prenom · $notes · moyenne() new objet #1 prenom 'Léa' notes [5.5, 5] objet #2 prenom 'Noah' notes [3] objet #3 prenom 'Zoé' notes [6, 5.5]

new crée un objet à partir de ce plan. Le plan, lui, ne contient aucune donnée d'élève.

Appeler une méthode

Dans une méthode, $this désigne l'objet sur lequel elle est appelée. Ici, c'est l'objet #1, celui de $lea.

$lea->ajouterNote(5.5); $lea objet #1 (Eleve) prenom 'Léa' notes [5.5] $this Dans ajouterNote(), $this désigne l'objet #1.

Le vocabulaire

Quatre mots à connaître. Fais défiler pour les empiler.

Propriété

Une variable propre à chaque objet, déclarée dans la classe. Depuis PHP 7.4, on la type (string, array…).1

Méthode

Une fonction de la classe, appelée sur un objet avec -> : $lea->moyenne().1

Constructeur

__construct() est appelé automatiquement sur chaque nouvel objet : c'est l'endroit pour l'initialiser.1

Promotion

Depuis PHP 8.0, public function __construct(public string $prenom) {} déclare la propriété et l'initialise en une ligne.1

Le code

Voici la classe. Elle ne fait rien tant qu'on ne crée pas d'objet.

La classe ElevePHP
<?php
class Eleve
{
    public string $prenom;
    public array $notes = [];

    public function __construct(string $prenom)
    {
        $this->prenom = $prenom;
    }

    public function ajouterNote(float $note): void
    {
        $this->notes[] = $note;
    }

    public function moyenne(): float
    {
        return round(array_sum($this->notes) / count($this->notes), 2);
    }
}

Créer des objets

new appelle le constructeur. Chaque objet garde ses propres notes : la moyenne de Léa n'est pas celle de Noah.

Utiliser la classePHP
$lea = new Eleve('Léa');
$lea->ajouterNote(5.5);
$lea->ajouterNote(5);
$noah = new Eleve('Noah');
$noah->ajouterNote(3);
echo $lea->prenom, ' : ', $lea->moyenne(), "\n";
echo $noah->prenom, ' : ', $noah->moyenne(), "\n";
Léa : 5.25
Noah : 3

Chacun ses données

moyenne() de Léa 5,5 + 5 = 10,5 ÷ 2 = 5,25 Une moyenne : la somme divisée par le nombre de notes. round(10.5 / 2, 2) = 5.25

La même méthode donne 5,25 pour Léa et 3 pour Noah.

Scène 1 · Le plan et les objets

Fais défiler : le code s'exécute ligne après ligne. Deux objets naissent du même plan, et chacun garde ses notes.

Scène 1 · Classe et objets

Un plan, pas encore d'élève

class Eleve le plan string $prenomarray $notes = [] __construct()ajouterNote()moyenne() $this

Piège : oublier $this->

Dans une méthode, $notes[] = $note; crée une variable locale $notes, qui disparaît à la fin de la méthode : la propriété de l'objet ne change pas. Pour toucher la propriété, il faut $this->notes[] = $note;.

Piège : la moyenne sans note

Appelée sur un élève sans note, moyenne() divise par count([]), soit 0 : DivisionByZeroError. Le corrigé 2 montre comment l'éviter.

Deux noms, un seul objet

Notion 2 · Références

$b = $a ne copie pas l'objet

Une variable « objet » ne contient pas l'objet lui-même, seulement un identifiant qui le retrouve. Affecter l'objet à une autre variable copie cet identifiant : les deux variables mènent alors au même objet.3

$a $b $c objet #1 (Eleve) prenom 'Lina' objet #2 (clone) prenom 'Lina' $b = $a : une flèche de plus. clone : un objet de plus.

Le code

Deux variables, un objetPHP
<?php
class Eleve
{
    public function __construct(public string $prenom) {}
}

$a = new Eleve('Léa');
$b = $a;                  // le même objet
$b->prenom = 'Lina';
echo $a->prenom, "\n";

$c = clone $a;            // un nouvel objet, copie de $a
$c->prenom = 'Zoé';
echo $a->prenom, "\n";
var_dump($a === $b, $a === $c);
Lina
Lina
bool(true)
bool(false)
Je te repose ma question du début : si tu changes $b->prenom, est-ce que $a change aussi ?

Oui, je crois : $b et $a mènent au même élève.

Exact : $b = $a copie l'identifiant, pas l'objet. Pour une vraie copie, on écrit clone.

Copier ou cloner

$b = $a ne copie que la flèche. clone fabrique un deuxième objet, une copie de l'original.3

$b = $a $a $b objet #1 un seul objet clone $a $a $c objet #1 objet #2 deux objets

Pour un objet indépendant, on écrit clone.

Dans une fonction

Passer un objet à une fonction copie aussi l'identifiant : la fonction modifie l'objet de l'appelant.3

$a $e paramètre de renommer() objet #1 (Eleve) avant : 'Léa' après : 'Mia' Le paramètre reçoit une copie de l'identifiant : même objet.

Scène 2 · Des flèches vers les objets

Fais défiler : chaque variable est une étiquette qui pointe vers un objet numéroté, comme dans var_dump (object(Eleve)#1).

Scène 2 · Identifiants d'objets

Un objet, une variable

variables objets

=== entre objets

Vrai seulement s'il s'agit de la même instance.

Objet passé à une fonction

La fonction reçoit une copie de l'identifiant : si elle change une propriété, l'objet de l'appelant change.3

clone

Copie superficielle : les propriétés sont copiées, mais un objet rangé dans une propriété reste partagé, sauf si la méthode __clone() le clone à son tour.3

Tableaux, eux

Rappel de la fiche précédente : un tableau affecté ou passé à une fonction est copié. Les objets se comportent autrement.

Exercice · à toi

Que va afficher ce code ?

Quatre extraits, tous exécutés avec PHP 8.4. La classe Eleve est celle de l'exemple ci-dessus.

Qui peut toucher aux données

Notion 3 · Encapsulation

public, protected, private : qui a le droit d'y toucher

Un membre public est accessible partout ; protected, seulement dans la classe, ses classes enfants et ses parents ; private, seulement dans la classe qui le déclare.1

extérieur : public classe enfant : public, protected la classe : tout (private) $solde, méthodes

On garde les données private et on n'expose que des méthodes qui les vérifient : c'est l'encapsulation.

Le code

Un compte qui se protègePHP
<?php
class Compte
{
    private float $solde = 0;

    public function deposer(float $montant): void
    {
        if ($montant <= 0) {
            throw new InvalidArgumentException('Montant positif attendu');
        }
        $this->solde += $montant;
    }

    public function retirer(float $montant): void
    {
        if ($montant > $this->solde) {
            throw new RuntimeException('Solde insuffisant');
        }
        $this->solde -= $montant;
    }

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

Le compte refuse

Le solde ne peut pas être modifié depuis l'extérieur : la dernière ligne échoue.

Utiliser le comptePHP
$compte = new Compte();
$compte->deposer(200);
$compte->retirer(50);
echo $compte->solde(), "\n";
try {
    $compte->retirer(500);
} catch (RuntimeException $e) {
    echo 'Refusé : ', $e->getMessage(), "\n";
}
$compte->solde = 1000000;   // interdit depuis l'extérieur
150
Refusé : Solde insuffisant
Fatal error: Uncaught Error: Cannot access private property Compte::$solde in …

Une méthode refuse

Une méthode peut refuser une valeur impossible : elle lance une exception, et le solde ne change pas.

retirer(500) 500 > solde (150) ? oui throw RuntimeException solde : 150 Le solde reste à 150, rien n'est retiré.

Scène 3 · Trois portes, trois points de vue

Fais défiler : on regarde la même classe depuis l'extérieur, depuis une classe enfant, puis depuis la classe elle-même.

Scène 3 · Visibilité

Depuis l'extérieur

class Compte

throw

Une méthode refuse une valeur impossible en lançant une exception ; l'appelant la rattrape avec try … catch.

readonly

Depuis PHP 8.1, une propriété readonly s'initialise une seule fois, dans sa classe ; toute modification ensuite lève Cannot modify readonly property.1

Une subtilitéLa visibilité vaut par classe, pas par objet : une méthode de Compte peut lire le private $solde d'un autre objet Compte.1
Exercice · classer

Accepté ou refusé ?

Compte a un private $solde, un protected $titulaire et une méthode publique solde() ; CompteEpargne extends Compte ; Forme est une interface. Chaque ligne a été testée avec PHP 8.4.

Une classe en prolonge une autre

Notion 4 · Héritage

extends : hériter et spécialiser

Une classe enfant hérite de toutes les méthodes et propriétés public et protected de son parent ; elle peut en ajouter et redéfinir une méthode héritée. Les membres private du parent lui restent inaccessibles.2

Compte public solde() protected $solde private $pin CompteEpargne public solde() protected $solde private : non hérité extends Les membres private restent dans la classe qui les déclare.

Le code

Un compte d'épargnePHP
<?php
class Compte
{
    protected float $solde = 0;

    public function deposer(float $montant): void
    {
        $this->solde += $montant;
    }

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

class CompteEpargne extends Compte
{
    public function __construct(private float $taux) {}

    public function ajouterInterets(): void
    {
        $this->deposer(round($this->solde * $this->taux, 2));
    }
}

Utiliser l'enfant

L'enfant appelle deposer() sans la réécrire : la méthode vient du parent.

Utiliser CompteEpargnePHP
$e = new CompteEpargne(0.0125);   // taux fictif de 1,25 %
$e->deposer(1000);
$e->ajouterInterets();
echo $e->solde(), "\n";
var_dump($e instanceof Compte);
1012.5
bool(true)

Solde : 1012,5 (1000 + 12,5 d'intérêts).

Appeler le parent

Dans l'enfant, $this->deposer() appelle la méthode héritée de Compte. Pour appeler explicitement la version du parent, on écrit parent::deposer().1

CompteEpargne : ajouterInterets() deposer(12,5) Compte : deposer(), héritée 1000 + 12,5 = 1012,5 Le parent fait le travail, l'enfant le lance.

Est-ce un compte ?

Un compte d'épargne est un compte : $e instanceof Compte vaut true.1

Compte CompteEpargne $e instanceof Compte vaut true

Scène 4 · La classe enfant éclatée

Fais défiler : les membres hérités descendent de Compte dans CompteEpargne, puis servent.

Scène 4 · Héritage

Deux classes

class Compte extends class CompteEpargne

parent::

Une méthode redéfinie peut appeler la version du parent : parent::deposer($montant). Si l'enfant a son propre constructeur, celui du parent n'est appelé que par parent::__construct().1

instanceof

$e instanceof Compte vaut true : un compte d'épargne est un compte.

final

Une classe final ne peut pas avoir d'enfant ; PHP refuse class Fille extends Base si Base est final.

Visibilité héritée

Un enfant peut assouplir une visibilité (protected vers public), jamais la restreindre.2

Piège : private chez le parent

Si $solde était private dans Compte, $this->solde dans CompteEpargne ne la verrait pas : Warning: Undefined property: CompteEpargne::$solde. C'est à cela que sert protected.2

Un contrat, plusieurs façons

Notion 5 · Interfaces

Un contrat, plusieurs façons de le remplir

Une interface dit quelles méthodes une classe doit avoir, sans dire comment elles marchent. Une classe qui l'implements doit toutes les écrire, sinon PHP refuse la classe ; elle peut en implémenter plusieurs.2

interface Forme aire() implements Rectangle aire() : l × h Cercle aire() : π × r² Chaque classe écrit sa propre aire().

Une fonction qui attend Forme accepte tout objet qui respecte le contrat : c'est le polymorphisme.2

Le code

Des formes et leur airePHP
<?php
interface Forme
{
    public function aire(): float;
}

class Rectangle implements Forme
{
    public function __construct(private float $l, private float $h) {}

    public function aire(): float
    {
        return $this->l * $this->h;
    }
}

class Cercle implements Forme
{
    public function __construct(private float $r) {}

    public function aire(): float
    {
        return round(M_PI * $this->r ** 2, 2);
    }
}

function aireTotale(array $formes): float
{
    $total = 0;
    foreach ($formes as $f) {
        $total += $f->aire();   // chaque objet répond à sa façon
    }
    return $total;
}

L'appel

Le total vaut 15,14 : 12 pour le rectangle, puis 3,14 pour le cercle.

Un seul appelPHP
echo aireTotale([new Rectangle(3, 4), new Cercle(1)]);
15.14

Séquence · le même appel, deux méthodes

Fais défiler : la même ligne $f->aire() exécute deux méthodes différentes.

interface Forme : aire() Rectangle(3, 4) aire() : l × h Cercle(1) aire() : π × r²
Étape 1 sur 4 · le contrat

Rectangle et Cercle implements Forme : chacune a sa méthode aire(), écrite à sa façon.2

Étape 2 sur 4 · premier tour

$f est un Rectangle : $f->aire() exécute la méthode de Rectangle, 3 × 4 = 12.

Étape 3 sur 4 · second tour

$f est un Cercle : la même ligne exécute la méthode de Cercle, π × 1², arrondi à 3,14.

Étape 4 sur 4 · le total

aireTotale renvoie 15,14 sans jamais savoir quelles classes existent : il lui suffit que chaque objet respecte le contrat Forme.

Classe abstraite

Une classe abstraite partage du code

Une classe abstract ne s'instancie pas. Elle peut contenir du code, et une méthode abstract que ses enfants doivent écrire.2

Une classe abstraitePHP
<?php
abstract class Figure
{
    abstract public function aire(): float;

    public function decrire(): string
    {
        return 'aire : ' . $this->aire();
    }
}

class Carre extends Figure
{
    public function __construct(private float $cote) {}

    public function aire(): float
    {
        return $this->cote * $this->cote;
    }
}

echo (new Carre(3))->decrire(), "\n";
aire : 9

Le schéma

new Figure() lève Cannot instantiate abstract class Figure.2

abstract class Figure aire() : abstraite · decrire() extends class Carre extends Figure aire() : 3 × 3 = 9 decrire() vit dans Figure et appelle aire() de Carre.
interfaceclasse abstraite
Contient du codenon, seulement des signatures de méthodesoui, des méthodes complètes et des méthodes abstraites
Instanciablenonnon
Une classe peut en avoirplusieurs (implements A, B)une seule (extends)
Quand l'utiliserpour un contrat commun à des classes sans lienpour partager du code entre classes proches

Une classe abstraite ne peut pas être instanciée, et toute classe qui contient une méthode abstraite doit l'être ; ses enfants doivent écrire toutes les méthodes abstraites.2 PHP répond Cannot instantiate interface Forme à new Forme().

La saisie change le sens

Notion 6 · PDO

Un objet de tous les jours : PDO

PDO (PHP Data Objects) est une classe fournie par PHP pour parler aux bases de données : MySQL, PostgreSQL, SQLite… On crée un objet PDO, puis on prépare des requêtes.4

Le SQL part en premier, les valeurs ensuite. ton script $pdo objet PDO prepare() base SQLite table eleves prepare(SQL) execute(valeurs) les lignes reviennent (fetchAll)

Depuis PHP 8.0, une erreur SQL lève par défaut une PDOException.4

Une requête préparée

Une requête préparée contient des marqueurs (:classe ou ?) ; les valeurs sont transmises à part, avec execute(). La base distingue toujours le code SQL des données.45

Lire les élèves d'une classePHP
<?php
$pdo = new PDO('sqlite::memory:');   // MySQL : 'mysql:host=localhost;dbname=ecole;charset=utf8mb4'
$pdo->exec("CREATE TABLE eleves (id INTEGER PRIMARY KEY, prenom TEXT, classe TEXT)");
$pdo->exec("INSERT INTO eleves (prenom, classe) VALUES ('Léa', '2M3'), ('Noah', '2M3'), ('Elias', '2M1')");

$classe = $_GET['classe'] ?? '2M3';   // vient de l'URL : jamais collé dans le SQL
$stmt = $pdo->prepare('SELECT prenom FROM eleves WHERE classe = :classe ORDER BY prenom');
$stmt->execute(['classe' => $classe]);
foreach ($stmt->fetchAll(PDO::FETCH_ASSOC) as $ligne) {
    echo htmlspecialchars($ligne['prenom']), "\n";
}
Léa
Noah

Scène 5 · La saisie qui change le sens de la requête

Fais défiler : la même saisie malveillante, d'abord collée dans le SQL, puis passée à une requête préparée. Tout a été exécuté avec PDO et SQLite.

Scène 5 · Injection SQL

La saisie

saisie : ?classe= ' OR '1'='1 lignes renvoyées

Le code

La faille, puis la paradePHP
<?php
$pdo = new PDO('sqlite::memory:');
$pdo->exec("CREATE TABLE eleves (id INTEGER PRIMARY KEY, prenom TEXT, classe TEXT)");
$pdo->exec("INSERT INTO eleves (prenom, classe) VALUES ('Léa', '2M3'), ('Noah', '2M3'), ('Elias', '2M1')");
$classe = "' OR '1'='1";

// DANGER : la saisie est collée dans la requête
$sql = "SELECT prenom FROM eleves WHERE classe = '$classe' ORDER BY prenom";
foreach ($pdo->query($sql) as $ligne) {
    echo $ligne['prenom'], "\n";
}

// Requête préparée : la saisie reste une valeur
$stmt = $pdo->prepare('SELECT prenom FROM eleves WHERE classe = :classe ORDER BY prenom');
$stmt->execute(['classe' => $classe]);
echo count($stmt->fetchAll()), " ligne(s)\n";
Elias
Léa
Noah
0 ligne(s)

Le modèle et la valeur

Le marqueur :classe fixe la structure de la requête. La saisie arrive ensuite, comme une simple valeur.

WHERE classe = :classe ' OR '1'='1 valeur seulement 0 ligne La saisie reste une valeur : le modèle ne change jamais.
Piège : ce qu'un marqueur ne peut pas remplacer

Un marqueur remplace une valeur, jamais un nom de table, de colonne ou un ordre de tri (ASC, DESC). Si l'utilisateur choisit la colonne de tri, on compare son choix à une liste de valeurs autorisées.5

Les deux réflexes de sécurité se répondent : requête préparée pour envoyer une donnée à la base, htmlspecialchars() pour l'afficher dans la page.
Exercice · choisir

Requête sûre ?

Trois questions sur PDO et l'injection SQL.

Trois notions de plus

Notion 7 · static

static : ce qui appartient à la classe

Une propriété ou une méthode static appartient à la classe, pas à chaque objet. On l'appelle avec Classe::, et dans la classe, self:: la désigne.6

class Eleve static $nombre 2 compteur objet #1 'Léa' constructeur : +1 objet #2 'Noah' constructeur : +1 Un seul compteur pour la classe : chaque new l'ajoute de 1.

Une méthode static n'a pas de $this : on l'appelle avec Eleve::nombre().6

Le code

Compter les élèvesPHP
<?php
class Eleve
{
    private static int $nombre = 0;

    public function __construct(public string $prenom)
    {
        self::$nombre++;
    }

    public static function nombre(): int
    {
        return self::$nombre;
    }
}

new Eleve('Léa');
new Eleve('Noah');
echo Eleve::nombre(), "\n";
2

Notion 8 · Traits

Un trait partage du code, sans héritage

Un trait rassemble des méthodes. Une classe l'insère avec use, sans en hériter : une classe peut utiliser plusieurs traits.7

trait Salut saluer() use class Eleve saluer() class Professeur saluer() Le trait fournit saluer() à chaque classe qui l'utilise.

Un trait ne s'instancie pas : new Salut() lève Cannot instantiate trait Salut.7

Le code

Deux classes, un traitPHP
<?php
trait Salut
{
    public function saluer(): string
    {
        return 'Bonjour, je suis ' . $this->prenom;
    }
}

class Eleve
{
    use Salut;

    public function __construct(public string $prenom) {}
}

class Professeur
{
    use Salut;

    public function __construct(public string $prenom) {}
}

echo (new Eleve('Léa'))->saluer(), "\n";
echo (new Professeur('Madame Roche'))->saluer(), "\n";
Bonjour, je suis Léa
Bonjour, je suis Madame Roche

Notion 9 · Espaces de noms

namespace : le nom complet d'une classe

Un namespace range les classes dans un espace. Le nom complet d'une classe commence par cet espace : Ecole\Notes\Eleve.8

Ecole \ Notes \ Eleve Ecole\Notes\Eleve Le nom complet = espace de noms + nom de la classe.

Le code

Un espace de nomsPHP
<?php
namespace Ecole\Notes;

class Eleve
{
    public function __construct(public string $prenom) {}
}

$lea = new Eleve('Léa');
echo $lea->prenom, ' : ', Eleve::class, "\n";
Léa : Ecole\Notes\Eleve

Entraîne-toi sur des cas

Habitudes de pro

Sept bonnes pratiques

  • une classe, une responsabilité ; un nom au singulier (Eleve, Compte) ;
  • propriétés private et typées par défaut, readonly quand elles ne doivent plus changer ;
  • valider dans les méthodes, et lancer une exception pour une valeur impossible ;
  • protected seulement quand un enfant en a vraiment besoin ;

Habitudes de pro (suite)

  • se souvenir que $b = $a partage l'objet, et utiliser clone pour une copie ;
  • typer les paramètres par une interface (Forme $f) plutôt que par une classe précise ;
  • avec PDO : toujours prepare() et execute() pour les valeurs, jamais de concaténation.
Entraînement

Trois exercices corrigés

Tous les corrigés ont été exécutés avec PHP 8.4.

1Écris une classe Rectangle avec un constructeur promu (largeur, hauteur) et les méthodes aire() et perimetre().Voir le corrigé
<?php
class Rectangle
{
    public function __construct(
        private float $largeur,
        private float $hauteur,
    ) {}

    public function aire(): float
    {
        return $this->largeur * $this->hauteur;
    }

    public function perimetre(): float
    {
        return 2 * ($this->largeur + $this->hauteur);
    }
}

$r = new Rectangle(3, 4.5);
echo $r->aire(), ' / ', $r->perimetre();
13.5 / 15

Les deux propriétés sont private : on ne peut plus fausser une mesure depuis l'extérieur. La virgule après le dernier paramètre est permise depuis PHP 8.0.

2Améliore Eleve : notes privées, refus d'une note hors de l'échelle 1 à 6, et une moyenne qui vaut null quand il n'y a encore aucune note.Voir le corrigé
<?php
class Eleve
{
    private array $notes = [];

    public function __construct(public string $prenom) {}

    public function ajouterNote(float $note): void
    {
        if ($note < 1 || $note > 6) {
            throw new InvalidArgumentException("Note $note hors de l'échelle 1 à 6");
        }
        $this->notes[] = $note;
    }

    public function moyenne(): ?float
    {
        if (count($this->notes) === 0) {
            return null;
        }
        return round(array_sum($this->notes) / count($this->notes), 2);
    }
}

$zoe = new Eleve('Zoé');
var_dump($zoe->moyenne());
$zoe->ajouterNote(6);
$zoe->ajouterNote(5.5);
var_dump($zoe->moyenne());
try {
    $zoe->ajouterNote(7);
} catch (InvalidArgumentException $e) {
    echo $e->getMessage();
}
NULL
float(5.75)
Note 7 hors de l'échelle 1 à 6

?float annonce « un float ou null ». La division par zéro ne peut plus arriver, et une note impossible n'entre jamais dans l'objet.

3Cette ligne cherche la classe d'un élève à partir d'un prénom saisi. Pourquoi est-elle dangereuse, et comment la corriger ?Voir le corrigé
$ligne = $pdo->query("SELECT classe FROM eleves WHERE prenom = '$prenom'")->fetch();

La saisie est collée dans le SQL : une apostrophe suffit à changer la requête. Version corrigée, avec un marqueur positionnel :

<?php
$pdo = new PDO('sqlite::memory:');
$pdo->exec("CREATE TABLE eleves (id INTEGER PRIMARY KEY, prenom TEXT, classe TEXT)");
$pdo->exec("INSERT INTO eleves (prenom, classe) VALUES ('Léa', '2M3'), ('Noah', '2M3'), ('Elias', '2M1')");
$prenom = 'Noah';

$stmt = $pdo->prepare('SELECT classe FROM eleves WHERE prenom = ?');
$stmt->execute([$prenom]);
$ligne = $stmt->fetch(PDO::FETCH_ASSOC);
echo $ligne ? $ligne['classe'] : 'introuvable';
2M3
À retenir

La fiche en un coup d'œil

Classe et objetclass décrit, new crée une instance ; $this est l'objet sur lequel la méthode est appelée.
Constructeur__construct() initialise ; la promotion (PHP 8.0) déclare et remplit les propriétés en une ligne.
Références$b = $a copie l'identifiant : même objet. clone crée une copie (superficielle).
Visibilitépublic partout, protected dans la famille de classes, private dans la seule classe qui déclare.
Encapsulationdonnées private, méthodes qui valident et lancent une exception si besoin ; readonly pour figer.
Héritageextends transmet public et protected ; parent:: appelle la version du parent.
Interfacesun contrat de méthodes ; implements oblige à toutes les écrire ; une fonction qui attend l'interface accepte toute classe qui la respecte.
PDOprepare() avec :marqueurs, puis execute() avec les valeurs ; erreurs en PDOException depuis PHP 8.0.
staticune propriété ou une méthode static appartient à la classe ; on l'appelle avec Classe::.
Traitsuse insère des méthodes dans une classe, sans héritage ; un trait ne s'instancie pas.
Espaces de nomsnamespace range les classes ; le nom complet commence par l'espace : Ecole\Notes\Eleve.
Classe abstraiteelle ne s'instancie pas ; ses enfants écrivent les méthodes abstract.

Douze questions pour finir

Dernière étape : le quiz. Douze questions tirées au hasard, différentes à chaque partie. Si tu te trompes, lis bien l'explication.
Quiz final

Teste-toi

Sources

  1. The PHP Group, PHP Manual, « Classes and Objects » : « The Basics », « Properties » (types, readonly), « Constructors and Destructors » (promotion, parent::__construct), « Visibility ». bases, propriétés, constructeurs, visibilité (php.net), consulté le 8 octobre 2026.
  2. The PHP Group, PHP Manual : « Object Inheritance », « Object Interfaces », « Class Abstraction ». héritage, interfaces, classes abstraites (php.net), consulté le 8 octobre 2026.
  3. The PHP Group, PHP Manual : « Objects and references », « Object Cloning ». références, clone (php.net), consulté le 8 octobre 2026.
  4. The PHP Group, PHP Manual, PDO : « Prepared statements and stored procedures », « Errors and error handling » (ERRMODE_EXCEPTION par défaut depuis PHP 8.0). requêtes préparées, erreurs (php.net), consulté le 8 octobre 2026.
  5. OWASP, SQL Injection Prevention Cheat Sheet (requêtes paramétrées, limites pour les noms de tables et de colonnes). cheatsheetseries.owasp.org, consulté le 8 octobre 2026.
  6. The PHP Group, PHP Manual, « Static Keyword » : propriétés et méthodes static, accès avec self:: ou Classe::. mot-clé static (php.net), consulté le 8 octobre 2026.
  7. The PHP Group, PHP Manual, « Traits » : déclaration, use dans une classe, résolution des conflits de méthodes. traits (php.net), consulté le 8 octobre 2026.
  8. The PHP Group, PHP Manual, « Namespaces » : déclaration d'un espace de noms, nom complet des classes. espaces de noms (php.net), consulté le 8 octobre 2026.

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Tout le code a été exécuté avec PHP 8.4 ; les requêtes, avec PDO et SQLite.

Glisser pour continuer vers Les bases de PL/pgSQL
Gymnase 2