Ficha de revisão: Gestion des composants et conteneurs Swing

📋 Plan du Cours

1. Composants Swing
2. Conteneurs Swing
3. Gestionnaires de disposition
4. Événements et listeners
5. Fenêtres Swing
6. Barres de menus
7. Boîtes de dialogue
8. Composants graphiques
9. Positionnement composants
10. Gestion de l’interactivité

📖 1. Composants Swing

🔑 Notions clés & Définitions

• JComponent (héritée de Component de AWT) : classe de base pour tous les composants Swing, offrant des méthodes communes telles que getParent() et add(). Elle facilite la création et la gestion des composants graphiques en permettant l'héritage et la personnalisation.
• Hiérarchie des composants Swing : tous les composants Swing descendent de JComponent, qui elle-même hérite de Component de AWT. Cette structure hiérarchique assure une cohérence dans la gestion des composants et leur comportement.
• Méthode getParent() : méthode commune à tous les composants Swing, permettant de connaître le conteneur parent dans lequel le composant est hébergé.
• Méthode add() : méthode utilisée pour ajouter un composant dans un conteneur, permettant de construire l’arborescence graphique.
• setVisible() : méthode pour gérer la visibilité d’un composant. Si elle est à false, le composant n’est pas affiché, mais reste dans la hiérarchie.
• setEnabled() : méthode pour activer ou désactiver un composant. Un composant désactivé reste visible mais inactif, empêchant toute interaction utilisateur.

📝 Points essentiels

• Héritage de JComponent : tous les composants Swing (boutons, labels, images, etc.) héritent de cette classe, ce qui leur confère des méthodes communes pour la gestion, la personnalisation et l’interactivité.
• Hiérarchie des composants : la structure repose sur JComponent descendant de Component de AWT, permettant une uniformité dans la manipulation des éléments graphiques.
• Gestion de la hiérarchie : la méthode getParent() permet de remonter dans l’arborescence, tandis que add() sert à construire cette hiérarchie en insérant des composants dans des conteneurs.
• Visibilité et activation : setVisible() contrôle l’affichage, setEnabled() contrôle la possibilité d’interagir avec le composant.
• Utilisation des bordures : la classe BorderFactory fournit des méthodes statiques pour créer facilement des bordures prédéfinies (ex : createTitleBorder()), permettant d’encadrer visuellement les composants.

💡 À retenir

Les composants Swing, tous hérités de JComponent, offrent une gestion cohérente de l’affichage, de la hiérarchie et de l’interactivité, facilitant la création d’interfaces graphiques portables et modulaires. La classe BorderFactory simplifie l’ajout d’encadrements visuels pour une meilleure ergonomie.

📖 2. Conteneurs Swing

🔑 Notions clés & Définitions

• Conteneurs Swing : Objets qui peuvent héberger d’autres composants ou conteneurs, tous descendant de la classe Container. Ils structurent l’interface graphique en regroupant des composants pour une gestion cohérente de l’affichage et de l’interactivité.

• Conteneurs primaires lourds : Conteneurs fondamentaux dont la fenêtre est dessinée par le système d’exploitation, assurant une compatibilité native. Incluent JFrame, JWindow, JDialog, et JApplet. Selon Sun (date non précisée), ils sont la base pour créer des fenêtres principales ou modales dans Swing.

• Structure interne des conteneurs primaires : Organisation hiérarchique composée de GlassPane, ContentPane, LayeredPane, et JRootPane. Selon Sun (date non précisée), cette architecture permet de gérer la superposition, la gestion des événements, et la personnalisation de la fenêtre.

• Conteneurs secondaires légers : Composants de gestion plus fine et modulable, tels que JPanel, JScrollPane, JSplitPane, JTabbedPane, JToolBar, et JDesktopPane. Tous descendants de JComponent, ils facilitent la construction d’interfaces complexes tout en restant légers (dépourvus de dessin par le système d’exploitation).

• Méthodes de gestion des composants : Les méthodes add, remove, et setContentPane permettent d’ajouter, de retirer ou de remplacer les composants dans un conteneur. Par exemple, add insère un composant dans un conteneur, tandis que setContentPane remplace le panneau principal d’un JFrame ou JWindow.

📝 Points essentiels

