Ce quiz est construit comme un...
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.
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).
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
}
}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.
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
}
}É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();
}
}É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.
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.
É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();
}
}É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();
}
}É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();
}
}É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.
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 ?
implementsextendsinheritssuperQuelle est la méthode correcte pour redéfinir une méthode dans une sous-classe en Java ?
override@Overrideredefine@RedefineLequel des éléments suivants n’est pas un type de polymorphisme en Java ?
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();
}
}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();
}
}Quel mot-clé empêche une classe d’être héritée ?
privateprotectedfinalstaticQuelle 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();
}
}Quelle interface doit être implémentée pour créer une classe capable d’être triée ?
CloneableSerializableComparableIterableQuel est le concept de permettre à une méthode d’avoir des noms identiques mais des paramètres différents ?
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(); } } extends@OverridefinalComparableDeux outils concrets pour piloter la qualité sans alourdir vos équipes Un système qualité n’avance…
Un chantier se gagne souvent avant même l’arrivée des équipes. Quand tout est clair dès…
Le mariage a du sens quand il repose sur une décision libre, mûrie et partagée.…
Une étude de cas réussie commence par une structure sûre. Ce modèle Word vous guide…
Les soft skills se repèrent vite sur une fiche, mais elles ne pèsent vraiment que…
Outil de comparaison et repérage des offres étudiantes Choisir des verres progressifs ressemble rarement à…
This website uses cookies.