Exercice Java Corrigé – POO – Classes Imbriquées

// Classe externe appelée Ordinateur
class Ordinateur {    

    // Classe interne appelée Processeur
    class Processeur {        

        // Méthode pour afficher les détails du processeur
        void afficherDetails() {            
            // Afficher les détails du processeur
            System.out.println("Marque du processeur: Intel");            
            System.out.println("Vitesse du processeur: 4.5 GHz");        
        }    
    }    

    // Méthode pour créer et afficher les détails du processeur
    void afficherDetailsProcesseur() {        
        // Créer une instance de la classe interne Processeur
        Processeur proc = new Processeur();        
        // Appeler la méthode afficherDetails()
        proc.afficherDetails();    
    }    

    // Méthode main pour exécuter le programme
    public static void main(String[] args) {        
        // Créer une instance de la classe externe Ordinateur
        Ordinateur ord = new Ordinateur();        
        // Appeler la méthode pour afficher les détails du processeur
        ord.afficherDetailsProcesseur();    
    }
}

Sortie:

Marque du processeur: Intel
Vitesse du processeur: 4.5 GHz

Explication:

Dans cet exercice, la classe interne Processeur est définie dans la classe externe Ordinateur. L’exercice ci-dessus démontre l’utilisation de classes imbriquées en Java, permettant à la classe interne d’accéder aux membres de la classe externe. En créant une instance de la classe interne à partir de la classe externe, nous pouvons encapsuler la fonctionnalité et maintenir un groupement logique de classes liées. Cela permet d’organiser le code et d’améliorer la lisibilité et la maintenabilité.

// Classe externe Universite
public class Universite {        

    // Classe imbriquée statique Department
    static class Department {        

        // Variables d'instance pour Department
        private String nomDepartement;        
        private int nbrEnseignant;                

        // Constructeur pour initialiser Department
        public Department(String nomDepartement, int nbrEnseignant) {            
            this.nomDepartement = nomDepartement;            
            this.nbrEnseignant = nbrEnseignant;        
        }                

        // Méthode pour afficher les informations du département
        public void afficherInfo() {            
            System.out.println("Département: "+ nomDepartement);            
            System.out.println("Nombre de membres du personnel enseignant: "+ nbrEnseignant);        
        }    
    }        

    // Méthode main pour démontrer la classe imbriquée statique
    public static void main(String[] args) {        
        // Création d'une instance de la classe imbriquée Department
        Universite.Department dep = new Universite.Department("Informatique", 50);                

        // Appel de la méthode afficherInfo
        dep.afficherInfo();    
    }
}

Sortie:

Département: Informatique
Nombre de membres du personnel enseignant: 50

Explication:

Les classes imbriquées de Java permettent de regrouper logiquement les classes qui ne sont utilisées qu’à un seul endroit. Cela permet d’accroître l’utilisation de l’encapsulation et de créer un code plus lisible et plus facile à maintenir. Dans cet exercice, la classe Departement est une classe statique imbriquée dans la classe Universite, ce qui lui permet d’être associée à la classe Universite sans avoir besoin d’une instance d’Universite. Cette méthode est utile pour regrouper des classes liées entre elles.

// Classe Voiture
public class Voiture {        

    // Méthode startMoteur
    public void startMoteur() {        

        // Classe locale Moteur à l'intérieur de la méthode 
        // startMoteur
        class Moteur {            

            // Méthode run dans la classe locale Moteur
            public void run() {                
                // Instruction d'impression indiquant que le moteur 
                // fonctionne
                System.out.println("Le moteur fonctionne");            
            }        
        }                

        // Création d'une instance de la classe locale Moteur
        Moteur moteur = new Moteur();        

        // Appel de la méthode run de la classe locale Moteur
        moteur.run();    
    }        

    // Méthode main pour tester la classe locale
    public static void main(String[] args) {        
        // Création d'une instance de Voiture
        Voiture v = new Voiture();        

        // Appel de la méthode startMoteur
        v.startMoteur();    
    }
}

Sortie:

Le moteur fonctionne

Explication:

Les classes imbriquées de Java permettent différents niveaux d’utilisation des classes imbriquées. Les classes locales sont définies à l’intérieur d’un bloc, généralement une méthode, et ne sont accessibles qu’à l’intérieur de ce bloc. Dans cet exercice, la classe Moteur est une classe locale dans la méthode startMoteur() de la classe Voiture, ce qui lui permet d’encapsuler la logique de démarrage du moteur dans cette méthode. Cela améliore l’organisation et l’encapsulation du code.

interface Accueil {
   // Cette méthode doit être implémentée par toute classe qui 
   // implémente cette interface
   public void direBonjour();
}