• Les conteneurs en Swing sont tous des descendants de Container, permettant une hiérarchisation flexible des composants graphiques.
• Les conteneurs primaires (JFrame, JWindow, JDialog, JApplet) sont lourds, c’est-à-dire dessinés par le système d’exploitation, sauf leur contenu qui est géré par la JVM. La structure interne comprend un JRootPane contenant un GlassPane (transparence et gestion des événements), un ContentPane (zone d’affichage principale, souvent un JPanel), et un LayeredPane pour la superposition.
• Les conteneurs secondaires (JPanel, JScrollPane, etc.) sont légers, c’est-à-dire dessinés par la JVM, et servent à organiser l’interface de façon modulaire et réutilisable.
• La gestion des composants dans un conteneur s’effectue principalement via add, remove, et setContentPane. La méthode setContentPane est essentielle pour changer le panneau principal d’un JFrame ou JWindow.
• La hiérarchie interne (GlassPane, ContentPane, LayeredPane, JRootPane) permet une gestion avancée des événements, de la superposition et de la personnalisation de la fenêtre.

💡 À retenir

Les conteneurs Swing, qu’ils soient primaires lourds ou secondaires légers, structurent efficacement l’interface graphique en utilisant une hiérarchie claire, facilitant la gestion, la portabilité et la personnalisation des composants.

📖 3. Gestionnaires de disposition

🔑 Notions clés & Définitions

• Gestionnaires de placement : Composants qui organisent automatiquement la position et la taille des composants dans un conteneur, permettant une interface adaptable et portable (voir aussi la notion de portabilité graphique). AUTEUR (date) : facilite la construction d'interfaces cohérentes sur différents systèmes d'exploitation.

• Inconvénient du positionnement absolu : Utilisation manuelle des méthodes setLocation et setSize pour placer et dimensionner les composants, ce qui complique la portabilité et la maintenance de l'interface, car cela ne s'adapte pas aux variations d'écran ou de police (voir aussi la gestion de la taille et position).

• Utilisation des gestionnaires pour assurer portabilité graphique : Privilégier les gestionnaires de disposition pour que l'interface s'adapte dynamiquement aux changements de taille ou de résolution, garantissant une compatibilité entre différents environnements (voir aussi la méthode revalidate).

• Méthodes liées à la taille et position des composants : getLocation, setLocation, setSize, getPreferredSize ; permettent d'obtenir ou de définir la position et la taille d’un composant. La méthode getPreferredSize retourne la taille optimale pour un composant, facilitant un affichage cohérent.

• Appel de revalidate : Méthode à invoquer après modification de la taille ou de la position d’un composant pour que celui-ci soit redessiné et que la nouvelle disposition soit prise en compte dans l’interface graphique.

📝 Points essentiels

• Les gestionnaires de disposition (layout managers) remplacent le positionnement manuel absolu pour assurer la portabilité et l’adaptabilité des interfaces graphiques Swing.
• La hiérarchie des composants dans Swing repose sur une hiérarchie de conteneurs, où chaque conteneur peut utiliser un gestionnaire de disposition pour organiser ses composants.
• Les principaux gestionnaires de disposition incluent FlowLayout, BorderLayout, GridLayout, BoxLayout, etc., chacun ayant ses règles spécifiques pour organiser les composants.
• Lorsqu’un composant est déplacé ou redimensionné, il est nécessaire d’appeler revalidate() pour que la nouvelle disposition soit effective et que l’affichage soit mis à jour.
• La méthode getPreferredSize() permet d’obtenir la taille optimale d’un composant, évitant d’utiliser setSize() manuellement, ce qui pourrait nuire à la portabilité.

💡 À retenir

L’utilisation de gestionnaires de disposition est essentielle pour créer des interfaces graphiques portables, adaptables et faciles à maintenir, en évitant le positionnement manuel et en assurant une compatibilité optimale entre différents environnements.

📖 4. Événements et listeners

🔑 Notions clés & Définitions

• Événements générés par les actions utilisateur : Ce sont des objets qui représentent une interaction de l’utilisateur avec un composant graphique, comme un clic, une sélection ou une saisie. Ces événements sont créés automatiquement par le système lors d’une action et transmis aux gestionnaires d’événements pour traitement.

