Propriété
Une variable propre à chaque objet, déclarée dans la classe. Depuis PHP 7.4, on la type (string, array…).1
Informatique · 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 quizAprès cette fiche, tu sais
new ;$b = $a avec un objet, et quand utiliser clone ;private, protected et des méthodes qui valident ;static, les traits et les espaces de noms, et interroger une base avec PDO et des requêtes préparées.Attends, tu veux dire que $a change aussi ? Je pensais le contraire.
Un plan, puis des objets
Notion 1 · Classe et objet
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
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.
Quatre mots à connaître. Fais défiler pour les empiler.
Une variable propre à chaque objet, déclarée dans la classe. Depuis PHP 7.4, on la type (string, array…).1
Une fonction de la classe, appelée sur un objet avec -> : $lea->moyenne().1
__construct() est appelé automatiquement sur chaque nouvel objet : c'est l'endroit pour l'initialiser.1
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.
<?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.
$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
La même méthode donne 5,25 pour Léa et 3 pour Noah.
Fais défiler : le code s'exécute ligne après ligne. Deux objets naissent du même plan, et chacun garde ses notes.
Un plan, pas encore d'élève
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;.
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
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
Le code
<?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)
Oui, je crois : $b et $a mènent au même élève.
clone.Copier ou cloner
$b = $a ne copie que la flèche. clone fabrique un deuxième objet, une copie de l'original.3
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
Fais défiler : chaque variable est une étiquette qui pointe vers un objet numéroté, comme dans var_dump (object(Eleve)#1).
Un objet, une variable
Vrai seulement s'il s'agit de la même instance.
La fonction reçoit une copie de l'identifiant : si elle change une propriété, l'objet de l'appelant change.3
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
Rappel de la fiche précédente : un tableau affecté ou passé à une fonction est copié. Les objets se comportent autrement.
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
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
On garde les données private et on n'expose que des méthodes qui les vérifient : c'est l'encapsulation.
Le code
<?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.
$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.
Fais défiler : on regarde la même classe depuis l'extérieur, depuis une classe enfant, puis depuis la classe elle-même.
Depuis l'extérieur
Une méthode refuse une valeur impossible en lançant une exception ; l'appelant la rattrape avec try … catch.
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
Compte peut lire le private $solde d'un autre objet Compte.1Compte 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
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
Le code
<?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.
$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
Est-ce un compte ?
Un compte d'épargne est un compte : $e instanceof Compte vaut true.1
Fais défiler : les membres hérités descendent de Compte dans CompteEpargne, puis servent.
Deux classes
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
$e instanceof Compte vaut true : un compte d'épargne est un compte.
Une classe final ne peut pas avoir d'enfant ; PHP refuse class Fille extends Base si Base est final.
Un enfant peut assouplir une visibilité (protected vers public), jamais la restreindre.2
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
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
Une fonction qui attend Forme accepte tout objet qui respecte le contrat : c'est le polymorphisme.2
Le code
<?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.
echo aireTotale([new Rectangle(3, 4), new Cercle(1)]);
15.14
Fais défiler : la même ligne $f->aire() exécute deux méthodes différentes.
Rectangle et Cercle implements Forme : chacune a sa méthode aire(), écrite à sa façon.2
$f est un Rectangle : $f->aire() exécute la méthode de Rectangle, 3 × 4 = 12.
$f est un Cercle : la même ligne exécute la méthode de Cercle, π × 1², arrondi à 3,14.
aireTotale renvoie 15,14 sans jamais savoir quelles classes existent : il lui suffit que chaque objet respecte le contrat Forme.
Classe abstraite
Une classe abstract ne s'instancie pas. Elle peut contenir du code, et une méthode abstract que ses enfants doivent écrire.2
<?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
| interface | classe abstraite | |
|---|---|---|
| Contient du code | non, seulement des signatures de méthodes | oui, des méthodes complètes et des méthodes abstraites |
| Instanciable | non | non |
| Une classe peut en avoir | plusieurs (implements A, B) | une seule (extends) |
| Quand l'utiliser | pour un contrat commun à des classes sans lien | pour 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
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
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
<?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
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.
La saisie
Le code
<?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.
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
Trois questions sur PDO et l'injection SQL.
Trois notions de plus
Notion 7 · static
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
Une méthode static n'a pas de $this : on l'appelle avec Eleve::nombre().6
Le code
<?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 rassemble des méthodes. Une classe l'insère avec use, sans en hériter : une classe peut utiliser plusieurs traits.7
Un trait ne s'instancie pas : new Salut() lève Cannot instantiate trait Salut.7
Le code
<?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
Un namespace range les classes dans un espace. Le nom complet d'une classe commence par cet espace : Ecole\Notes\Eleve.8
Le code
<?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
Eleve, Compte) ;private et typées par défaut, readonly quand elles ne doivent plus changer ;protected seulement quand un enfant en a vraiment besoin ;Habitudes de pro (suite)
$b = $a partage l'objet, et utiliser clone pour une copie ;Forme $f) plutôt que par une classe précise ;prepare() et execute() pour les valeurs, jamais de concaténation.Tous les corrigés ont été exécutés avec PHP 8.4.
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.
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.
$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
Douze questions pour finir
self:: ou Classe::. mot-clé static (php.net), consulté le 8 octobre 2026.use dans une classe, résolution des conflits de méthodes. traits (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.