L’héritage en Java : Un Guide Didactique et des Exercices Corrigés

L’héritage est un concept fondamental en programmation orientée objet (POO). Il permet de créer une nouvelle classe à partir d’une classe existante, facilitant ainsi la réutilisation du code et l’extension des fonctionnalités. En Java, l’héritage est réalisé à l’aide du mot-clé extends.

Pourquoi l’Héritage est-il Important?

Réutilisation du Code : L’héritage permet de réutiliser les classes existantes, réduisant ainsi la duplication du code.
Extension des Fonctionnalités : Vous pouvez étendre les fonctionnalités des classes existantes sans les modifier.
Hiérarchie des Classes : Il aide à organiser les classes en une hiérarchie logique, rendant le code plus compréhensible et maintenable.

Exercice 1 : Création d’une Classe de Base et d’une Classe Dérivée

Objectif : Comprendre comment créer une classe dérivée à partir d’une classe de base.

Énoncé : Créez une classe de base appelée Person avec les attributs name et age. Créez une classe dérivée appelée Student qui hérite de Person et ajoute un attribut studentId.

Solution :

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

class Student extends Person {
    int studentId;

    Student(String name, int age, int studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    void display() {
        super.display();
        System.out.println("Student ID: " + studentId);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student("Alice", 20, 12345);
        student.display();
    }
}

Intérêt : Cet exercice illustre comment créer des classes dérivées et comment utiliser le mot-clé super pour appeler les constructeurs et les méthodes de la classe de base.

Exercice 2 : Redéfinition de Méthodes (Override)

Objectif : Apprendre à redéfinir les méthodes de la classe de base dans la classe dérivée.

Énoncé : Créez une méthode display dans la classe Student qui redéfinit la méthode display de la classe Person pour inclure l’affichage de l’attribut studentId.

Solution :

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

class Student extends Person {
    int studentId;

    Student(String name, int age, int studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    @Override
    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Student ID: " + studentId);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student("Bob", 22, 67890);
        student.display();
    }
}

Intérêt : Cet exercice montre comment redéfinir des méthodes pour personnaliser le comportement des classes dérivées, un aspect crucial de l’héritage.

Exercice 3 : Polymorphisme avec l’Héritage

Objectif : Comprendre le concept de polymorphisme en utilisant l’héritage.

Énoncé : Créez une classe Teacher qui hérite de Person et ajoute un attribut teacherId. Créez un tableau de Person qui contient des objets Student et Teacher, puis affichez les informations de chaque objet.

Solution :

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

class Student extends Person {
    int studentId;

    Student(String name, int age, int studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    @Override
    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Student ID: " + studentId);
    }
}

class Teacher extends Person {
    int teacherId;

    Teacher(String name, int age, int teacherId) {
        super(name, age);
        this.teacherId = teacherId;
    }

    @Override
    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Teacher ID: " + teacherId);
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = {
            new Student("Charlie", 21, 11223),
            new Teacher("David", 45, 33445)
        };

        for (Person person : people) {
            person.display();
            System.out.println();
        }
    }
}

Intérêt : Cet exercice démontre le polymorphisme, où une référence de type Person peut pointer vers des objets de sous-classes Student et Teacher, permettant un comportement spécifique à chaque type lors de l’appel de la méthode display.

Conclusion

Ces exercices illustrent les concepts clés de l’héritage en Java, tels que la création de classes dérivées, la redéfinition de méthodes et le polymorphisme. En comprenant et en pratiquant ces concepts, vous serez mieux préparé à concevoir des systèmes robustes et réutilisables en programmation orientée objet.

Modèle de QCM Piège avec Dégradation du Niveau

L’objectif de ce QCM est de tester les connaissances des étudiants sur l’héritage en Java, tout en introduisant des pièges subtils pour évaluer leur compréhension approfondie du sujet. Les questions deviennent progressivement plus difficiles.

Question 1 : Concepts de Base

1. Quel mot-clé est utilisé pour créer une classe dérivée en Java ?

A) derive
B) inherit
C) extends
D) implements

Piège : implements est souvent confondu avec extends par les débutants.

Réponse correcte : C

Question 2 : Constructeurs

2. Quelle est la bonne façon d’appeler le constructeur de la classe de base dans une classe dérivée ?

A) super()
B) base()
C) parent()
D) superclass()

Piège : parent() et superclass() peuvent sembler logiques mais sont incorrects.

Réponse correcte : A

Question 3 : Redéfinition de Méthodes

3. Quelle annotation est utilisée pour indiquer qu’une méthode est redéfinie dans une classe dérivée ?

A) @Override
B) @Redefine
C) @Extend
D) @Inherited

Piège : @Inherited peut sembler pertinent car il ressemble à “héritage”, mais il est incorrect.

Réponse correcte : A

Question 4 : Polymorphisme

4. Quelle est la sortie du code suivant ?

class Person {
    void display() {
        System.out.println("Person");
    }
}

class Student extends Person {
    void display() {
        System.out.println("Student");
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.display();
    }
}

A) Person
B) Student
C) PersonStudent
D) Erreur de compilation

Piège : Le piège ici est de croire que la méthode de la classe de base sera appelée.

Réponse correcte : B

Question 5 : Champs et Méthodes Statics

5. Quelle est la sortie du code suivant ?

class Parent {
    static void display() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    static void display() {
        System.out.println("Child");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        p.display();
    }
}

A) Parent
B) Child
C) ParentChild
D) Erreur de compilation

Piège : Les méthodes statiques ne sont pas polymorphiques.

Réponse correcte : A

Question 6 : Accès aux Membres de la Classe de Base

6. Quelle est la sortie du code suivant ?

class Animal {
    String name = "Animal";
}

class Dog extends Animal {
    String name = "Dog";

    void printName() {
        System.out.println(name);
        System.out.println(super.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.printName();
    }
}

A) Dog Animal
B) Animal Dog
C) Dog Dog
D) Animal Animal

Piège : Comprendre l’usage de super pour accéder aux membres de la classe de base.

Réponse correcte : A

Conclusion

Ce modèle de QCM présente des pièges courants auxquels les étudiants pourraient être confrontés lorsqu’ils apprennent l’héritage en Java. En répondant correctement à ces questions, ils montrent une compréhension approfondie des concepts et des subtilités de l’héritage en Java.

Exercices_Heritage_Java Télécharger