Enregistrements

Enregistrements - Fichiers
Objectif
Le but de ce TP est de vous faire découvrir les fichiers et les enregistrements.
Les fichiers permettent de sauvegarder et de récupérer des données d'une exécution à l'autre.
Les enregistrements sont des types de variables qui serviront à stocker différentes données, comme
les tableaux sauf qu'ici les données peuvent être de types hétérogènes.
Pré-requis
Ce TP utilisera les notions d'IHM acquises au TP précédent.
Travail préparatoire
Liste des fonctions/procédures disponibles pour les fichiers
En fonction du type de fichier, on a les procédures/fonctions suivantes qui peuvent être utilisées :
Fichier de type FichierEnEcriture
•
•
•
•
•
void ouvrirFichierEnEcriture(String nomFichier) : procédure recevant le nom du fichier à écrire.
Doit être appelé AVANT toute écriture dans le fichier.
void ecrireChaineDansFichier(String txt) : procédure permettant d'écrire la chaine txt dans le
fichier texte.
void ecrireEntierDansFichier(int nb) : procédure permettant d'écrire l'entier nb dans le fichier
texte.
void ecrireDoubleDansFichier(double nb) : procédure permettant d'écrire le double nb dans le
fichier texte
void fermerFichierEnEcriture() : procédure fermant le fichier (on ne doit plus essayer de
l'écrire après!)
Fichier de type FichierEnLecture
•
•
•
•
•
void ouvrirFichierEnLecture(String nomFichier) : procédure recevant le nom du fichier à lire.
Doit être appelé AVANT toute lecture depuis le fichier.
int lireEntierDepuisFichier() : fonction qui retourne l'entier lu depuis la ligne courante du fichier
(puis la ligne suivante devient la nouvelle ligne courante)
double lireDoubleDepuisFichier() : idem mais lit la ligne sous forme d'un double (ça DOIT être
un double, sinon ça plante)
String lireChaineDepuisFichier() : idem mais lit la ligne sous forme d'une chaine (ça marche
toujours)
void fermerFichierEnLecture() : procédure fermant le fichier (on ne doit plus essayer de le lire
après!)
Tutoriel sur les fichiers
On va vous montrer comment on peut enregistrer des informations dans des fichiers textes puis les
relire.
Démarche à suivre :
Avant toute opération de lecture ou écriture dans un fichier, il faut au préalable l'ouvrir dans le bon
mode (lecture ou écriture) et pour cela déclarer votre variable fichier avec le bon type
(FichierEnLecture ou FichierEnEcriture).
A la fin des opérations de lecture ou écriture, il ne faut pas oublier de fermer le fichier.
Manipulations
Objectif :
On va faire un programme qui, quand on appuiera sur un bouton, écrira un fichier avec deux mots
puis, quand on appuiera sur un autre bouton, relira ce fichier et affichera ces deux mots dans
l'interface.
Fichiers nécessaires :
Pour commencer, ajoutez dans votre répertoire de travail les deux fichiers suivants (faites un clic droit
sur les 2 fichiers suivant (l'un puis l'autre) puis choisir l'option de menu enregistrer la cible sous... puis
dans le dossier src (voir ci-dessous)) :
•
•
FichierEnLecture.java
FichierEnEcriture.java
Ils doivent être dans le sous-répertoire de votre projet, celui dans lequel seront vos autres fichiers
JAVA.
Exemple :
•
•
votre projet se nomme tp2 et le dossier de travail est dans le répertoire Z:\TP2\ExoFichiers\
copiez les 2 fichiers dans le répertoire : Z:\TP2\ExoFichiers\tp2\src
Ces 2 fichiers ont été créés pour ajouter des objets simplifiant la manipulation de fichiers texte avec
java.
Vous allez réaliser une IHM comme celle-ci :
Tutoriel 1 : Ecriture d'un fichier
•
•
•
•
•
•
•
•
•
•
•
Dans le projet courant (ou un nouveau si vous le souhaitez), commencez par créer une
nouvelle JFrame. Nommez-la TestFichier.
Ajoutez-y deux boutons (renommez-les btnEcriture et btnLecture) et deux labels (renommezles lblNom1 et lblNom2).
Ajoutez un gestionnaire d'événement sur le bouton btnEcriture et mettez-y le code suivant :
FichierEnEcriture monFichier = new FichierEnEcriture();
monFichier.ouvrirFichierEnEcriture("test.txt");
monFichier.ecrireChaineDansFichier("Riri");
monFichier.ecrireChaineDansFichier("Fifi");
monFichier.fermerFichierEnEcriture();
La première ligne permet de déclarer une variable nommée ici monFichier de type
FichierEnEcriture (vous comprendrez la syntaxe utilisée l'année prochaine en I3 dans le cours
programmation objet).
Faites que ce fichier soit le programme par défaut (voir FAQ)
Lancez le programme, appuyez sur le bouton btnEcriture et constatez qu'un fichier a été créé
dans votre répertoire de travail (TP2) et en l'ouvrant avec le blocnote, vérifiez qu'il contient
bien deux lignes avec Riri et Fifi.
Résultat
En allant dans votre répertoire de travail, vous constaterez qu'un nouveau fichier nommé test.txt a été
créé. Vous pouvez l'ouvrir à l'aide du bloc note de Windows pour voir son contenu.
Tutoriel 2 : Lecture d'un fichier
•
•
•
•
•
•
•
•
Ajoutez un gestionnaire d'événement sur le bouton btnLecture et mettez-y le code suivant :
FichierEnLecture monFichier = new FichierEnLecture();
monFichier.ouvrirFichierEnLecture("test.txt");
String nom1 = monFichier.lireChaineDepuisFichier();
String nom2 = monFichier.lireChaineDepuisFichier();
lblNom1.setText(nom1);
lblNom2.setText(nom2);
monFichier.fermerFichierEnLecture();
•
Lancez le programme, appuyez sur le bouton btnLecture et constatez que les deux mots
contenus dans le fichier sont affichés dans l'interface. Vous pouvez tenter de modifier le
contenu du fichier texte à l'aide du blocnote afin de constater que ce sont bien les textes du
fichier qui sont affichés.
Tutoriel sur la notion d'enregistrement
Présentation
Le projet qui vous est donné comporte :
•
une IHM : CarnetAdresse.java (jFrame)
•
un code définissant une personne : Personne.java.
Commencez par :
•
•
•
•
Télécharger le projet
Dézipper l'archive.
Ouvrir le projet avec Netbeans
Ouvrir le fichier : Personne.java.
Le code Personne.java définit les informations d'une personne. Pour cela, on va 'enrichir' le
vocabulaire des types connus par Java (actuellement int, double, boolean, String, ...) en créant un
nouveau type : Personne.
Grace à ce nouveau type, on pourra s'en servir par la suite pour créer des variables de ce type.
Le type Personne est comme un tableau, c'est à dire que dans une variable de type Personne, on va
pouvoir stocker plusieurs informations (ici 3).
Ces informations sont :
- le nom de la personne (type : chaîne de caractères),
- le prénom de la personne (type : chaîne de caractères),
- son âge (type : entier)
Chaque variable dans le programme qui sera une Personne aura donc ces 3 informations.
Pour modifier ou consulter le nom d'une Personne il faut :
•
Définir une variable simple de type Personne :
Personne moi = new Personne();
Ceci crée un variable moi qui aura les 3 informations nom, prenom et age et réserve l'espace disque
pour stocker ces informations.
•
Nous accédons aux données comme suit :
moi.nom = "Toto"; //chaine de caractères
moi.prenom ="Tata"; //chaine de caractères
moi.age = 11; //entier
•
Tableaux
Si vous avez besoin de stocker plusieurs variables de type Personne, il est possible de définir des
tableaux de Personne comme suit :
Personne[] carnet = new Personne[100]; //crée un tableau de 100 Personnes
Carnet est donc un tableau de 100 cases, chaque case étant dimensionnée pour recevoir une variable
de type Personne.
Remarques :
•
Vous devrez réserver l'espace mémoire pour chaque nouvelle case du tableau avec new
Personne() sinon vous ne pourrez pas remplir les champs nom, prenom et age.
Exemple :
•
le code suivant compile mais posera problème à l'exécution :
Personne[ ] carnet = new Personne[100]; //créé un tableau de taille 100
for (int i=0; i< NbPersonnes;i++)
{
carnet[i].nom = 'test'; //impossible car pas de réservation de l'espace mémoire sur le disque
}
•
alors que ce code est correct :
Personne[ ] carnet = new Personne[100]; //créé un tableau de taille 100
for (int i=0; i< NbPersonnes;i++)
{
carnet[i] = new Personne(); //réservation de l'espace mémoire pour les champs d'une personne
carnet[i].nom = 'test'; //ok
}
•
Rappel : vous devrez intégrer à votre projet les fichiers suivants pour manipuler les fichiers
(voir TP2)
• FichierEnLecture.java
• FichierEnEcriture.java
Manipulez le projet qui vous est donné afin de mieux comprendre ces
notions.
Lancez l'exécution du projet et suivez le fonctionnement des boutons qui vous sont données.
Ce projet comporte 2 boutons :
- le bouton ajouter permet de :
- créer une nouvelle personne dans une tableau de personnes.
- renseigner les champs nom, prenom, age de cette personne.
- le bouton afficher qui
- affiche s'il n'y a pas de personne saisie ou
- affiche la personne dans la case 0 du tableau.
Remarque
Les commentaires et les noms de variables explicites ont été choisis pour que la compréhension du
programme soit facilité pour les relecteurs.
Pensez à faire de même dans vos programmes.