• Transmission des événements des composants vers gestionnaires d’événements : Processus par lequel un événement généré par un composant est envoyé à une méthode ou un objet appelé listener, chargé de réagir à cet événement. La communication repose sur l’association d’un listener à un composant via des méthodes d’enregistrement.

• Séparation entre gestion des événements et création de l’interface : Principe selon lequel la logique de traitement des événements est distincte de la construction graphique de l’interface. Cela facilite la maintenance et la modularité du code, en permettant de modifier la réaction aux événements sans changer la structure visuelle.

• Rôle des listeners pour gérer l’interactivité : Les listeners sont des objets qui implémentent des interfaces spécifiques (ex : ActionListener, MouseListener) et qui contiennent les méthodes à exécuter en réponse à un événement. Ils permettent de définir la réaction du programme face à une action utilisateur.

• Notion de gestionnaire d’événements (Event Handler) : Composant ou méthode qui reçoit et traite les événements transmis par les composants graphiques. Il peut s’agir d’une classe anonyme ou d’une classe dédiée, qui définit le comportement à adopter lors de la survenue d’un événement.

📝 Points essentiels

• Les événements sont des objets issus de classes spécifiques (ex : ActionEvent, MouseEvent) qui encapsulent des informations sur l’action utilisateur (source, type, moment, etc.).

• La méthode d’association d’un listener à un composant se fait généralement via la méthode addXListener, par exemple addActionListener pour un bouton, permettant au composant d’envoyer ses événements à ce listener.

• La séparation entre interface et gestion des événements repose sur le modèle Observer : le composant (Observable) notifie ses listeners (Observers) lorsqu’un événement survient, sans que la logique de traitement soit intégrée à la construction graphique.

• La conception modulaire favorise la réutilisation et la maintenance du code, en permettant d’attacher ou de détacher dynamiquement des gestionnaires d’événements.

• La gestion des événements dans Swing repose sur le principe de délégation : chaque composant peut avoir plusieurs listeners, chacun réagissant à un type spécifique d’événement.

💡 À retenir

La gestion des événements dans Swing repose sur la génération d’objets représentant des actions utilisateur, leur transmission via des listeners, et une séparation claire entre création de l’interface et traitement de l’interactivité, ce qui facilite la modularité et la maintenance du code.

📖 5. Fenêtres Swing

🔑 Notions clés & Définitions

• JFrame : Fenêtre principale d’une application Swing, construite comme un conteneur lourd (composant dessiné par le système d’exploitation), comportant une bordure, un titre, des icônes et éventuellement un menu. (source)
• JWindow : Fenêtre sans bordure ni boutons, utilisée pour des affichages temporaires ou spécifiques comme les splash screens ou écrans d’attente. Elle est également un conteneur léger, dessinée par la JVM, et ne peut être fermée que par le programme. (source)
• Méthodes communes à JFrame et JWindow : setVisible(), pack(), qui permettent respectivement d’afficher la fenêtre, d’ajuster sa taille selon ses composants internes, et de préparer la fenêtre pour l’affichage. (source)
• Différences JFrame / JWindow :
  • Bordure et boutons : JFrame possède une bordure, un titre, des icônes et boutons de fermeture, tandis que JWindow n’a aucune bordure ni boutons.
  • Fermeture : JFrame peut être fermée via une opération par défaut (setDefaultCloseOperation), JWindow doit être fermée explicitement par le code.
  • Utilisation : JFrame est une fenêtre standard du système d’exploitation, JWindow est réservée à des usages spécifiques comme splash screens ou écrans d’attente. (source)

📝 Points essentiels

• JFrame est la fenêtre principale standard dans Swing, intégrée dans le système d’exploitation, avec une bordure, un titre, et souvent un menu. Elle est créée via new JFrame(), et ses méthodes setSize(), setLocation(), setDefaultCloseOperation() permettent de la configurer.
• JWindow est une fenêtre sans bordure ni boutons, souvent utilisée pour des affichages temporaires comme les splash screens ou écrans d’attente. Elle est créée via new JWindow(), puis configurée avec setSize(), setLocation(), et rendue visible avec setVisible(true).
• La méthode pack() ajuste la taille de la fenêtre en fonction de ses composants internes, en utilisant la méthode getPreferredSize() pour calculer la taille optimale.
• La différence majeure réside dans l’aspect visuel et l’usage : JFrame est une fenêtre classique du système, JWindow est une fenêtre légère sans bordure ni boutons, conçue pour des usages spécifiques.
• La fermeture d’un JFrame peut être contrôlée avec setDefaultCloseOperation(), tandis que JWindow doit être fermée manuellement par setVisible(false) ou dispose().
• Utilisation :
  • JFrame pour fenêtres principales, avec menu, bordure, icônes.
  • JWindow pour splash screens, écrans d’attente, fenêtres temporaires sans bordure. (source)

