Exercice Java Corrigé sur POO – Polymorphism

// Déclarer la classe Animal
class Animal {
    // Méthode pour afficher le bruit que fait l'animal
    public void faireBruit() {
        System.out.println("L'animal émet un bruit");
    }
} 


// Déclarez la classe Chat qui hérite la classe Animal
class Chat extends Animal {
    // Surcharger la méthode faireBruit pour fournir une 
    // implémentation spécifique pour Chat
    @Override
    public void faireBruit() {
        System.out.println("Le chat meow");
    }
}


// Déclarez la classe Chien qui hérite la classe Animal
class Chien extends Animal {
    // Surcharger la méthode faireBruit pour fournir une 
    // implémentation spécifique pour Chien
    @Override
    public void faireBruit() {
        System.out.println("Le chien aboie");
    }
}


// Déclarez la classe Main
public class Main {
    // Méthode principale : point d'entrée du programme
    public static void main(String[] args) {
        // Créer une instance de Animal
        Animal animal = new Animal();
        // Créer une instance de Chat
        Chat chat = new Chat();
        // Créer une instance de Chien
        Chien chien = new Chien();

        // Appeler la méthode faireBruit sur l'instance Animal
        animal.faireBruit(); // Sortie: L'animal émet un bruit
        // Appeler la méthode faireBruit sur l'instance Chat
        chat.faireBruit();   // Sortie: Le chat meow
        // Appeler la méthode faireBruit sur l'instance Chien
        chien.faireBruit();  // Sortie: Le chien aboie
    }
} 

Sortie:

L'animal émet un bruit
Le chat meow
Le chien aboie

Explication:

Le polymorphisme en Java permet à une méthode d’avoir plusieurs formes. Il permet d’utiliser une même méthode ou une même interface pour différentes classes.

// Déclarer la classe Vehicule
class Vehicle {
    // Champ privé pour stocker la vitesse du véhicule
    private int vitesse;

    // Méthode pour augmenter la vitesse du véhicule de 10
    public void augmenterVitesse() {
        vitesse += 10;
    }

    // Méthode pour récupérer la vitesse actuelle du véhicule
    public int getVitesse() {
        return vitesse;
    }
} 


// Déclarez la classe Voiture qui hérite la classe Vehicule
class Voiture extends Vehicle {
    // Surcharger la méthode augmenterVitesse de la classe Vehicle
    @Override
    public void augmenterVitesse() {
        // Appeler la méthode augmenterVitesse de la classe mère
        super.augmenterVitesse();
        // Afficher un message indiquant que la vitesse de la voiture 
        // a augmenté
        System.out.println("\nVitesse de la voiture augmentée de 30 unités.");
    }
} 


// Déclarez la classe Bicyclette qui hérite la classe Vehicule
class Bicyclette extends Vehicle {
    // Surcharger la méthode augmenterVitesse de la classe Vehicle
    @Override
    public void augmenterVitesse() {
        // Appeler la méthode augmenterVitesse de la classe mère
        super.augmenterVitesse();
        // Afficher un message indiquant que la vitesse de la voiture 
        // a augmenté
        System.out.println("Vitesse de la bicyclette augmentée de 15 unités.");
    }
} 


// Déclarez la classe Main
public class Main {
    // Méthode principale: le point d'entrée du programme
    public static void main(String[] args) {
        // Créer une instance de la classe Voiture
        Voiture voiture = new Voiture();
        // Créer une instance de la classe Bicyclette
        Bicyclette bicyclette = new Bicyclette();

        // Afficher la vitesse initiale de la voiture
        System.out.println("Vitesse initiale de la voiture: "+ voiture.getVitesse());
        // Afficher la vitesse initiale de la bicyclette
        System.out.println("Vitesse initiale de la bicyclette: "+ bicyclette.getVitesse());

        // Accélérer la voiture
        voiture.augmenterVitesse();
        // Accélérer la bicyclette
        bicyclette.augmenterVitesse();

        // Affichez la vitesse de la voiture après avoir accéléré
        System.out.println("\nVitesse de la voiture après avoir accéléré: " + voiture.getVitesse());
        // Affichez la vitesse de la bicyclette après avoir accéléré
        System.out.println("Vitesse de la bicyclette après avoir accéléré: " + bicyclette.getVitesse());
    }
} 

Sortie:

Vitesse initiale de la voiture: 0
Vitesse initiale de la bicyclette: 0

Vitesse de la voiture augmentée de 30 unités.
Vitesse de la bicyclette augmentée de 15 unités.

Vitesse de la voiture après avoir accéléré: 10
Vitesse de la bicyclette après avoir accéléré: 10