// Classe principale contenant la méthode main
public class Main {    
    public static void main(String[] args) {        
        // Création d'une classe anonyme qui implémente l'interface 
        // Accueil
        Accueil acc = new Accueil() {            
            @Override            
            public void direBonjour() {                
                // Redéfinir la méthode direBonjour pour afficher 
                // "Bonjour, le monde!"
                System.out.println("Bonjour, le monde!");            
            }        
        };        

        // Appel de la méthode direBonjour de la classe anonyme
        acc.direBonjour();    
    }
}

Sortie:

Bonjour, le monde!

Explication:

Dans cet exercice, le concept de classes imbriquées de Java est démontré par l’utilisation d’une classe anonyme. Une classe anonyme est une classe sans nom, utilisée pour instancier des objets avec certaines modifications, telles que l’implémentation d’une interface ou l’extension d’une autre classe. Cela permet d’obtenir un code concis et flexible, particulièrement utile pour implémenter des interfaces simples ou des classes abstraites sans encombrer le code avec des définitions de classes supplémentaires.

// Classe Bibliotheque
public class Bibliotheque {        

    // Variable d'instance nomBibliotheque
    private String nomBibliotheque;    

    // Constructeur pour initialiser nomBibliotheque
    public Bibliotheque(String nomBibliotheque) {        
        this.nomBibliotheque = nomBibliotheque;    
    }    

    // Classe interne Livre
    public class Livre {                

        // Méthode getNomBibliotheque qui renvoie le nom de la 
        // bibliothèque
        public String getNomBibliotheque() {            
            // Accès à la variable d'instance nomBibliotheque de la 
            // classe externe
            return nomBibliotheque;        
        }    
    }    

    // Méthode main pour tester l'accès des membres de la classe 
    // externe par la classe interne
    public static void main(String[] args) {        
        // Création d'une instance de Bibliotheque
        Bibliotheque biblio = new Bibliotheque("Bibliothèque de Recherche");                

        // Création d'une instance de la classe interne Livre
        Bibliotheque.Livre livr = biblio.new Livre();                

        // Appel de la méthode getNomBibliotheque et impression du 
        // résultat
        System.out.println("Nom de la Bibliothèque: "+ livr.getNomBibliotheque());    
    }
}

Sortie:

Nom de la Bibliothèque: Bibliothèque de Recherche

Explication:

Les classes imbriquées de Java permettent aux classes internes d’accéder aux membres de leur classe externe. Dans cet exercice, la classe Livre est une classe interne de la classe Bibliotheque et peut accéder directement à la variable « nomBibliotheque ». Cela démontre l’étroite relation entre les classes internes et externes, améliorant l’encapsulation et l’organisation du code en gardant les fonctionnalités connexes ensemble.

// Classe externe Mathematique
public class Mathematique {    

    // Classe imbriquée statique Calculatrice
    public static class Calculatrice {        

        // Méthode statique somme qui renvoie la somme de deux 
        // entiers
        public static int somme(int a, int b) {            
            return a + b;        
        }    
    }    

    // Méthode main pour démontrer l'utilisation de la classe 
    // imbriquée statique et de sa méthode
    public static void main(String[] args) {        
        // Appel de la méthode statique somme de la classe imbriquée 
        // statique Calculatrice
        int s = Mathematique.Calculatrice.somme(2, 4);                

        // Impression du résultat
        System.out.println("Somme : " + s);    
    }
}

Sortie:

Somme : 6

Explication:

Les classes imbriquées de Java peuvent être statiques, ce qui signifie qu’elles n’ont pas besoin d’une instance de la classe extérieure pour être instanciées. Dans cet exercice, la classe Calculatrice est une classe statique imbriquée dans « Mathematique ». La méthode somme de Calculatrice est également statique, ce qui permet de l’appeler directement en utilisant le nom de la classe sans créer d’instance. Cela montre comment les membres statiques peuvent être utilisés dans différents contextes pour fournir des fonctions utilitaires ou des données partagées.

// Classe Maison
public class Maison {    

    // Méthode calculerSurface pour calculer la surface d'une chambre 
    public void calculerSurface() {        

        // Variables locales pour la longueur et la largeur de la 
        // chambre 
        final double longueur = 15.5;        
        final double largeur = 8.0;        

        // Classe locale Chambre à l'intérieur de la méthode 
        // calculerSurface
        class Chambre {            

            // Méthode getSurface pour calculer et renvoyer la 
            // surface de la pièce
            public double getSurface() {                
                return longueur * largeur;            
            }        
        }        

        // Instanciation de la classe locale Chambre
        Chambre ch = new Chambre();                

        // Appel de la méthode getSurface et impression de la surface
        double surface = ch.getSurface();        
        System.out.println("Surface de la pièce: "+ surface);    
    }    

    // Méthode main pour démontrer l'utilisation de la classe locale
    public static void main(String[] args) {        
        // Création d'une instance de Maison et appel de la méthode 
        // calculerSurface
        Maison m = new Maison();        
        m.calculerSurface();    
    }
}

Sortie:

Surface de la pièce: 124.0

Explication:

