Héritage et Polymorphisme en Java : Exercices Corrigés
L’héritage et le polymorphisme sont deux concepts fondamentaux de la programmation orientée objet (POO). En Java, ils permettent de créer des programmes modulaires, réutilisables et maintenables. Cet article explore ces concepts à travers des explications détaillées et des exercices corrigés.
Héritage en Java
L’héritage en java permet à une classe de hériter des propriétés et des méthodes d’une autre classe. La classe qui hérite est appelée sous-classe (ou classe dérivée) et la classe dont elle hérite est appelée super-classe (ou classe de base).
Exemple de code
class Animal {
void manger() {
System.out.println("L'animal mange");
}
}
class Chien extends Animal {
void aboyer() {
System.out.println("Le chien aboie");
}
}
public class TestHéritage {
public static void main(String[] args) {
Chien chien = new Chien();
chien.manger(); // Appel de la méthode héritée
chien.aboyer(); // Appel de la méthode spécifique
}
}Polymorphisme en Java
Le polymorphisme en Java permet à une même méthode de se comporter différemment selon l’objet qui l’appelle. En Java, cela est réalisé principalement par deux mécanismes : la surcharge de méthode et la redéfinition de méthode.
Exemple de code
class Animal {
void faireDuBruit() {
System.out.println("L'animal fait du bruit");
}
}
class Chat extends Animal {
@Override
void faireDuBruit() {
System.out.println("Le chat miaule");
}
}
class Chien extends Animal {
@Override
void faireDuBruit() {
System.out.println("Le chien aboie");
}
}
public class TestPolymorphisme {
public static void main(String[] args) {
Animal monAnimal;
monAnimal = new Chat();
monAnimal.faireDuBruit(); // Appelle la méthode du Chat
monAnimal = new Chien();
monAnimal.faireDuBruit(); // Appelle la méthode du Chien
}
}Exercices Corrigés
Exercice 1 : Héritage de base
Énoncé : Créez une super-classe Personne avec des propriétés comme nom et âge, et une méthode sePrésenter(). Créez une sous-classe Étudiant qui ajoute une propriété numéroÉtudiant et redéfinit la méthode sePrésenter() pour inclure le numéro étudiant.
Solution :
class Personne {
String nom;
int âge;
Personne(String nom, int âge) {
this.nom = nom;
this.âge = âge;
}
void sePrésenter() {
System.out.println("Je m'appelle " + nom + " et j'ai " + âge + " ans.");
}
}
class Étudiant extends Personne {
String numéroÉtudiant;
Étudiant(String nom, int âge, String numéroÉtudiant) {
super(nom, âge);
this.numéroÉtudiant = numéroÉtudiant;
}
@Override
void sePrésenter() {
super.sePrésenter();
System.out.println("Mon numéro étudiant est " + numéroÉtudiant + ".");
}
}
public class TestHéritageExercice {
public static void main(String[] args) {
Étudiant étudiant = new Étudiant("Alice", 21, "123456");
étudiant.sePrésenter();
}
}Exercice 2 : Polymorphisme
Énoncé : Créez une classe Employé avec une méthode travailler(). Créez deux sous-classes Développeur et Designer qui redéfinissent la méthode travailler() pour décrire le travail spécifique de chaque type d’employé. Utilisez le polymorphisme pour appeler la méthode travailler() sur une instance d’Employé.
Solution :
class Employé {
void travailler() {
System.out.println("L'employé travaille");
}
}
class Développeur extends Employé {
@Override
void travailler() {
System.out.println("Le développeur écrit du code");
}
}
class Designer extends Employé {
@Override
void travailler() {
System.out.println("Le designer crée des maquettes");
}
}
public class TestPolymorphismeExercice {
public static void main(String[] args) {
Employé monEmployé;
monEmployé = new Développeur();
monEmployé.travailler();
monEmployé = new Designer();
monEmployé.travailler();
}
}Conclusion
L’héritage et le polymorphisme sont essentiels pour créer des applications Java modulaires et réutilisables. En comprenant et en pratiquant ces concepts à travers des exercices, les développeurs peuvent écrire du code plus efficace et plus facile à maintenir. Les exemples et exercices présentés ici devraient servir de base pour explorer davantage ces concepts fondamentaux de la POO.
Exercices Avancés : Héritage et Polymorphisme en Java avec des Cas Particuliers
Les exercices suivants visent à approfondir la compréhension de l’héritage et du polymorphisme en Java, en introduisant des cas particuliers et des scénarios réels. Ces exercices couvrent des concepts avancés tels que les classes abstraites, les interfaces, les méthodes génériques, et la composition.
Exercice 1 : Classe Abstraite et Méthodes Abstraites
Énoncé :
Créez une classe abstraite Animal avec une méthode abstraite faireDuBruit(). Créez des sous-classes concrètes Lion et Oiseau qui redéfinissent la méthode faireDuBruit() pour émettre des sons spécifiques. Créez une méthode main pour démontrer le comportement polymorphique.
Solution :
abstract class Animal {
abstract void faireDuBruit();
}
class Lion extends Animal {
@Override
void faireDuBruit() {
System.out.println("Le lion rugit");
}
}
class Oiseau extends Animal {
@Override
void faireDuBruit() {
System.out.println("L'oiseau chante");
}
}
public class TestAbstrait {
public static void main(String[] args) {
Animal monAnimal;
monAnimal = new Lion();
monAnimal.faireDuBruit();
monAnimal = new Oiseau();
monAnimal.faireDuBruit();
}
}Exercice 2 : Interface et Polymorphisme
Énoncé :
Créez une interface Volant avec une méthode voler(). Créez deux classes Avion et Superman qui implémentent cette interface. Utilisez le polymorphisme pour appeler la méthode voler() sur une instance de Volant.
Solution :
interface Volant {
void voler();
}
class Avion implements Volant {
@Override
public void voler() {
System.out.println("L'avion vole dans le ciel");
}
}
class Superman implements Volant {
@Override
public void voler() {
System.out.println("Superman vole pour sauver le monde");
}
}
public class TestInterface {
public static void main(String[] args) {
Volant monVolant;
monVolant = new Avion();
monVolant.voler();
monVolant = new Superman();
monVolant.voler();
}
}Exercice 3 : Généricité et Polymorphisme
Énoncé :
Créez une classe générique Boîte<T> qui peut contenir un objet de n’importe quel type. Ajoutez une méthode afficherContenu() pour afficher le contenu de la boîte. Testez cette classe avec différents types, tels que String, Integer, et une classe utilisateur Personne.
Solution :
class Boîte<T> {
private T contenu;
Boîte(T contenu) {
this.contenu = contenu;
}
void afficherContenu() {
System.out.println("Contenu de la boîte : " + contenu.toString());
}
}
class Personne {
String nom;
int âge;
Personne(String nom, int âge) {
this.nom = nom;
this.âge = âge;
}
@Override
public String toString() {
return "Personne[nom=" + nom + ", âge=" + âge + "]";
}
}
public class TestGénéricité {
public static void main(String[] args) {
Boîte<String> boîteString = new Boîte<>("Bonjour");
boîteString.afficherContenu();
Boîte<Integer> boîteInteger = new Boîte<>(123);
boîteInteger.afficherContenu();
Personne personne = new Personne("Alice", 30);
Boîte<Personne> boîtePersonne = new Boîte<>(personne);
boîtePersonne.afficherContenu();
}
}Exercice 4 : Composition et Héritage
Énoncé :
Créez une classe Adresse avec des propriétés rue, ville et codePostal. Créez une classe Personne avec des propriétés nom, âge et une propriété Adresse. Implémentez une méthode afficherInfo() dans Personne pour afficher les informations de la personne et de son adresse. Montrez comment la composition est utilisée en créant une instance de Personne avec une adresse.
Solution :
class Adresse {
String rue;
String ville;
String codePostal;
Adresse(String rue, String ville, String codePostal) {
this.rue = rue;
this.ville = ville;
this.codePostal = codePostal;
}
@Override
public String toString() {
return rue + ", " + ville + ", " + codePostal;
}
}
class Personne {
String nom;
int âge;
Adresse adresse;
Personne(String nom, int âge, Adresse adresse) {
this.nom = nom;
this.âge = âge;
this.adresse = adresse;
}
void afficherInfo() {
System.out.println("Nom: " + nom);
System.out.println("Âge: " + âge);
System.out.println("Adresse: " + adresse);
}
}
public class TestComposition {
public static void main(String[] args) {
Adresse adresse = new Adresse("123 Rue Principale", "Paris", "75000");
Personne personne = new Personne("Jean Dupont", 40, adresse);
personne.afficherInfo();
}
}Ces exercices avancés explorent des concepts plus complexes de l’héritage et du polymorphisme en Java, en incluant des cas particuliers et des scénarios réels.
QCM sur Héritage et Polymorphisme en Java
Pour chaque question, choisissez la meilleure réponse parmi les options proposées.
Questions
Quel mot-clé est utilisé pour hériter d’une classe en Java ?
- a)
implements - b)
extends - c)
inherits - d)
super
Quelle est la méthode correcte pour redéfinir une méthode dans une sous-classe en Java ?
- a) Utiliser le mot-clé
override - b) Utiliser le mot-clé
@Override - c) Utiliser le mot-clé
redefine - d) Utiliser le mot-clé
@Redefine
Lequel des éléments suivants n’est pas un type de polymorphisme en Java ?
- a) Polymorphisme statique
- b) Polymorphisme dynamique
- c) Polymorphisme de classe
- d) Polymorphisme d’interface
Quelle est la sortie du programme suivant
class Animal {
void faireDuBruit() {
System.out.println("L'animal fait du bruit");
}
}
class Chien extends Animal {
@Override
void faireDuBruit() {
System.out.println("Le chien aboie");
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Chien();
animal.faireDuBruit();
}
}- a) L’animal fait du bruit
- b) Le chien aboie
- c) Erreur de compilation
- d) Erreur à l’exécution
Quelle est la sortie du programme suivant ?
class Parent {
void afficher() {
System.out.println("Parent");
}
}
class Enfant extends Parent {
void afficher() {
System.out.println("Enfant");
}
void afficherParent() {
super.afficher();
}
}
public class Test {
public static void main(String[] args) {
Enfant e = new Enfant();
e.afficher();
e.afficherParent();
}
}- a) Enfant
Parent - b) Parent
Enfant - c) Enfant
Enfant - d) Parent
Parent
Quel mot-clé empêche une classe d’être héritée ?
- a)
private - b)
protected - c)
final - d)
static
Quelle est la sortie du programme suivant ?
class A {
static void afficher() {
System.out.println("Classe A");
}
}
class B extends A {
static void afficher() {
System.out.println("Classe B");
}
}
public class Test {
public static void main(String[] args) {
A a = new B();
a.afficher();
}
}- a) Classe A
- b) Classe B
- c) Erreur de compilation
- d) Erreur à l’exécution
Quelle interface doit être implémentée pour créer une classe capable d’être triée ?
- a)
Cloneable - b)
Serializable - c)
Comparable - d)
Iterable
Quel est le concept de permettre à une méthode d’avoir des noms identiques mais des paramètres différents ?
- a) Héritage
- b) Redéfinition de méthode
- c) Surcharge de méthode
- d) Encapsulation
- Quelle est la sortie du programme suivant ?
interface I { void afficher(); } class C implements I { public void afficher() { System.out.println("Classe C"); } } public class Test { public static void main(String[] args) { I i = new C(); i.afficher(); } }- a) Classe I
- b) Classe C
- c) Erreur de compilation
- d) Erreur à l’exécution
Réponses
- b)
extends - b) Utiliser le mot-clé
@Override - c) Polymorphisme de classe
- b) Le chien aboie
- a) Enfant
Parent - c)
final - a) Classe A
- c)
Comparable - c) Surcharge de méthode
- b) Classe C
Autres articles