// Déclarer la classe Forme
class Forme {
    // Méthode de calcul de la surface de la forme
    // L'implémentation par défaut renvoie 0
    public double calculerSurface() {
        return 0;
    }
}


// Définir la classe Cercle comme une sous-classe de Forme
class Cercle extends Forme {

    // Déclarer une variable pour le rayon
    private double rayon;

    // Constructeur pour la classe Cercle qui prend le rayon comme 
    // paramètre
    public Cercle(double rayon) {
        // Affecter le paramètre rayon à la variable rayon
        this.rayon = rayon;
    }

    // Surcharger la méthode calculerSurface de la classe Forme
    @Override
    public double calculerSurface() {
        // Calculer et renvoyer la surface du cercle à l'aide de la 
        // formule πr²
        return Math.PI * rayon * rayon;
    }
} 


// Définir la classe Rectangle comme une sous-classe de Forme
class Rectangle extends Forme {

    // Déclarer les variables largeur et hauteur
    private double largeur;
    private double hauteur;

    // Constructeur pour la classe Rectangle qui prend la largeur et 
    // la hauteur comme paramètres
    public Rectangle(double largeur, double hauteur) {
        this.largeur = largeur;
        this.hauteur = hauteur;
    }

    // Surcharger la méthode calculerSurface de la classe Forme
    @Override
    public double calculerSurface() {
        // Calculer et renvoyer la surface du rectangle en utilisant 
        // la formule largeur * hauteur
        return largeur * hauteur;
    }
} 


// Définir la classe Triangle comme une sous-classe de Forme
class Triangle extends Forme {

    // Déclarer les variables base et hauteur
    private double base;
    private double hauteur;

    // Constructeur pour la classe Triangle qui prend la base et la 
    // hauteur comme paramètres
    public Triangle(double base, double hauteur) {
        this.base = base;
        this.hauteur = hauteur;
    }

    // Surcharger la méthode calculerSurface de la classe Forme
    @Override
    public double calculerSurface() {
        // Calculer et renvoyer l'aire du triangle en utilisant la 
        // formule 0,5 * base * hauteur
        return 0.5 * base * hauteur;
    }
}


// Définir la classe Main
public class Main {

    // Méthode principale qui sert de point d'entrée à l'application
    public static void main(String[] args) {

        // Créer un objet Cercle avec un rayon de 5
        Cercle cercle = new Cercle(5);
        // Afficher la surface de l'objet Cercle
        System.out.println("Surface du cercle: " + cercle.calculerSurface());

        // Créer un objet Rectangle avec une largeur de 15 et une 
        // hauteur de 32
        Rectangle rectangle = new Rectangle(15, 32);
        // Afficher la surface de l'objet Rectangle
        System.out.println("\nSurface du rectangle: "+ rectangle.calculerSurface());

        // Créer un objet Triangle de base 6 et de hauteur 8
        Triangle triangle = new Triangle(6, 8);
        // Afficher la surface de l'objet Triangle
        System.out.println("\nSurface du Triangle: "+ triangle.calculerSurface());
    }
}

Sortie:

Surface du cercle: 78.53981633974483

Surface du rectangle: 480.0

Surface du Triangle: 24.0

// Définir la classe Employee
class Employee {

    // Déclarer des variables (nom et role)
    private String nom;
    private String role;

    // Constructeur pour la classe Employee qui prend le nom et le 
    // role comme paramètres
    public Employee(String nom, String role) {
        this.nom = nom;
        this.role = role;
    }

    // Méthode pour récupérer le nom de l'employé
    public String getNom() {
        // Renvoyer le nom de l'employé
        return nom;
    }

    // Méthode pour récupérer le role de l'employé
    public String getRole() {
        // Renvoyer le role de l'employé
        return role;
    }

    // Méthode pour calculer le salaire de l'employé
    public double calculerSalaire() {
        // Renvoyer 0.0 comme salaire par défaut
        return 0.0;
    }
} 


// Définir la classe Directeur comme une sous-classe de Employee
class Directeur extends Employee {

    // Déclarer les variables baseSalaire et bonus
    private double baseSalaire;
    private double bonus;

    // Constructeur de la classe Directeur qui prend comme paramètres 
    // le nom, le salaire de base et le bonus.
    public Directeur(String nom, double baseSalaire, double bonus) {
        // Appeler le constructeur de la super-classe Employee avec 
        // le nom et le rôle Directeur
        super(nom, "Directeur");
        this.baseSalaire = baseSalaire;
        this.bonus = bonus;
    }