💡 À retenir

Les JFrame et JWindow sont deux fenêtres principales en Swing, la première étant la fenêtre standard du système avec bordure et boutons, la seconde étant une fenêtre sans bordure, idéale pour des affichages temporaires ou spécifiques comme les splash screens. Leur gestion commune via setVisible() et pack() facilite leur utilisation dans des interfaces graphiques.

📖 6. Barres de menus

🔑 Notions clés & Définitions

• Barres de menus : éléments d’interface graphique permettant d’organiser et d’accéder rapidement aux fonctionnalités principales d’une application via une liste déroulante située généralement en haut de la fenêtre.
• JToolBar : classe de Swing utilisée pour créer une barre d’outils contenant des boutons ou autres composants graphiques, souvent placée en haut de la fenêtre pour un accès rapide aux actions courantes.
• Positionnement typique : la pratique courante consiste à placer la barre d’outils en haut de la fenêtre afin d’assurer une ergonomie optimale et une accessibilité immédiate aux fonctionnalités principales.

📝 Points essentiels

• La barre de menus est construite à partir de la classe JMenu, qui regroupe plusieurs JMenuItem ou JRadioButtonMenuItem pour représenter les options. Ces menus sont ajoutés à une JMenuBar via la méthode add.
• La JToolBar est un composant léger (classe JToolBar) qui peut contenir des boutons, icônes, listes déroulantes, etc., et est généralement placée en haut de la fenêtre pour une ergonomie efficace.
• La construction d’une barre d’outils avec boutons se fait en créant une instance de JToolBar, puis en y ajoutant des composants comme JButton ou JToggleButton à l’aide de la méthode add. Exemple :

  JToolBar tb = new JToolBar();
  JButton btnOuvrir = new JButton(new ImageIcon("icons/fileopen.png"));
  JButton btnEnregistrer = new JButton(new ImageIcon("icons/filesave.png"));
  tb.add(btnOuvrir);
  tb.add(btnEnregistrer);
  

• La position typique des barres d’outils est en haut de la fenêtre, ce qui facilite l’accès immédiat aux fonctionnalités essentielles sans encombrer la zone de travail.

💡 À retenir

Les barres de menus et les barres d’outils, placées en haut de la fenêtre, offrent une organisation ergonomique et efficace pour accéder rapidement aux principales fonctionnalités d’une interface graphique Swing.

📖 7. Boîtes de dialogue

🔑 Notions clés & Définitions

• JOptionPane (voir source) : classe de Swing permettant de créer facilement des boîtes de dialogue standardisées pour communiquer avec l’utilisateur, avec possibilité de personnalisation.
• showMessageDialog (voir source) : méthode de JOptionPane qui affiche une boîte de message modale pour informer l’utilisateur, bloquant l’application jusqu’à ce que l’utilisateur clique sur le bouton de confirmation.
• showConfirmDialog (voir source) : méthode de JOptionPane qui affiche une boîte de dialogue de confirmation ou de question, permettant de recueillir une réponse binaire (oui/non). Elle retourne un entier correspondant à la réponse choisie.
• showInputDialog (voir source) : méthode de JOptionPane qui affiche une boîte de dialogue pour saisir une valeur ou une réponse de l’utilisateur, généralement sous forme de texte.
• Dialogues modaux (voir source) : boîtes de dialogue qui bloquent l’interaction avec la fenêtre principale jusqu’à leur fermeture, assurant que l’utilisateur réponde avant de continuer.

📝 Points essentiels

