Java Avancée by MedGm
Gestion de fichiers
En Java, la gestion de fichiers permet de lire, écrire, créer ou supprimer des fichiers et des
répertoires. Pour cela, on utilise principalement les classes du package [Link]
Points clés :
Lire un fichier :
On peut utiliser des classes comme FileReader qui lit le contenu d’un fichier dans une liste de
chaînes de caractères.
Écrire dans un fichier :
De même, FileWriter permet d'écrire des données dans un fichier.
Par exemple, pour créer un fichier et y écrire du texte, j’utilise souvent un BufferedWriter
pour améliorer la performance d’écriture.
Créer et supprimer des fichiers :
La classe File offre des méthodes pour créer, renommer ou supprimer des fichiers et
dossiers.
Exemple , créer un fichier :
File file = new File("[Link]"); crée un objet fichier.
createNewFile() crée physiquement le fichier sur le disque.
Un autre exemple simple et générale :
Flux d'entrées/sorties (I/O)
Les flux d'entrées/sorties (I/O) en Java sont des abstractions qui permettent de lire (entrée)
et d’écrire (sortie) des données, que ce soit dans des fichiers, des réseaux ou d’autres
sources.
Principes de base :
InputStream et OutputStream :
Ce sont les classes de base pour la lecture et l’écriture d’octets. Par exemple,
FileInputStream pour lire des données d’un fichier sous forme d’octets et
FileOutputStream pour écrire.
Reader et Writer :
Pour manipuler des caractères (texte), on utilise Reader et Writer (comme FileReader et
FileWriter).
Bufferisation :
Les classes comme BufferedReader ou BufferedWriter ajoutent une couche de buffer qui
améliore les performances en réduisant le nombre d’accès physiques au disque.
Exemple simple de lecture d’un fichier avec des flux :
while ((ligne = [Link]()) != null) Lit le fichier ligne par ligne jusqu'à la fin (null)
Sérialisation
La sérialisation en Java est le processus qui consiste à convertir un objet en un flux de
données (typiquement des octets) pour le stocker dans un fichier ou le transmettre sur un
réseau. Cette opération permet ensuite de désérialiser ces données pour reconstruire l'objet
original.
Points clés :
Implémenter Serializable :
Pour qu’un objet puisse être sérialisé, la classe doit implémenter l’interface Serializable.
Exemple :
Sérialiser un objet :
On utilise ObjectOutputStream pour écrire un objet dans un fichier.
Désérialiser un objet :
Pour lire l’objet à partir du fichier, on utilise ObjectInputStream.
Conclusion
Pour résumer, la gestion de fichiers, les flux I/O et la sérialisation sont des concepts
essentiels pour manipuler les données en Java. Ils vous permettent de :
Gérer des fichiers (création, lecture, écriture, suppression).
Lire et écrire des données de manière efficace avec des flux d’entrées et sorties.
Enregistrer et transmettre des objets grâce à la sérialisation.
Quelques méthodes pour cette partie :
Interfaces Graphiques en Java : AWT & Swing
1. Qu'est-ce qu'AWT ?
AWT (Abstract Window Toolkit) est la première bibliothèque graphique de Java. Elle fournit
un ensemble de composants (boutons, fenêtres, menus, etc.) qui dépendent du système
d'exploitation pour leur apparence et leur comportement.
Avantages :
Intégration native avec le système d'exploitation.
Limites :
Apparence souvent moins personnalisable et moins riche que Swing.
2. Qu'est-ce que Swing ?
Swing est une bibliothèque graphique plus récente qui fait partie de la plateforme Java
depuis JDK 1.2.
Caractéristiques principales :
Composants légers : Contrairement à AWT, Swing ne dépend pas du système
d'exploitation pour afficher les composants, ce qui permet une apparence uniforme
sur toutes les plateformes.
Personnalisable : Swing offre une grande flexibilité pour modifier l'apparence des
composants (Look and Feel).
Richesse fonctionnelle : Plus de composants et de fonctionnalités (comme des tables,
des arbres, etc.).
3. Les Composants de Base
Voici quelques composants couramment utilisés, que ce soit en AWT ou en Swing :
Fenêtre (Frame / JFrame) :
La fenêtre principale de votre application.
AWT : Frame
Swing : JFrame
Panneau (Panel / JPanel) :
Conteneur pour regrouper d'autres composants et organiser l'interface.
AWT : Panel
Swing : JPanel
Bouton (Button / JButton) :
Permet d'exécuter une action lorsqu'on clique dessus.
AWT : Button
Swing : JButton
Étiquette (Label / JLabel) :
Affiche du texte ou des images.
AWT : Label
Swing : JLabel
Champ de Texte (TextField / JTextField) :
Zone où l'utilisateur peut saisir du texte.
AWT : TextField
Swing : JTextField
Zone de Texte (TextArea / JTextArea) :
Permet d'afficher et de saisir du texte sur plusieurs lignes.
AWT : TextArea
Swing : JTextArea
4. Organisation des Composants
Pour organiser les composants dans une fenêtre, on utilise des gestionnaires de mise en page
(layout managers) qui définissent comment les composants sont disposés.
FlowLayout : Positionne les composants de gauche à droite.
BorderLayout : Divise la fenêtre en cinq zones (North, South, East, West, Center).
GridLayout : Organise les composants dans une grille de lignes et de colonnes.
5. Exemple Simple avec Swing
ici c’est un exemple pour créer une fenêtre Swing avec quelques composants :
pour cet exemple, nous créons une fenêtre avec un panneau personnalisé, une étiquette, un
champ de texte et un bouton. Le setBounds définit la position et la taille de chaque
composant dans le panneau, pour bien comprire les methodes du chaque classe , voir la
partie prochaine
Les méthodes de classes GUI en AWT & Swing
Introspection en Java
L'introspection, également appelée "reflection" en anglais, est un mécanisme puissant en
Java qui permet d'examiner et de modifier la structure d'une classe, d'un objet ou d'une
méthode à l'exécution. Grâce à l'API [Link], on peut interroger les classes, accéder à
leurs méthodes, champs et constructeurs, et même modifier des éléments privés. Cela est
particulièrement utile dans la création de frameworks, d'outils de débogage ou pour réaliser
de la sérialisation et de l'injection de dépendances.
Pourquoi utiliser l'introspection ?
Exploration Dynamique : Elle permet d’examiner la structure d’une classe à l’exécution,
ce qui est très pratique pour des outils ou des frameworks génériques.
Invocation Dynamique : On peut appeler des méthodes ou modifier des champs (même
privés) sans connaître leur nom à l’avance.
Création d'Instances Dynamiques : Grâce aux constructeurs récupérés par introspection,
il est possible de créer des objets sans utiliser le mot-clé new de manière statique.
Flexibilité et Extensibilité : L’introspection favorise le développement de solutions
modulaires et adaptatives, en permettant par exemple la lecture d’annotations ou la
configuration automatique des objets.
Les Principales Classes de l'API Reflection
Pour réaliser l'introspection en Java, on utilise plusieurs classes essentielles du package
[Link] :
Class<T> : Représente une classe ou une interface en Java. Elle est la porte d'entrée pour
obtenir toutes les informations sur une classe.
Method : Représente une méthode d'une classe. Elle permet d’obtenir le nom, les
paramètres et même d’invoquer la méthode dynamiquement.
Field : Représente un champ (variable d'instance) d'une classe. On peut l'utiliser pour lire
ou modifier la valeur d'un attribut.
Constructor<T> : Représente un constructeur d'une classe, utile pour créer des instances
dynamiquement.
Modifier : Fournit des méthodes utilitaires pour analyser et interpréter les modificateurs
d'accès (public, private, static, final, etc.) d'une classe, d'une méthode ou d'un champ.
Utilisation de l'introspection en pratique
1. Obtenir un objet Class
Il existe plusieurs façons d’obtenir un objet Class qui représente une classe :
Via .class :
Via getClass() :
Via [Link]() :
2. Obtenir et examiner les méthodes d'une classe
Pour récupérer les méthodes d'une classe, on peut utiliser la méthode getDeclaredMethods():
Cela permet d’afficher le nom de toutes les méthodes déclarées dans la classe.
3. Accéder aux champs d'une classe
L’introspection permet aussi d’obtenir la liste des champs d’une classe avec
getDeclaredFields() :
Ici, on peut voir le nom de chaque champ et ses modificateurs d’accès (par exemple, public
ou private).
4. Modifier des champs privés
L’un des grands avantages de l’introspection est la possibilité d’accéder et de modifier des
champs privés. Pour ce faire, on utilise setAccessible(true) :
5. Invocation dynamique de méthodes
Il est possible d'appeler une méthode à partir de son nom de manière dynamique :
Ici, la méthode toUpperCase est invoquée dynamiquement sur l’objet texte.
6. Création dynamique d'instances
L'introspection permet de créer des instances de classes de façon dynamique en utilisant
leurs constructeurs :
On récupère le constructeur de la classe Exemple qui prend un paramètre de type String,
puis on crée une nouvelle instance avec la valeur fournie.
Conclusion
L'introspection est un outil extrêmement puissant qui offre une grande flexibilité dans le
développement Java. Elle permet d’examiner, d’invoquer et de manipuler dynamiquement
des classes, des méthodes et des champs, ce qui est très utile pour développer des
frameworks, des bibliothèques et des outils de débogage. Toutefois, en raison de ses
implications sur la performance et la sécurité, il est important de l’utiliser avec précaution.
Les méthodes de classes de l’introspection :
Les Threads en Java et la programmation concurrente
Les threads en Java permettent d'exécuter plusieurs tâches en même temps, un peu comme
si plusieurs personnes travaillaient en parallèle sur un même projet. Plutôt que de faire tout
de manière séquentielle, les threads permettent de diviser le travail pour accélérer le
traitement et améliorer la réactivité d'une application.
Points Essentiels
Créer un Thread :
Tu peux créer un thread en étendant la classe Thread ou en implémentant l'interface
Runnable.
Cela te permet de définir une méthode run() qui contient le code à exécuter.
Démarrer le Thread :
En appelant la méthode start(), le thread commence son exécution en parallèle avec les
autres tâches du programme.
Synchronisation :
Quand plusieurs threads accèdent aux mêmes ressources (comme des variables
partagées), il faut utiliser des mécanismes comme synchronized, wait(), et notify() pour
éviter des problèmes (comme deux cuisiniers utilisant la même poêle en même temps).
Contrôler le Comportement :
Tu peux mettre un thread en pause avec sleep(), attendre qu’un autre thread termine
avec join(), et même modifier la priorité pour influencer l’ordre d'exécution.
Voici un exemple rapide avec deux threads qui affichent des messages :
Sémaphore
Un sémaphore est un mécanisme de synchronisation qui contrôle l'accès à une ressource
limitée par un nombre fixe de "permits".
Usage : Permet de limiter le nombre de threads qui peuvent accéder simultanément à
une ressource partagée.
Exemple : Si tu as une imprimante partagée, tu peux créer un sémaphore avec un seul
permit pour t'assurer qu'un seul thread imprime à la fois.
Executor et ExecutorService
Un Executor est une interface qui permet d'exécuter des tâches de manière asynchrone sans
avoir à gérer directement la création et la gestion des threads.
ExecutorService est une extension de l'interface Executor qui fournit des méthodes pour
gérer et arrêter un groupe de threads (un "pool de threads") et permet d'obtenir des
résultats de tâches asynchrones.
Thread Pools
Un Thread Pool (ou pool de threads) est un ensemble de threads réutilisables qui exécutent
des tâches.
Avantages :
Réduction du coût de création de threads.
Meilleure gestion des ressources.
Exemple :
Callable et Future
Contrairement à l'interface Runnable, qui ne retourne rien, Callable permet de définir des
tâches qui renvoient un résultat et peuvent lancer des exceptions.
Future est un objet qui représente le résultat d'une tâche asynchrone. Tu peux l'utiliser
pour vérifier si la tâche est terminée et obtenir le résultat une fois disponible.
Exemple avec Callable et Future
Pour résumer :
Programmation Concurrente : Permet l'exécution simultanée de plusieurs tâches pour
une meilleure performance.
Sémaphore : Contrôle l'accès à une ressource limitée en limitant le nombre de threads
simultanés.
Executor/ExecutorService et Thread Pools : Gèrent l'exécution des tâches via des pools
de threads réutilisables, simplifiant ainsi la gestion des threads.
Callable et Future : Permettent d'exécuter des tâches asynchrones avec un résultat
retourné, offrant une flexibilité supplémentaire par rapport à Runnable.
Quelques méthodes des classes
Java Collections Framework (JCF)
Le Java Collections Framework (JCF) est une bibliothèque qui fournit des structures de
données réutilisables et optimisées, comme les listes, ensembles, files, et maps. Ces classes
permettent de stocker, manipuler et rechercher des objets efficacement.
🗂 Les principales interfaces du JCF
Le JCF repose sur plusieurs interfaces clés :
Interface Description
Collection<E> Interface mère de toutes les collections
(sauf Map).
List<E> Une collection ordonnée (ex : ArrayList,
LinkedList).
Set<E> Un ensemble sans doublon (ex : HashSet,
TreeSet).
Queue<E> Une file d’attente (FIFO ou autres, ex :
PriorityQueue).
Deque<E> Une file d’attente à double entrée (ex :
ArrayDeque).
Map<K, V> Une collection clé-valeur (ex : HashMap,
TreeMap).
Les classes principales du JCF :
List (Les listes : ArrayList, LinkedList, Vector, Stack)
Une List est une collection ordonnée qui permet des éléments en double et l'accès par index.
Différences entre les implémentations :
ArrayList : Tableau dynamique, rapide en lecture, lent en insertion.
LinkedList : Liste chaînée, rapide en insertion/suppression, lent en accès indexé.
Vector : Comme ArrayList mais synchronisé (plus lent).
Stack : Une pile (LIFO).
Set (Les ensembles : HashSet, TreeSet, LinkedHashSet)
Un Set stocke des éléments uniques (pas de doublons).
Différences entre les implémentations :
HashSet : Rapide mais sans ordre garanti.
LinkedHashSet : Conserve l'ordre d’insertion.
TreeSet : Trie les éléments automatiquement.
Map (Les paires clé-valeur : HashMap, TreeMap, LinkedHashMap)
Une Map stocke des associations clé-valeur. Les clés sont uniques, mais plusieurs valeurs
peuvent être identiques.
Différences entre les implémentations :
HashMap : Rapide, sans ordre garanti.
LinkedHashMap : Conserve l’ordre d’insertion.
TreeMap : Trie les clés automatiquement.
Queue et Deque (Les files d'attente)
Une Queue suit le principe FIFO (First In, First Out).
Une Deque est une double queue, où l'on peut ajouter/retirer des deux côtés.
Différences :
PriorityQueue : Trie les éléments selon leur priorité.
ArrayDeque : Meilleure alternative à Stack et LinkedList en termes de performance.