Classes internes, imbriquées et anonymes
Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 49 sur 87.
Java te permet de définir des classes à l’intérieur d’autres classes. Ces classes internes aident à organiser le code en regroupant les fonctionnalités associées et peuvent accéder directement aux membres de la classe externe.
Une classe interne imbriquée est définie comme un membre d’une autre classe. Elle a accès à tous les champs et à toutes les méthodes de la classe externe, y compris les éléments privés :
class Outer {
private String message = "Hello";
class Inner {
void display() {
System.out.println(message); // Peut accéder au champ privé
}
}
}
// Utilisation
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display(); // Affiche : HelloUne classe interne locale est définie à l’intérieur d’une méthode. Elle ne peut être utilisée que dans cette méthode et peut accéder aux variables locales qui sont effectivement finales :
void process() {
String prefix = "Result: ";
class LocalHelper {
void print(int value) {
System.out.println(prefix + value);
}
}
new LocalHelper().print(42);
}Une classe interne anonyme est une classe sans nom, créée et instanciée en une seule expression. Elle est couramment utilisée pour implémenter des interfaces ou étendre des classes à la volée :
Comparator<String> comp = new Comparator<String>() {
@Override
public int compare(String a, String b) {
return a.length() - b.length();
}
};Les classes internes sont particulièrement utiles lorsqu’une classe ne concerne qu’une autre classe, ce qui permet de garder votre code organisé et encapsulé.
Défi
FacileCréons un système de panier d’achat qui met en évidence les trois types de classes internes. Tu vas créer un ShoppingCart qui utilise une classe interne imbriquée pour représenter les articles, une classe interne locale pour calculer les réductions et une classe interne anonyme pour formater le reçu final.
Tu vas organiser ton code dans trois fichiers :
ShoppingCart.java: crée la classe externe qui gère l’expérience d’achat. Ton ShoppingCart doit avoir un champ privécustomerName(String).Dans ShoppingCart, définis une classe interne imbriquée appelée
Itemavec deux champs privés :name(String) etprice(double). Donne à Item un constructeur qui initialise les deux champs et une méthodegetDetails()qui renvoie :[name]: $[price]Ton ShoppingCart a besoin d’un constructeur qui prend le nom du client, ainsi que d’une méthode appelée
checkout()qui accepte un Item et un pourcentage de réduction (double). Danscheckout():- Crée une classe interne locale appelée
DiscountCalculatoravec une méthodeapplyDiscount(double originalPrice)qui renvoie le prix après application du pourcentage de réduction, calculé comme suit :originalPrice - (originalPrice * discount / 100). - Utilise la classe locale pour calculer le prix final.
- Crée une classe interne anonyme qui implémente l’interface
Formatter(que tu vas définir) pour formater le reçu. La classe anonyme doit redéfinir une méthodeformat()qui renvoie une chaîne de reçu sur plusieurs lignes.
La méthode
checkout()doit renvoyer la chaîne du reçu formaté selon ce format exact :--- Receipt --- Customer: [customerName] Item: [item details from getDetails()] Discount: [discount]% Final Price: $[calculated price]- Crée une classe interne locale appelée
Formatter.java: définis une interface simple avec une seule méthode :String format(). Cette interface sera implémentée par ta classe interne anonyme à l’intérieur de la méthode checkout.Main.java: donne vie à ton panier d’achat ! Tu recevras trois entrées : le nom du client (String), le nom de l’article (String) et le prix de l’article (double). Le pourcentage de réduction est fixé à10.0.Crée un ShoppingCart avec le nom du client. Puis, crée un Item en utilisant la syntaxe de référence à la classe externe :
cart.new Item(name, price). Appellecheckout()avec l’article et la réduction, puis affiche le reçu renvoyé.
Tu recevras trois entrées dans l’ordre suivant : le nom du client, le nom de l’article et le prix de l’article.
Par exemple, si les entrées sont Alice, Laptop et 1000.0, le prix final après une réduction de 10 % sera 900.0.
Remarque que chaque type de classe interne a un rôle différent : la classe imbriquée regroupe des données liées à la classe externe, la classe locale encapsule une logique nécessaire uniquement au sein d’une méthode et la classe anonyme fournit une implémentation rapide et ponctuelle d’une interface !
Essayez vous-même
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Lire les entrées
String customerName = scanner.nextLine();
String itemName = scanner.nextLine();
double itemPrice = scanner.nextDouble();
double discount = 10.0;
// TODO: Créer un ShoppingCart avec le nom du client
// TODO: Créer un Item avec : cart.new Item(itemName, itemPrice)
// TODO: Appeler checkout() avec l’article et la remise, puis afficher le résultat
}
}
Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.
Toutes les leçons de Programmation Orientée Objet
1Fondamentaux de la POO
Fichiers externesIntroduction à la POOClasses vs ObjetsLe mot-clé thisMéthodesChamps (Attributs)Méthode constructeurSurcharge de constructeurRécapitulatif - Calculatrice simple4Héritage
Héritage de base (extends)Le mot-clé superRedéfinition de méthode (@Override)Chaînage de constructeursLa classe ObjectHéritage simple et multiniveauPourquoi pas d'héritage multiple de classesRécapitulatif - Hiérarchie des employés7Méthodes spéciales et classe Object
Méthode toString()equals() et hashCode()Méthode clone()compareTo() et ComparableInterface ComparatorRécapitulatif - Tri personnalisé2Modificateurs d'accès et Encapsulation
Aperçu des niveaux d'accèsMéthodes Getter et SetterMasquage d'informationsLe mot-clé finalRécapitulatif - Gestionnaire de compte bancaire5Polymorphisme
Bases de la surcharge de méthodesRedéfinition de méthodes (Run-Time)Upcasting et DowncastingL'opérateur instanceofClasses et méthodes abstraitesRécapitulatif - Calculateur de formes8Concepts avancés de la POO
Composition vs HéritageAgrégation vs CompositionClasses internes, imbriquées et anonymesEnums et méthodes d'EnumRecords (Java 16+)Classes scellées (Java 17+)11Patrons de conception, partie 1
Introduction aux patrons de conceptionPatron SingletonPatron FabriquePatron MonteurPatron ObservateurPatron Stratégie3Propriétés de classe et membres statiques
Variables d'instance vs variables statiquesMéthodes statiquesBlocs statiquesConstantes (static final)Récapitulatif - Compteur et utilitaire6Interfaces et Classes Abstraites
Introduction aux InterfacesImplémentation d'InterfacesImplémentation d'Interfaces MultiplesDefault et Static dans les InterfacesClasses Abstraites vs InterfacesInterfaces FonctionnellesRécapitulatif - Système de Paiement9La généricité
Introduction à la généricitéClasses génériquesMéthodes génériquesParamètres de type bornésWildcards (?, extends, super)Récapitulatif - Conteneur générique12Patrons de conception, partie 2
Patron CommandePatron AdaptateurPatron DécorateurPatron Template MethodPatron ÉtatPatron CompositePatron ItérateurEntraînez-vous par vous-même : Compilateur Java en ligne