• JOptionPane facilite la création de dialogues variés (messages, questions, saisies) sans nécessiter une gestion complexe d’interface graphique.
• La méthode showMessageDialog peut afficher différents types de messages (information, avertissement, erreur) en utilisant des constantes comme JOptionPane.WARNING_MESSAGE.
• La méthode showConfirmDialog permet de poser une question fermée à l’utilisateur avec des options prédéfinies (oui/non, oui/non/annuler), et retourne un code (ex : YES_OPTION, NO_OPTION).
• La méthode showInputDialog recueille une réponse utilisateur sous forme de chaîne de caractères, avec possibilité d’ajouter un message ou un titre personnalisé.
• La personnalisation des boîtes de dialogue via JOptionPane inclut l’ajout de composants graphiques dans les dialogues, permettant une interaction plus riche.
• Ces dialogues sont généralement utilisés pour une interaction simple et rapide avec l’utilisateur, notamment dans des applications Java Swing.

💡 À retenir

Les boîtes de dialogue Swing, créées via JOptionPane, offrent une manière simple et efficace d’interagir avec l’utilisateur en affichant des messages, en posant des questions ou en recueillant des données, tout en étant facilement personnalisables et modales.

📖 8. Composants graphiques

🔑 Notions clés & Définitions

• Boutons (JButton, JToggleButton, JButton) : Composants permettant à l’utilisateur d’effectuer une action en cliquant. JButton est le bouton standard, tandis que JToggleButton conserve son état (activé/désactivé) après clic (voir "Les boutons à bascule"). La classe abstraite AbstractButton fournit des méthodes pour paramétrer ces boutons, comme setText, setIcon, et setMnemonic (pour raccourcis clavier).
• Labels (JLabel) : Composants affichant du texte ou une image, utilisé pour informer ou décorer l’interface. La création se fait via le constructeur JLabel(String) ou en utilisant un ImageIcon pour afficher une image, par exemple new JLabel(new ImageIcon("venus.jpg")).
• Images (ImageIcon) : Classe permettant de charger et d’afficher des images (JPEG, GIF, PNG) dans des composants Swing, notamment dans un JLabel ou un JButton.
• Utilisation de JLabel pour afficher des images : La méthode consiste à créer un ImageIcon puis à l’associer à un JLabel pour l’affichage. Exemple : JLabel imgLabel = new JLabel(new ImageIcon("image.jpg")); (voir "Les composants atomiques").
• Gestion des composants dans les conteneurs : Un composant est hébergé par un conteneur (ex : JPanel, JFrame). La méthode add() permet d’ajouter un composant dans un conteneur, et getParent() pour connaître son conteneur parent. La position et la taille peuvent être modifiées via setLocation et setSize, mais il est conseillé d’utiliser des gestionnaires de disposition pour assurer la portabilité graphique.
• Icônes dans les boutons : La classe ImageIcon permet d’ajouter une icône à un bouton avec setIcon ou lors de la création via le constructeur JButton(String, Icon). Exemple : new JButton("Ouvrir", new ImageIcon("icon.png")).

📝 Points essentiels

• Tous les composants Swing descendent de JComponent, elle-même dérivée de Component de AWT, ce qui facilite leur gestion commune.
• Les composants sont généralement hébergés dans des conteneurs légers comme JPanel, JTabbedPane, ou JToolBar. La hiérarchie interne de JFrame inclut GlassPane, ContentPane (par défaut un JPanel), LayeredPane, et JRootPane.
• La création d’un composant d’image se fait en utilisant ImageIcon, qui peut être affiché dans un JLabel ou un JButton.
• La gestion automatique de la disposition des composants est privilégiée via les gestionnaires de placement (ex : FlowLayout, BorderLayout) pour assurer la compatibilité entre différents systèmes d’exploitation.
• La personnalisation des composants (bordures, icônes, raccourcis clavier) se fait via des méthodes comme setBorder, setIcon, setMnemonic. La classe BorderFactory fournit des bordures prédéfinies, par exemple createTitleBorder.
• Les composants comme JLabel peuvent aussi contenir des images, ce qui permet d’afficher des icônes ou des illustrations dans l’interface.

💡 À retenir

Les composants graphiques de Swing, tels que boutons, labels et images, sont conçus pour être légers, facilement personnalisables et compatibles avec différents environnements, grâce à l’utilisation de classes comme JComponent et ImageIcon, et à une hiérarchie orientée héritage. Leur gestion efficace repose sur l’utilisation de conteneurs et de gestionnaires de disposition pour garantir une interface adaptable et ergonomique.

📖 9. Positionnement composants