Les classes imbriquées de Java peuvent être locales, ce qui signifie qu’elles sont définies à l’intérieur d’une méthode. Dans cet exercice, la classe Chambre est définie à l’intérieur de la méthode « calculerSurface() » de la classe Maison. La classe locale Chambre peut accéder aux variables locales finales longueur et largeur définies dans la méthode englobante. Cet exercice montre comment les classes locales peuvent être utilisées pour encapsuler des fonctionnalités qui ne sont pertinentes qu’au sein d’une méthode spécifique, favorisant ainsi une meilleure organisation et lisibilité du code.

// Classe abstraite Animal avec une méthode abstraite faireBruit
abstract class Animal {    
    // Méthode abstraite faireBruit
    abstract void faireBruit();    
}

// Classe principale pour tester une classe anonyme
public class Main {    

    // Méthode main
    public static void main(String[] args) {        

        // Création d'une classe anonyme qui hérite Animal et 
        // redéfinit la méthode faireBruit
        Animal chat = new Animal() {            

            // Redéfinition de la méthode faireBruit
            @Override            
            void faireBruit() {                
                System.out.println("Meow");            
            }        
        };        

        // Appel de la méthode faireBruit
        chat.faireBruit();    
    }
}

Sortie:

Meow

Explication:

Les classes imbriquées de Java peuvent être anonymes, ce qui signifie qu’elles n’ont pas de nom de classe et qu’elles sont utilisées pour instancier des objets ayant un certain comportement « unique ». Dans cet exercice, une classe anonyme hérite la classe abstraite Animal et fournit une implémentation pour la méthode « faireBruit() ». Cela permet une définition rapide et concise d’une sous-classe et de ses méthodes, rendant le code plus lisible et plus facile à gérer lorsqu’une seule instance avec un comportement spécifique est nécessaire.

// Classe externe Personne
public class Personne {    

    // Classe interne Adresse
    class Adresse {        

        // Variables d'instance pour la ville et l'état
        String ville;        
        String etat;        

        // Constructeur pour la classe Adresse
        Adresse(String ville, String etat) {            
            this.ville = ville;            
            this.etat = etat;        
        }        

        // Méthode pour afficher les détails de l'adresse
        void afficherAdresse() {            
            System.out.println("Ville: "+ ville +", État: "+ etat);        
        }    
    }    

    // Méthode main pour démontrer la création d'une instance de la 
    // classe interne
    public static void main(String[] args) {        
        // Création d'une instance de la classe externe Personne
        Personne p = new Personne();        

        // Création d'une instance de la classe interne Adresse
        Personne.Adresse add = p.new Adresse("Paris", "OK");        

        // Appel de la méthode afficherAdresse pour afficher les 
        // détails de l'adresse
        add.afficherAdresse();    
    }
}

Sortie:

Ville: Paris, État: OK

Explication:

Les classes imbriquées de Java, y compris les classes internes, permettent une meilleure organisation et encapsulation du code. Dans cet exercice, la classe interne Adresse au sein de la classe externe Personne montre comment une classe interne peut avoir son propre constructeur et ses propres méthodes. Cela permet de créer des objets étroitement associés à leur classe externe, ce qui permet de regrouper logiquement des classes qui ne sont utilisées qu’à un seul endroit et d’améliorer la lisibilité et la maintenabilité du code.

// Classe externe Ecole
public class Ecole {    

    // Classe imbriquée statique Etudiant
    static class Etudiant {        

        // Variables d'instance pour le nom et la note de l'étudiant
        String nom;        
        String note;        

        // Constructeur pour la classe Etudiant
        Etudiant(String nom, String note) {            
            this.nom = nom;            
            this.note = note;        
        }        

        // Méthode non statique pour afficher les informations de 
        // l'étudiant
        void afficherEtudiantInfo() {            
            System.out.println("Nom de l'Étudiant: "+ nom);            
            System.out.println("Note: "+ note);        
        }    
    }    

    // Méthode main pour démontrer la création d'une instance de la 
    // classe imbriquée statique
    public static void main(String[] args) {        
        // Création d'une instance de la classe imbriquée statique 
        // Etudiant
        Ecole.Etudiant e = new Ecole.Etudiant("Alex Chio", "B");        

        // Appel de la méthode afficherEtudiantInfo pour afficher les 
        // détails de l'étudiant
        e.afficherEtudiantInfo();    
    }
}

Sortie:

Nom de l'Étudiant: Alex Chio
Note: B

Explication:

Les classes imbriquées de Java, y compris les classes imbriquées statiques, permettent un regroupement logique des classes qui ne sont utilisées qu’à un seul endroit, ce qui améliore la lisibilité et la maintenabilité du code. Dans cet exercice, la classe statique imbriquée Etudiant au sein de la classe externe Ecole démontre comment une classe statique imbriquée peut avoir des méthodes et des variables d’instance non statiques. Cela permet de créer des objets qui sont logiquement associés à la classe externe tout en offrant une certaine flexibilité dans la définition et l’utilisation des méthodes.