    // Surcharger la méthode calculerSalaire de la classe Employee
    @Override
    public double calculerSalaire() {
        // Calculer et renvoyer le salaire du directeur en 
        // additionnant le salaire de base et le bonus.
        return baseSalaire + bonus;
    }
} 


// Définir la classe Programmeur comme une sous-classe de Employee
class Programmeur extends Employee {

    // Déclarer les variables baseSalaire et paiementHeuresSuppl
    private double baseSalaire;
    private double paiementHeuresSuppl;

    // Constructeur de la classe Programmeur qui prend comme 
    // paramètres le nom, le salaire de base et la rémunération 
    // des heures supplémentaires.
    public Programmeur(String nom, double baseSalaire, double paiementHeuresSuppl) {
        // Appeler le constructeur de la super-classe Employee avec 
        // le nom et le rôle Programmeur
        super(nom, "Programmeur");
        this.baseSalaire = baseSalaire;
        this.paiementHeuresSuppl = paiementHeuresSuppl;
    }

    // Remplacer la méthode calculerSalaire de la classe Employee
    @Override
    public double calculerSalaire() {
        // Calculer et renvoyer le salaire du programmeur en 
        // additionnant baseSalaire et paiementHeuresSuppl.
        return baseSalaire + paiementHeuresSuppl;
    }
}


// Définir la classe Main
public class Main {
    // Méthode principale qui sert de point d'entrée à l'application
    public static void main(String[] args) {
        // Créer un objet Directeur
        Employee emp1 = new Directeur("Alex Bio", 8500.0, 1200.0);
        // Créer un objet Programmeur
        Employee emp2 = new Programmeur("Emily Chio", 6000.0, 400.0);
        // Afficher le nom, le rôle et le salaire de l'objet 
        // Directeur
        System.out.println("Directeur: "+ emp1.getNom() +"\nRole: "+ emp1.getRole() +"\nSalaire: "+ emp1.calculerSalaire()+" €");
        // Afficher le nom, le rôle et le salaire de l'objet 
        // Programmeur
        System.out.println("\nProgrammeur: "+ emp2.getNom() +"\nRole: "+ emp2.getRole() +"\nSalaire: "+ emp2.calculerSalaire()+" €");
    }
}

Sortie:

Directeur: Alex Bio
Role: Directeur
Salaire: 9700.0 €

Programmeur: Emily Chio
Role: Programmeur
Salaire: 6400.0 €

// Définir la classe Sports
class Sports {
    public void play() {
        System.out.println("Faire du sport...\n");
    }
} 


// Définir la classe Football comme une sous-classe de Sports
class Football extends Sports {
    // Surcharger la méthode play de la classe Sports
    @Override
    public void play() {
        // Print "Playing football..." to the console
        System.out.println("Faire du football...");
    }
} 


// Définir la classe Basketball comme une sous-classe de Sports
class Basketball extends Sports {
    // Surcharger la méthode play de la classe Sports
    @Override  
    public void play() {
        System.out.println("Faire du basketball...");
    }
} 


// Définir la classe Rugby comme une sous-classe de Sports
class Rugby extends Sports {
    // Surcharger la méthode play de la classe Sports
    @Override  
    public void play() {
        System.out.println("Faire du rugby..."); 
    }
} 


// Déclarer la classe Main
public class Main {  
    public static void main(String[] args) {
        // Créer une instance de la classe Sports	
        Sports sports = new Sports(); 
        // Créer une instance de la classe Football		
        Football football = new Football(); 
        // Créer une instance de la classe Basketball		
        Basketball basketball = new Basketball(); 
        // Créer une instance de la classe Rugby		
        Rugby rugby = new Rugby();  

        // Appeler la méthode play sur l'instance Sports
        sports.play();
        // Appeler la méthode play sur l'instance Sports Football		
        football.play();
        // Appeler la méthode play sur l'instance Sports Basketball 		
        basketball.play(); 
        // Appeler la méthode play sur l'instance Sports Rugby		
        rugby.play();  
    }
} 

Sortie:

Faire du sport...

Faire du football...
Faire du basketball...
Faire du rugby...

// Définir une classe nommée CompteBancaire
class CompteBancaire {    
    // Déclarer une variable privée de type double appelée solde
    private double solde;  
    
    // Définir un constructeur qui prend un double initialBalance en 
    // paramètre
    public CompteBancaire(double initialBalance) {    
        // Assigner le paramètre initialBalance à la variable
        // d'instance solde
        this.solde = initialBalance;  
    }  
    