🔑 Notions clés & Définitions

• Positionnement relatif : Méthode de placement des composants en fonction de leur conteneur ou d’autres composants, privilégiée pour garantir la portabilité graphique (voir présentation de Swing).
• Gestionnaires de disposition (Layout Managers) : Objets qui organisent automatiquement la position et la taille des composants dans un conteneur, évitant ainsi le positionnement manuel (voir section 3).
• getLocation / setLocation : Méthodes permettant respectivement d’obtenir la position d’un composant et de la modifier manuellement, mais leur utilisation est déconseillée en faveur des gestionnaires de disposition (voir présentation de Swing).
• Recommandation d’éviter le positionnement manuel : Prendre en compte la diversité des environnements d’exécution (polices, résolutions) en utilisant des gestionnaires pour assurer la compatibilité graphique (voir présentation de Swing).
• Positionnement automatique : Utilisation des gestionnaires de placement pour disposer les composants de façon dynamique et adaptable, garantissant la portabilité et la cohérence de l’interface graphique (voir section 3).

📝 Points essentiels

• Le positionnement manuel (setLocation) est fortement déconseillé car il ne garantit pas la compatibilité entre différents systèmes d’exploitation ou résolutions d’écran.
• Swing propose une variété de gestionnaires de disposition (FlowLayout, BorderLayout, GridBagLayout, etc.) pour organiser automatiquement les composants selon des règles prédéfinies, assurant ainsi la portabilité graphique.
• La méthode getLocation permet d’obtenir la position d’un composant par rapport à son conteneur, tandis que setLocation modifie cette position, mais leur usage direct est à éviter pour préserver la cohérence de l’interface.
• Après modification de la taille ou de la position d’un composant, il est nécessaire d’appeler revalidate pour que l’affichage soit mis à jour correctement.
• La gestion dynamique de la taille des composants est facilitée par la méthode getPreferredSize, qui indique la taille optimale pour un affichage correct, évitant ainsi le positionnement manuel.
• La hiérarchie des composants (conteneur -> composants) doit être respectée pour une organisation cohérente, en utilisant les gestionnaires de disposition pour une disposition automatique.

💡 À retenir

Pour garantir la portabilité et la cohérence de l’interface graphique, il est préférable d’utiliser les gestionnaires de disposition plutôt que le positionnement manuel avec setLocation, en s’appuyant sur les méthodes getLocation et getPreferredSize pour une gestion efficace et adaptable.

📖 10. Gestion de l’interactivité

🔑 Notions clés & Définitions

• Gestion de l’interactivité : Ensemble des mécanismes permettant à une interface graphique de réagir aux actions de l’utilisateur, notamment via la capture d’événements et l’exécution de réponses adaptées.

• Événements : Objets représentant une action utilisateur (clic, déplacement, saisie, etc.) qui sont transmis par un composant à un gestionnaire pour traitement. Selon AUTEUR (date), ils permettent de moduler le comportement du programme en fonction des interactions.

• Listeners (écouteurs) : Composants qui capturent et réagissent aux événements générés par l’utilisateur. Selon AUTEUR (date), ils assurent la séparation entre la gestion des actions et la création de l’interface graphique, facilitant la modularité du code.

• Modification du programme en réponse aux événements : Processus par lequel l’état ou le comportement de l’application est ajusté suite à la détection d’un événement, par exemple en modifiant l’affichage ou en déclenchant des traitements spécifiques.

• Séparation entre interface graphique et gestion des événements : Approche qui consiste à dissocier la construction de l’interface (création des composants) de la logique de réponse aux interactions, en utilisant notamment des listeners pour gérer les actions utilisateur.

📝 Points essentiels

• La gestion de l’interactivité repose sur la détection d’événements (clics, saisies, mouvements) par des composants graphiques, qui sont encapsulés dans des objets d’événements (ex : ActionEvent, MouseEvent).

• Ces événements sont transmis à des gestionnaires d’événements appelés listeners, qui sont attachés aux composants via des méthodes spécifiques (ex : addActionListener, addMouseListener). Ces listeners implémentent des interfaces fonctionnelles permettant de définir la réponse à chaque type d’événement.

• La séparation entre interface graphique et gestion des événements est essentielle pour la modularité du code. Elle permet de modifier la logique de réponse sans toucher à la structure de l’interface, facilitant la maintenance et l’évolution du programme.

