Cours : Héritage et abstraction

Les notions du jour

Héritage

Abstraction

L'héritage est un principe de POO qui permet entre autre de factoriser le code en créant des classes qui partagent des attributs et des méthodes.

Exemple sans héritage

Imaginons que nous avons deux types d'utilisateurs : les Readeret les Author. Ces deux types d'utilisateurs ont un email, un mot de passe et peuvent se connecter. Le Reader peut mettre des livres en favori, l' Author peut publier des livres.

Sans héritage nous allons devoir définir nos deux classes comme suit :

class Reader 
{
    private string $email;
    private string $password;
    private array $favoriteBooks;

    public function __construct(){}
    public function login() : void {}
    public function addBookToFavorites(Book $book): void {}
    public function removeBookFromFavorites(Book $book): void {}  
}

class Author 
{
    private string $email;
    private string $password;
    private array $publishedBooks;

    public function __construct(){}
    public function login() : void {}
    public function publishBook(Book $book) : void {}  
}

Et nous avons donc pas mal de code dupliqué entre nos deux classes.

Exemple avec héritage

class User 
{
    protected string $email;
    protected string $password;

    public function __construct(){}
    public function login() : void {}
}

class Reader extends User
{
    private array $favoriteBooks;

    public function __construct(){}
    public function addBookToFavorites(Book $book): void {}
    public function removeBookFromFavorites(Book $book): void {}  
}

class Author extends User
{
    private array $publishedBooks;

    public function __construct(){}
    public function publishBook(Book $book) : void {}  
}

En PHP pour signaler qu'une classe hérite d'une autre, on utilise le mot clé extends.

Ici, User est la classe mère et contient le code commun. Reader et Author sont des classes filles qui héritent de User. En héritant de User, elle vont avoir les attributs et méthodes de User sans avoir besoin de les redéclarer.

Si vous instanciez un User, il pourra se connecter.

Si vous instanciez un Reader, il pourra se connecter et gérer ses livres favoris.

Si vous instanciez un Author, il pourra se connecter et publier des livres.

Héritage et substitution

Si une classe hérite d'une autre classe, on dit qu'elle peut s'y substituer. En pratique cela signifie qui si une fonction prend un User en paramètre et que vous lui passer un Author ou un Reader cela fonctionnera.

function checkLogin(User $user) : bool 
{
    return true;
}

$author = new Author();
$reader = new Reader();
$user = new User();

checkLogin($author); // fonctionne
checkLogin($reader); // fonctionne
checkLogin($user); // fonctionne

L'inverse est par contre faux. Si un Author est une forme de User, un User n'est pas une forme d' Author, il lui manque un attribut et une méthode.

function findFavoritesFromAuthor(Reader $reader, Author $author) : array
{
    return [];
}

$author = new Author();
$reader = new Reader();
$user = new User();

findFavoritesFromAuthor($reader, $author); // fonctionne
findFavoritesFromAuthor($user, $user); // ne fonctionne pas
findFavoritesFromAuthor($author, $reader); // ne fonctionne pas

Le mot clé protected

Nous allons voir le troisième et dernier modificateur de visibilité : protected.

Ce mot clé signifie private sauf pour les classes filles.

Si un attribut ou une méthode est protected, il est private pour tous les action en dehors de la classe SAUF si ces actions sont réalisées dans une classe fille.

Le constructeur de la classe mère

Si pour une raison quelconque vous avez besoin de faire un comportement spécifique pour le constructeur d'une classe mère vous pouvez utiliser cette syntaxe :

class Author extends User
{
    private array $publishedBooks;

    public function __construct(){
        parent::__construct(); // appelle le constructeur de la classe mère
    }

    public function publishBook(Book $book) : void {}  
}

Exercices sur l'héritage

L'abstraction

L'abstraction va de pair avec l'héritage. Une classe abstraite c'est une classe qu'on ne peut pas instancier. Elles sont très utiles pour transmettre par héritage des attributs ou méthodes à leurs classes filles sans pour autant pouvoir exister seules.

Pour déclarer une classe abstraite, il suffit d'utiliser le mot-clé abstract:

abstract class AbtractManager
{
    protected PDO $db;

    public function __construct()
    {
        // initialiser la base de données
    }
}

class CategoryManager extends AbtractManager
{
    private array $categories = [];

    public function __construct()
    {
        parent::__construct();
    }
    // ...
}

class PostManager extends AbtractManager
{
    private array $posts = [];

    public function __construct()
    {
        parent::__construct();
    }
    // ...
}

Mini-projet Blog

23 June 2025