    // Définir une méthode pour obtenir le solde actuel
    public double getSolde() {    
        // Retourner le solde actuel
        return solde;  
    }  
    
    // Définir une méthode pour déposer un montant sur le solde
    public void deposer(double montant) {    
        // Ajouter le montant au solde actuel
        solde += montant;  
    }  
    
    // Définir une méthode pour retirer un montant du solde
    public void retirer(double montant) {    
        // Vérifier si le montant à retirer est inférieur ou égal au 
        // solde actuel
        if (montant <= solde) {      
            // Soustraire le montant du solde actuel
            solde -= montant;    
        } else {      
            // Afficher "Fonds insuffisants." dans la console si le 
            // solde est insuffisant
            System.out.println("Fonds insuffisants.");    
        }  
    }
} 

// Définir une classe nommée CompteEpargne qui hérite CompteBancaire
class CompteEpargne extends CompteBancaire {    
    // Déclarer une variable privée de type double appelée limit
    private double limit;  
    
    // Définir un constructeur qui prend un double initialBalance et 
    // un double limit en paramètres
    public CompteEpargne(double initialBalance, double limit) {    
        // Appeler le constructeur de la superclasse CompteBancaire 
        // avec initialBalance
        super(initialBalance);    
        // Assigner le paramètre limit à la variable d'instance limit
        this.limit = limit;  
    }  
    
    // Redéfinir la méthode retirer de la classe CompteBancaire
    @Override  
    public void retirer(double montant) {    
        // Vérifier si le montant à retirer est inférieur ou égal à 
        // la limite de retrait
        if (montant <= limit) {      
            // Appeler la méthode retirer de la superclasse 
            // CompteBancaire avec le montant
            super.retirer(montant);    
        } else {      
            // Afficher "Limite de retrait dépassée." dans la console 
            // si le montant dépasse la limite de retrait
            System.out.println("Limite de retrait dépassée.");    
        }  
    }
} 

// Définir une classe nommée CompteCheque qui hérite CompteBancaire
class CompteCheque extends CompteBancaire {    
    // Déclarer une variable privée de type double appelée 
    // fraisDepassement
    private double fraisDepassement;  
    
    // Définir un constructeur qui prend un double soldeInitial et un 
    // double fraisDepassement en paramètres
    public CompteCheque(double soldeInitial, double fraisDepassement) {    
        // Appeler le constructeur de la superclasse CompteBancaire 
        // avec soldeInitial
        super(soldeInitial);    
        // Assigner le paramètre fraisDepassement à la variable 
        // d'instance fraisDepassement
        this.fraisDepassement = fraisDepassement;  
    }  
    
    // Redéfinir la méthode retirer de la classe CompteBancaire
    @Override  
    public void retirer(double montant) {    
        // Vérifier si le montant à retirer est inférieur ou égal au 
        // solde actuel
        if (montant <= getSolde()) {      
            // Appeler la méthode retirer de la superclasse 
            // CompteBancaire avec le montant
            super.retirer(montant);    
        } else {      
            // Afficher "Frais de découvert appliqués." dans la 
            // console si le montant dépasse le solde actuel
            System.out.println("Frais de découvert appliqués.");      
            // Appeler la méthode retirer de la superclasse 
            // CompteBancaire avec le montant plus les frais de 
            // découvert
            super.retirer(montant + fraisDepassement);    
        }  
    }
} 

// Définir la classe principale
public class Main {  
    // Méthode principale, point d'entrée du programme
    public static void main(String[] args) {    
        // Créer un objet CompteEpargne avec un solde de 3000 et une 
        // limite de 750
        CompteBancaire ce = new CompteEpargne(3000, 750);    
        // Créer un objet CompteCheque avec un solde de 2000 et une 
        // limite de 100
        CompteBancaire cc = new CompteCheque(2000, 100);    
        // Retirer 400 du compte d'épargne
        retirerDuCompte(ce, 400);    
        // Retirer 150 du compte courant
        retirerDuCompte(cc, 150);    
        // Afficher le solde actuel du compte d'épargne
        System.out.println("Solde du compte d'épargne : "+ ce.getSolde());    
        // Afficher le solde actuel du compte courant
        System.out.println("Solde du compte courant : "+ cc.getSolde());  
    }  
    
    // Méthode pour retirer un montant spécifié d'un compte bancaire 
    // donné
    public static void retirerDuCompte(CompteBancaire compte, double montant) {    
        // Appeler la méthode retirer sur le compte avec le montant 
        // spécifié
        compte.retirer(montant);  
    }
}

Sortie:

Solde du compte d'épargne : 2600.0
Solde du compte courant : 1850.0