• La modification du programme en réponse aux événements peut inclure des actions comme l’activation/désactivation de composants, la mise à jour de l’affichage, ou le déclenchement de traitements métier.

• La capture des actions utilisateur via listeners permet d’assurer une interactivité fluide et réactive, en respectant la philosophie de programmation événementielle.

💡 À retenir

La gestion de l’interactivité en Swing s’appuie sur la détection d’événements par des listeners, permettant de modifier le comportement de l’application de manière modulaire et indépendante de l’interface graphique.

📊 Tableaux de Synthèse

Critère	Composants Swing	Conteneurs Swing	Gestionnaires de disposition
Héritage	Héritent de JComponent, qui hérite de Component	Héritent de Container, tous descendants de Component	N/A (organisent la disposition des composants)
Principaux classes	JComponent, BorderFactory	JFrame, JPanel, JScrollPane, JDialog, JRootPane	FlowLayout, BorderLayout, GridLayout, BoxLayout
Fonctionnalités clés	Gestion de l’affichage, visibilité (setVisible()), activation (setEnabled()), bordures (BorderFactory)	Structuration hiérarchique, gestion de l’arborescence, zones d’affichage	Organisation automatique des composants, portabilité graphique, revalidate()
Points importants	Méthodes add(), getParent(), gestion de la hiérarchie	Structure interne (GlassPane, ContentPane, LayeredPane, JRootPane)	Éviter le positionnement absolu, privilégier gestionnaires pour portabilité

Critère	Conteneurs primaires lourds	Conteneurs secondaires légers
Définition	Fenêtres dessinées par le système d’exploitation (JFrame, JDialog)	Composants modulaires (JPanel, JScrollPane)
Structure interne	JRootPane avec GlassPane, ContentPane, LayeredPane	Héritent de JComponent, plus légers, réutilisables
Gestion	Fenêtre principale ou modale	Organisation interne, composants réutilisables

⚠️ Pièges & Confusions Fréquentes

1. Confondre JComponent et Component : JComponent hérite de Component, mais offre des méthodes supplémentaires pour Swing.
2. Utiliser le positionnement absolu (setLocation, setSize) au lieu des gestionnaires de disposition, ce qui nuit à la portabilité.
3. Oublier d’appeler revalidate() après modification de la disposition ou de la taille d’un composant pour que la mise à jour soit effective.
4. Confondre conteneurs primaires lourds (ex : JFrame) et secondaires légers (JPanel) : les premiers sont liés à la fenêtre système, les seconds sont des composants.
5. Négliger la hiérarchie interne (GlassPane, ContentPane, LayeredPane) lors de la personnalisation des fenêtres.
6. Utiliser un seul gestionnaire de disposition pour tous les conteneurs sans adapter selon la disposition souhaitée.
7. Confondre add() pour ajouter un composant et setContentPane() pour changer le panneau principal d’un JFrame.

✅ Checklist Examen

• Connaître la hiérarchie de JComponent et ses méthodes (getParent(), add(), setVisible(), setEnabled()).
• Savoir que tous les composants Swing héritent de JComponent et utiliser BorderFactory pour créer des bordures.
• Identifier les principaux conteneurs Swing : JFrame, JPanel, JScrollPane, JDialog, JRootPane.
• Comprendre la structure interne d’un JFrame : JRootPane, GlassPane, ContentPane, LayeredPane.
• Savoir différencier conteneurs primaires lourds et secondaires légers.
• Connaître l’intérêt des gestionnaires de disposition (FlowLayout, BorderLayout, GridLayout, BoxLayout) pour assurer la portabilité graphique.
• Éviter le positionnement absolu en utilisant les gestionnaires, et rappeler d’appeler revalidate() après modification.
• Maîtriser la hiérarchie interne des conteneurs pour la gestion avancée des événements et de la superposition.
• Connaître la méthode setContentPane() pour changer le panneau principal d’un JFrame.
• Savoir que la méthode getPreferredSize() permet d’obtenir la taille optimale d’un composant.
• Comprendre l’utilisation des gestionnaires pour organiser dynamiquement l’interface.
• Savoir que la hiérarchie des composants doit être cohérente pour une interface portable et maintenable.