Cours CNAM par J. Laforgue

Exercice10_ES_Projet2_Agenda

Retour

Télécharger

Cet exercice consiste à faire évoluer le projet 2 de NFA 035 20012/2013 afin sauver l'agenda dans un fichier binaire et d'ouvrir l'agenda à partir d'un fichier binaire.
Le sujet de cet exercice est décrit dans le fichier pdf.

Exercice_SuiteProjet2_NFA032_2012-2013.pdf

      AGENDA.txt
            TACHE.txt
      compil.bat
      fr
         cnam
            ihm
            prog
               Projet2.java
            rdv
               Agenda.java

package fr.cnam.rdv;

import java.util.*;
import java.io.*;
import fr.cnam.util.*;

// Classe de définition d'un agenda
//    L'agenda contient des rendez-vous, des rendez-vous, des tâches à faire
//    Ces éléments sont lus dans des fichiers plats (pas d'utilisation de base de données)
//
public class Agenda
{
    String nomFichier;

// La collection contenant les éléments de l'agenda
    //   ElementAgenda est la classe abstraite dont les rendez-vous et taches héritent
    //
    private ArrayList<ElementAgenda> elements;

// Constructeur
    //
    public Agenda()
    {
        nomFichier = "";

// Initialisation des attributs
        //
        this.elements = new ArrayList<ElementAgenda>();
    }

// Enregistre dans le fichier binaire le contenu de l'agenda
    //  Chaque élément de l'agenda est écrit un par un
    //
    public void enregistrer(String nomFichier) throws Exception
    {
        File f = new File("../"+nomFichier);
        FileOutputStream fos = new FileOutputStream(f);
        DataOutputStream dos = new DataOutputStream(fos);
        
        dos.writeInt(elements.size());
        for(ElementAgenda e : elements)
            e.ecrire(dos);
        dos.close();

this.nomFichier = nomFichier;
    }

// Lecture des éléments de l'agenda dans un fichier bianire
    //
    public void ouvrir(String nomFichier) throws Exception
    {
        ArrayList<ElementAgenda> tmp = new ArrayList<ElementAgenda>();

File f = new File("../"+nomFichier);
        FileInputStream fis = new FileInputStream(f);
        DataInputStream dis = new DataInputStream(fis);
        
        int nb = dis.readInt();
        for(int i=0;i<nb;i++)
            {
                String type = dis.readUTF();
                
                if (type.equals("RDV"))
                    {
                        RendezVous rdv = new RendezVous("","","","");
                        rdv.lire(dis);
                        tmp.add(rdv);
                    }
                if (type.equals("TACHE"))
                    {
                        Tache tache = new Tache("","",0);
                        tache.lire(dis);
                        tmp.add(tache);
                    }
            }
        dis.close();

this.nomFichier = nomFichier;
        this.elements = tmp;
    }

// La méthode charger devient deux methodes d'import
    //
    public void importerRdvs(String nomFichierRdv) throws Exception
    {
        // Lecture du fichier contenant les rendez vous
        //
        int num=0;
        String[] lignes = Terminal.lireFichierTexte("../"+nomFichierRdv);

// On traite chaque ligne contenant soit un rendez-vous classique soit
        //  un rendez-vous périodique
        //
        for(String l:lignes)
            {
                try{
                    num++;
                    if (! siPeriodiqueLigne(l))
                        {
                            RendezVous rdv = RendezVous.decoderLigne(l);
                            elements.add(rdv);
                        }
                    else
                        {
                            RendezVousPeriodique rdv = RendezVousPeriodique.decoderLigne(l);
                            elements.add(rdv);
                        }
                }catch(Exception ex)
                    {
                        throw new Exception("Erreur de lecture ligne "+num);
                    }
            }
    }

public void importerTaches(String nomFichierTache) throws Exception
    {
        int num=0;

// Lecture du fichier contenant les rendez vous
        //
        String[] lignes = Terminal.lireFichierTexte("../"+nomFichierTache);

// On traite chaque ligne contenant une tache
        //
        for(String l:lignes)
            {
                try{
                    num++;
                    Tache tache = Tache.decoderLigne(l);
                    elements.add(tache);
                }catch(Exception ex)
                    {
                        throw new Exception("Erreur de lecture ligne "+num);
                    }
            }
    }

// Méthode static qui détermine si une ligne du fichier contient un rendez-vous periodique ou non 
    //
    private static boolean siPeriodiqueLigne(String ligne) throws Exception
    {
        StringTokenizer strtok = new StringTokenizer(ligne," ");
        String str = strtok.nextToken();
        if ( str.equals("journalier") ||
             str.equals("hebdomadaire") ||
             str.equals("mensuel") )
            return true;
        else
            return false;
    }

// Méthode qui retourne sous la forme d'un texte de caractère le contenu de 
    //  l'agenda
    public String toString()
    {
        // On trie les éléments de l'agenda
        Collections.sort(elements);

// Construction par concaténation du contenu de chaque élément de l'agenda
        // Chaque élément est numéroté afin de pouvoir choisir l'élément
        //
        String s = "";
        for(int i=0;i<elements.size();i++)
            s=s+
                "Numero : "+i+"\n"+
                elements.get(i).toString()+"\n--------------------------------\n";
        return s;
    }

// Méthode qui ajoute un nouvel élément dans l'agenda
    //
    public void ajouterElement(ElementAgenda e)
    {
        elements.add(e);
    }

// Méthode qui retourne sous la forme d'un texte le contenu de 
    //  l'agenda dont les éléments sont pour le jour donné
    //
    public String agendaJour(Calendar jour)
    {
        String s="";
        boolean ok=false;
        for(int i=0;i<elements.size();i++)
            {
                ElementAgenda e=elements.get(i);

// On teste si l'élément est dans la période du jour
                // Cette méthode est implémentée dans chacune des classes
                //   RendezVous et Tache
                //
                if (e.siDansLaPeriode(jour))
                    {
                        s=s+"Numero : "+i+"\n"+e.toString();
                        s=s+"\n--------------------------------\n";
                        ok=true;
                    }
            }
        if (!ok) s = "PAS D'ELEMENT A CETTE DATE";
        return s;
    }

// Méthode static qui convertit une chaine en date Calendar
    // Si la chaine ne contient pas une date valide alors
    //   la valeur de retour est null
    //
    static public Calendar stringToCalendar(String date)
    {
        Calendar cal=null;
        try
            {
                String[] t = date.split("/");
                
                cal = Calendar.getInstance();
                cal.clear();
                cal.set(Integer.parseInt(t[2]),
                        Integer.parseInt(t[1])-1,  // Les mois commence en 0
                        Integer.parseInt(t[0]));
                
                // Si la date saisie est correcte en format mais contient des valeurs entières
                //  qui ne correspondent pas valides
                if ( (cal.get(Calendar.YEAR)!=Integer.parseInt(t[2])) ||
                     (cal.get(Calendar.MONTH)!=Integer.parseInt(t[1])-1) ||
                     (cal.get(Calendar.DAY_OF_MONTH)!=Integer.parseInt(t[0])) )
                    {
                        cal=null;
                    }
            }
        catch(Exception ex){ cal = null;}  // Exception si erreur de format (pb de / ou pas un entier)
        
        return(cal);
    }

// Retourne le i-ième élément de l'agenda 
    //
    public ElementAgenda getElement(int i)
    {
        return elements.get(i);
    }
}

ElementAgenda.java

package fr.cnam.rdv;

import java.util.*;
import java.io.*;

// Cette classe abstraite est la définition d'un élément de l'agenda.
//  Les classes RendezVous et Tache héritent de cette classe et implémentent
//   les méthodes abstraites utilisées dans les traitements génériques de
//   la classe Agenda
//
// Cette classe implémente l'interface Comparable afin de pouvoir trier
//  les éléments de l'agenda
//
//    
public abstract class ElementAgenda implements Comparable<ElementAgenda>
{
    // Tous les éléments d'un agenda ont un texte
    protected String texte;

// Le constructeur
    public ElementAgenda(String texte)
    {
        this.texte = texte;
    }

// ---- Les méthodes abstraites -------

// Méthode qui permet de savoir si un élément est pour un jour donné
    abstract public boolean siDansLaPeriode(Calendar jour);

// Méthode qui permet d'ordonner les éléments
    // Elle retourne 
    //   dans le cas d'un RendezVous la date sous la forme d'un entier 
    //   dans le cas d'une Tache la priorite ou la date butée sous la forme d'un entier
    //
    abstract long getOrdre();
    
    // -------------------------------------

// Méthode qui permet de modifier sous formm d'IHM un élément de l'agenda
    // Cette méthode doit être surchargée par chaque classe 
    //   RendezVous RendezVousPeriodique Tache
    // 
    public void modifierIhm()
    {
        System.out.println("L'ihm n'est pas implementee");
    }

// Méthode d'implémentaiton de l'interface Comparable
    //  utilisé pour trier les éléments de l'agenda
    // Cette méthode utilise la méthode getOrdre qui est implémentée par
    //  chacune des classes RendezVous et Tache
    //
    public int compareTo(ElementAgenda e2)
    {
        if (this.getOrdre()<e2.getOrdre())
            return -1;
        else if (this.getOrdre()>e2.getOrdre())
            return +1;
        else
            return 0;
    }

abstract public void ecrire(DataOutputStream dos) throws Exception;

abstract public void lire(DataInputStream dis) throws Exception;
}

IHMAgenda.java

package fr.cnam.rdv;

import java.lang.*;
import java.util.*;
import java.io.*;

import fr.cnam.rdv.*;
import fr.cnam.ihm.*;

// Classe qui crée une IHM permettant de gérer l'agenda
// Elle implémente l'interface FormulaireInt afin de réaliser
//  les actions dans l'IHM
//
public class IHMAgenda implements FormulaireInt
{
    private Agenda agenda;  // L'agenda
    
    // Le constructeur qui crée les objets de l'IHM
    //
    public IHMAgenda(Agenda agenda) throws Exception
    {
        int x,y;

// Initialisation des attributs
        this.agenda = agenda;

// Date courante (utilisé par défaut dans l'IHM)
        Calendar calActuel = Calendar.getInstance();
        int dj = calActuel.get(Calendar.DAY_OF_MONTH)+1;
        int dm = calActuel.get(Calendar.MONTH)+1;
        int dy = calActuel.get(Calendar.YEAR);
        String dateActuelle = String.format("%s/%s/%s",dj,dm,dy);
        
        // Création du formulaire
        Formulaire form = new Formulaire("AGENDA",this,false,800,600);

// Pour gérer les fichiers
        form.addText("NOM_FICHIER_DATA","Nom du fichier",true);
        form.addButton("OUVRIR","Ouvrir",-1,-1,200);
        form.addButton("ENREGISTRER","Enregistrer",-1,-1,200);
        y = form.getYCour();
        form.addText("NOM_FICHIER_IMPORT_RDVS","Fichier texte de rdvs",true,"",-1,-1,180,5,150);
        form.addButton("IMPORTER_RDVS","Importer",340,y,100);
        y = form.getYCour();
        form.addText("NOM_FICHIER_IMPORT_TACHES","Fichier texte de taches",true,"",0,-1,180,5,150);
        form.addButton("IMPORTER_TACHES","Importer",340,y,100);

// Création des zones de texte permettant d'ajouter un nouveau rendez-vous
        form.addLabel("Pour ajouter un rendez vous",10,200,200);
        form.addText("DATE_RDV","Date",true,"",-1,-1,150,5,50);
        form.addText("HEURE_DEBUT_RDV","Heure de debut",true,"",-1,-1,150,5,50);
        form.addText("HEURE_FIN_RDV","Heure de fin",true,"",-1,-1,150,5,50);
        form.addText("TEXTE","Texte",true,"",-1,-1,150,5,100);
        form.addButton("AJOUTER_RDV","Ajouter");
        y = form.getYCour();

// Création de la zone de texte permettant d'afficher le contenu
        //  de l'agenda ou les informations d'erreur
        //
        form.addZoneText("RESULTAT","Resultat",true,agenda.toString(),450,30,400,500);

// Création du bouton permettant d'afficher tout l'agenda
        form.addLabel("Pour afficher le contenu de l'agenda",10,y+30,300);
        form.addButton("TOUT_AGENDA","Tout l'agenda",-1,-1,200);
        y = form.getYCour();

// Création des objets permettant de faire l'action
        //  qui affiche les éléments d'un jour donné
        form.addLabel("Pour afficher les rdv d'un jour",10,y+30,300);
        form.addText("JOUR","Date",true,dateActuelle,-1,-1,50,0,100);
        form.addButton("JOUR_AGENDA","Valider",-1,-1,100);
        y = form.getYCour();

// Création des objets permettant de faire l'action
        //  qui permet de modifier un élement donné
        form.addLabel("Pour modifier un element",10,y+30,300);
        form.addText("NUMERO","Numero",true,"",-1,-1,50,0,50);
        form.addButton("MODIFIER","Modifier",-1,-1,100);

// Affichage de l'IHM
        form.afficher();
    }

// Méthode qui est appelé par l'IHM quand on clique dans un bouton
    // Cette méthode a en entrée le formulaire et le nom du bouton
    //
    public void  submit(Formulaire form,String nomSubmit)
    {
        // ACTION : ajouter un nouveau rendez-vous
        // ----------------------------------------------
        if (nomSubmit.equals("AJOUTER_RDV"))
            {
                Calendar cal = Agenda.stringToCalendar(form.getValeurChamp("DATE_RDV"));
                if (cal==null)
                    form.setValeurChamp("RESULTAT","Erreur de saisi dans la date");
                else
                    {
                        agenda.ajouterElement(new RendezVous(form.getValeurChamp("DATE_RDV"),
                                                             form.getValeurChamp("HEURE_DEBUT_RDV"),
                                                             form.getValeurChamp("HEURE_FIN_RDV"),
                                                             form.getValeurChamp("TEXTE")));
                        form.setValeurChamp("RESULTAT",agenda.toString());
                    }
            }

// ACTION : affiche le contenu de tout l'agenda
        // ----------------------------------------------
        if (nomSubmit.equals("TOUT_AGENDA"))
            {
                form.setValeurChamp("RESULTAT",agenda.toString());
            }

// ACTION : affiche les éléments d'un jour donné
        // ----------------------------------------------
        if (nomSubmit.equals("JOUR_AGENDA"))
            {
                String sj = form.getValeurChamp("JOUR");
                Calendar cal = Agenda.stringToCalendar(sj);
                if (cal==null)
                    form.setValeurChamp("RESULTAT","ERREUR: la date n'est pas bonne");
                else 
                    form.setValeurChamp("RESULTAT",agenda.agendaJour(cal));
            }

// ACTION : modifier un des éléments de l'agenda
        // ----------------------------------------------
        if (nomSubmit.equals("MODIFIER"))
            {
                String snum = form.getValeurChamp("NUMERO");
                int num = Integer.parseInt(snum);
                agenda.getElement(num).modifierIhm();
            }

// ACTION : ouvrir un fichier d'agenda
        // ----------------------------------------------
        if (nomSubmit.equals("OUVRIR"))
            {
                String nomFichier = form.getValeurChamp("NOM_FICHIER_DATA");
                if (nomFichier.equals(""))
                    {
                        form.setValeurChamp("RESULTAT","Le champ est vide");
                    }
                else
                    {
                        try{
                            agenda.ouvrir(nomFichier);
                            form.setValeurChamp("RESULTAT",agenda.toString());
                        }
                        catch(Exception ex)
                            {
                                StringWriter sw = new StringWriter();
                                sw.write("Pb dans l'ouverture ou le chargement du fichier\n");
                                ex.printStackTrace(new PrintWriter(sw));
                                form.setValeurChamp("RESULTAT",sw.toString());

}
                    }
            }

if (nomSubmit.equals("ENREGISTRER"))
            {
                String nomFichier = form.getValeurChamp("NOM_FICHIER_DATA");
                if (nomFichier.equals(""))
                    {
                        form.setValeurChamp("RESULTAT","Le champ est vide");
                    }
                else
                    {
                        try{
                            agenda.enregistrer(nomFichier);
                            form.setValeurChamp("RESULTAT","Agenda sauvegarde dans "+nomFichier);
                        }
                        catch(Exception ex)
                            {
                                StringWriter sw = new StringWriter();
                                sw.write("Pb d'enregistrement de l'agenda\n");
                                ex.printStackTrace(new PrintWriter(sw));
                                form.setValeurChamp("RESULTAT",sw.toString());
                            }
                    }
            }

if (nomSubmit.equals("IMPORTER_RDVS"))
            {
                String nomFichier = form.getValeurChamp("NOM_FICHIER_IMPORT_RDVS");
                if (nomFichier.equals(""))
                    {
                        form.setValeurChamp("RESULTAT","Le champ est vide");
                    }
                else
                    {
                        try{
                            agenda.importerRdvs(nomFichier);
                            form.setValeurChamp("RESULTAT",agenda.toString());
                        }
                        catch(Exception ex)
                            {
                                StringWriter sw = new StringWriter();
                                sw.write("Pb d'import du fichier\n");
                                ex.printStackTrace(new PrintWriter(sw));
                                form.setValeurChamp("RESULTAT",sw.toString());
                            }
                    }
                
            }

if (nomSubmit.equals("IMPORTER_TACHES"))
            {
                String nomFichier = form.getValeurChamp("NOM_FICHIER_IMPORT_TACHES");
                if (nomFichier.equals(""))
                    {
                        form.setValeurChamp("RESULTAT","Le champ est vide");
                    }
                else
                    {
                        try{
                            agenda.importerTaches(nomFichier);
                            form.setValeurChamp("RESULTAT",agenda.toString());
                        }
                        catch(Exception ex)
                            {
                                StringWriter sw = new StringWriter();
                                sw.write("Pb d'import du fichier\n");
                                ex.printStackTrace(new PrintWriter(sw));
                                form.setValeurChamp("RESULTAT",sw.toString());
                            }
                    }
                
            }
        
    }
}

RendezVous.java

package fr.cnam.rdv;

import java.util.*;
import java.io.*;

import fr.cnam.ihm.*;

// Classe de définition d'un rendez-vous classique (non périodique)
// Elle hérite de la classe abstraite ElementAgenda
// Elle implémente l'interface FormulaireInt pour pouvoir modifier 
//  un RendezVous avec une IHM
//
public class RendezVous extends ElementAgenda implements FormulaireInt
{
    protected String date;       // Date de debut du rendez-vous
    protected String heureDebut; // Heure de debut du rendez-vous
    protected String heureFin;   // Heure de fin du rendez-vous

// Constructeur
    //
    public RendezVous(String date,
                      String heureDebut,
                      String heureFin,
                      String texte)
    {
        super(texte);
        this.date       = date;
        this.heureDebut = heureDebut;
        this.heureFin   = heureFin;
    }

// Méthode static qui retourne une RendezVous à partir d'une ligne du fichier texte
    //  Si la ligne ne peut pas etre décodée alors retourne un exception
    //
    public static RendezVous decoderLigne(String ligne) throws Exception
    {
        StringTokenizer strtok = new StringTokenizer(ligne," ");
        String date = strtok.nextToken();
        String heureDebut = strtok.nextToken();
        String heureFin = strtok.nextToken();
        String texte="";
        while (strtok.hasMoreTokens())
            texte=texte+" "+strtok.nextToken();
        
        return( new RendezVous(date,
                               heureDebut,
                               heureFin,
                               texte) );
    }

// RendezVous sous forme de chaine
    //
    public String toString()
    {
        String str="";
        str = str + String.format("%-15s : %-15s\n","Date",date);
        str = str + String.format("%-15s : %-15s\n","Heure debut",heureDebut);
        str = str + String.format("%-15s : %-15s\n","Heure fin",heureFin);
        str = str + String.format("%-15s : %-15s\n","Texte",texte);
        return(str);
    }
    
    // Retourne la date du RendezVous sous la forme d'un Calendar
    //
    public Calendar getDate()
    {
        Calendar cal = Calendar.getInstance();
        cal.clear();
        try{
            String[] t = date.split("/");
            cal.set(Integer.parseInt(t[2]),
                    Integer.parseInt(t[1])-1,  // Les mois commence en 0
                    Integer.parseInt(t[0]));
        }catch(Exception ex){} // si erreur de format la date est à 0
        return(cal);
    }

// Cette méthode détermine si le RendezVous est dans le jour donné
    //   (Cette même méthode est implémentée par RendzeVousPeriodique et Tache)
    //
    public boolean siDansLaPeriode(Calendar jour)
    {
        return getDate().equals(jour) ;
    }

// Cette méthode est utilisée par la méthode compareTo qui est dans la classe abstraite
    //  ElementAgenda.
    // Elle retourne un entier qui est utilisé comme valeur de comparaison pour trier
    //  les éléments de l'agenda
    //
    public long getOrdre()
    {
        // La valeur entière d'une date (nombre de millisecondes depuis le 1/1/1970
        return( getDate().getTime().getTime() );
    }

// Cette méthode est appelée dans l'IHM pour modifier un RendezVous
    // Elle est également implémentée dans chacune des classes RendezVousPeriodique et Tache
    //
    public void modifierIhm()
    {
        // Création du formulaire : l'objet RendezVous lui-même est passé en paramètre
        //   C'est lui qui réalise l'action
        Formulaire form = new Formulaire("Modifier un rendez vous",this,false,400,300);

form.addText("DATE_RDV","Date",true,this.date);
        form.addText("HEURE_DEBUT_RDV","Heure de debut",true,this.heureDebut);
        form.addText("HEURE_FIN_RDV","Heure de fin",true,this.heureFin);
        form.addText("TEXTE","Texte",true,this.texte,-1,-1,-1,-1,250);
        form.addButton("MODIFIER","Modifier");

try{
            form.afficher();
        }catch(Exception ex){}
    }

// Méthode appelée par le formulaire quand on clique sur un bouton
    //
    public void  submit(Formulaire form,String nomSubmit)
    {
        if (nomSubmit.equals("MODIFIER"))
            {
                // On récupère les valeurs de l'IHM et on affecte les attributs de l'objet
                this.date       = form.getValeurChamp("DATE_RDV");
                this.heureDebut = form.getValeurChamp("HEURE_DEBUT_RDV");
                this.heureFin   = form.getValeurChamp("HEURE_FIN_RDV");
                this.texte      = form.getValeurChamp("TEXTE");
                form.fermer();
            }
    }

public void ecrire(DataOutputStream dos) throws Exception
    {
        dos.writeUTF("RDV");
        dos.writeUTF(this.date);
        dos.writeUTF(this.heureDebut);
        dos.writeUTF(this.heureFin);
        dos.writeUTF(this.texte);
    }

public void lire(DataInputStream dis) throws Exception
    {
        this.date       = dis.readUTF();
        this.heureDebut = dis.readUTF();
        this.heureFin   = dis.readUTF();
        this.texte      = dis.readUTF();
    }
}

RendezVousPeriodique.java

package fr.cnam.rdv;

import java.util.*;
import fr.cnam.ihm.*;

// Classe de définition d'un rendez-vous périodique
// Cette classe hérite de la classe RendezVous car elle la complète
// Cette classe implémente l'interface FormulaireInt qui est
//  utilisée par le formulaire de modification en IHM
//
public class RendezVousPeriodique extends RendezVous implements FormulaireInt
{
    private String periode;  // La période du rendez-vous : 
    // "journalier" "hebdomadaire" ou "mensuel"

private String dateFin;  // Date de fin du rendez-vous périodique

// Constructeur
    //
    public RendezVousPeriodique(String periode,
                                String dateDebut,
                                String dateFin,
                                String heureDebut,
                                String heureFin,
                                String texte)
    {
        super(dateDebut,heureDebut,heureFin,texte);
        this.periode = periode;
        this.dateFin = dateFin;
    }

// Méthode static qui retourne une RendezVousPeriodique à partir d'une ligne du fichier texte
    //  Si la ligne ne peut pas etre décodée alors retourne un exception
    //
    public static RendezVousPeriodique decoderLigne(String ligne) throws Exception
    {
        StringTokenizer strtok = new StringTokenizer(ligne," ");
        String periode = strtok.nextToken();
        String dateDebut = strtok.nextToken();
        String dateFin = strtok.nextToken();
        String heureDebut = strtok.nextToken();
        String heureFin = strtok.nextToken();
        String texte="";
        while (strtok.hasMoreTokens())
            texte=texte+" "+strtok.nextToken();
        
        return( new RendezVousPeriodique(periode,
                                         dateDebut,
                                         dateFin,
                                         heureDebut,
                                         heureFin,
                                         texte) );
    }

// RendezVousPeriodique en chaine
    //
    public String toString()
    {
        String str="";
        str = str + String.format("%-15s : %-15s\n","Periode",periode);
        str = str + String.format("%-15s : %-15s\n","Date de fin",dateFin);
        str = str + super.toString(); // Appel de la classe héritée
        return(str);
    }

// Retourne la date calendaire de début du rendez-vous
    //
    public Calendar getDateDebut()
    {
        return(getDate());
    }

// Retourne la date calendaire de fin du rendez-vous
    //
    public Calendar getDateFin()
    {
        Calendar cal = Calendar.getInstance();
        cal.clear();
        String[] t = dateFin.split("/");
        cal.set(Integer.parseInt(t[2]),
                Integer.parseInt(t[1])-1,  // Les mois commence en 0
                Integer.parseInt(t[0]));
        return(cal);
    }

// Cette méthode détermine si le RendezVousPeriodique est dans le jour donné
    // Elle calcule toutes les dates possibles du rdv périodique puis recherche 
    //   si la journée est parmi une de ces dates.
    // (Cette même méthode est aussi implémentée par RendzeVous et Tache)
    //
    public boolean siDansLaPeriode(Calendar jour)
    {
        // Collection de toutes les dates du rdv périodique
        ArrayList<Calendar> dates = new ArrayList<Calendar>();
        
        // Calcul dans le cas journalier sauf samedi et dimanche
        if (periode.equals("journalier"))
            {
                Calendar calCour = (Calendar)getDateDebut().clone();
                while (! calCour.after(getDateFin()))
                    {
                        int j = calCour.get(Calendar.DAY_OF_WEEK);
                        if ( (j!=Calendar.SATURDAY) && (j!=Calendar.SUNDAY) )
                            {
                                dates.add((Calendar)calCour.clone());
                            }

// jour de la date + 1
                        calCour.set(Calendar.DAY_OF_MONTH,
                                    calCour.get(Calendar.DAY_OF_MONTH)+1);
                    }
            }
            
        // Calcul dans le cas hebdomadaire
        if (periode.equals("hebdomadaire"))
            {
                Calendar calCour = (Calendar)getDateDebut().clone();
                while (! calCour.after(getDateFin()))
                    {
                        dates.add((Calendar)calCour.clone());

// jour de la date + 7
                        calCour.set(Calendar.DAY_OF_MONTH,
                                    calCour.get(Calendar.DAY_OF_MONTH)+7);
                    }
            }
            
        // Calcul pour le cas mensuel
        if (periode.equals("mensuel"))
            {
                Calendar calCour = (Calendar)getDateDebut().clone();
                while (! calCour.after(getDateFin()))
                    {
                        dates.add((Calendar)calCour.clone());

// mois de la date + 1
                        calCour.set(Calendar.MONTH,
                                    calCour.get(Calendar.MONTH)+1);
                    }
            }
            
        // On recherche si jour n'est pas parmi les dates du rdv périodique
        boolean dedans = false;
        for(Calendar c : dates)
            if (c.equals(jour))
                dedans=true;

return(dedans);
    }
    
    // Cette méthode est utilisée par la méthode compareTo qui est dans la classe abstraite
    //  ElementAgenda.
    // Elle retourne un entier qui est utilisé comme valeur de comparaison pour trier
    //  les éléments de l'agenda
    //
    public long getOrdre()
    {
        // La valeur entière d'une date (nombre de millisecondes depuis le 1/1/1970
        return( getDateDebut().getTime().getTime() );
    }

// Cette méthode est appelée dans l'IHM pour modifier un RendezVous
    // Elle est également implémentée dans chacune des classes RendezVous et Tache
    //
    public void modifierIhm()
    {
        Formulaire form = new Formulaire("Modifier un rendez vous",this,false,400,300);
        form.addText("PERIODE","Periode",true,this.periode);
        form.addText("DATE_DEBUT_RDV","Date de debut",true,this.date);
        form.addText("DATE_FIN_RDV","Date de fin",true,this.dateFin);
        form.addText("HEURE_DEBUT_RDV","Heure de debut",true,this.heureDebut);
        form.addText("HEURE_FIN_RDV","Heure de fin",true,this.heureFin);
        form.addText("TEXTE","Texte",true,this.texte,-1,-1,-1,-1,250);
        form.addButton("MODIFIER","Modifier");

try{
            form.afficher();
        }catch(Exception ex){}
    }

// Méthode appelée par le formulaire quand on clique sur un bouton
    //
    public void  submit(Formulaire form,String nomSubmit)
    {
        if (nomSubmit.equals("MODIFIER"))
            {
                this.periode    = form.getValeurChamp("PERIODE");
                this.date       = form.getValeurChamp("DATE_DEBUT_RDV");
                this.dateFin    = form.getValeurChamp("DATE_FIN_RDV");
                this.heureDebut = form.getValeurChamp("HEURE_DEBUT_RDV");
                this.heureFin   = form.getValeurChamp("HEURE_FIN_RDV");
                this.texte      = form.getValeurChamp("TEXTE");
                form.fermer();
            }
    }

}

Tache.java

package fr.cnam.rdv;

import java.util.*;
import java.io.*;

import fr.cnam.ihm.*;

// Classe de définition d'une tache (qq chose à faire)
// Elle hérite de la classe abstraite ElementAgenda
// Elle implémente l'interface FormulaireInt pour pouvoir modifier 
//  une Tache avec une IHM
//
public class Tache extends ElementAgenda implements FormulaireInt
{
    private String dateButee;  // Date de butée de la tache
    // Cette date Peut être null
    private int priorite;      // Priorité de la tache
    // utilisé quand il n'existe pas de date de butée
    
    // Constructeur
    //
    public Tache(String texte,String dateButee, int priorite)
    {
        super(texte);
        this.dateButee = dateButee;
        this.priorite = priorite;
    }

// Retourne la date butée en Calendar de la tache
    //
    public Calendar getDateButee()
    {
        Calendar cal = Calendar.getInstance();
        cal.clear();
        try{
            String[] t = dateButee.split("/");
            cal.set(Integer.parseInt(t[2]),
                    Integer.parseInt(t[1])-1,  // Les mois commence en 0
                    Integer.parseInt(t[0]));
        }catch(Exception ex){} // si erreur de format la date est à 0
        return(cal);
    }

// Méthode static qui retourne une Tache à partir d'une ligne du fichier texte
    //  Si la ligne ne peut pas etre décodée alors retourne un exception
    //
    public static Tache decoderLigne(String ligne) throws Exception
    {
        StringTokenizer strtok = new StringTokenizer(ligne," ");
        String premier = strtok.nextToken();  // Premier mot de la ligne

// Le premier mot de la ligne est soit un entier soit une date
        boolean siEntier=true;

int priorite=0;    // Par defaut
        String dateButee;
        try{
            priorite = Integer.parseInt(premier); 
            // C'est un entier
        }catch(Exception ex){siEntier=false;}  // Ce n'est pas un entier
        
        if (siEntier)
            dateButee=null;
        else
            dateButee = premier;

// Decodage du reste de la ligne qui est le texte
        String texte="";
        while (strtok.hasMoreTokens())
            texte=texte+" "+strtok.nextToken();
        
        // Création de la Tache
        return( new Tache(texte,
                          dateButee,
                          priorite) );
    }
    
    // Tache en chaine
    //
    public String toString()
    {
        String str="";
        if (dateButee!=null)
            str = str + String.format("%-15s : %-30s\n","Date butee",dateButee);
        else
            str = str + String.format("%-15s : %-30s\n","Priorite",priorite);
        str = str + String.format("%-15s : %-30s\n","Texte",texte);

return(str);
    }

// Cette méthode détermine si la Tache est dans le jour donné
    // Si une tache n'a pas de date de butée alors elle est toujours pour le jour donné
    // Sinon elle est dans le jour donné si la tache doit être faite dans les 5 jours
    //
    public boolean siDansLaPeriode(Calendar jour)
    {
        if (dateButee==null) return true;
        else
            {
                Calendar calDateButee = Calendar.getInstance();
                calDateButee.clear();
                calDateButee.set(jour.get(Calendar.YEAR),
                                 jour.get(Calendar.DAY_OF_MONTH)-5,
                                 jour.get(Calendar.MONTH));

if (jour.after(calDateButee))
                    return true;
                else
                    return false;
            }
    }

// Cette méthode est utilisée par la méthode compareTo qui est dans la classe abstraite
    //  ElementAgenda.
    // Elle retourne un entier qui est utilisé comme valeur de comparaison pour trier
    //  les éléments de l'agenda
    //
    // Pour une tache cette valeur est soit la valeur de priorité si il n'y a pas de
    //  date de butée sinon la valeur entière de la date de butée
    //
    public long getOrdre()
    {
        if (dateButee==null)
            return(priorite);
        else
            return( getDateButee().getTime().getTime() );
    }

// Cette méthode est appelée dans l'IHM pour modifier une Tache
    // Elle est également implémentée dans chacune des classes RendezVousPeriodique et Tache
    //
    public void modifierIhm()
    {
        Formulaire form = new Formulaire("Modifier une tache",this,false,400,300);
        form.addText("DATE_BUTEE","Date butee",true,this.dateButee);
        form.addText("PRIORITE","Priorite",true,this.priorite+"");
        form.addText("TEXTE","Texte",true,this.texte,-1,-1,-1,-1,250);
        form.addButton("MODIFIER","Modifier");

try{
            form.afficher();
        }catch(Exception ex){}
    }

// Méthode appelée par le formulaire quand on clique sur un bouton
    //
    // Si la date de butée n'est pas saisi (vide) alors elle est non renseignée
    // Si la priorité n'est pas saisie alors la valeur est par défaut 0
    //
    public void  submit(Formulaire form,String nomSubmit)
    {
        if (nomSubmit.equals("MODIFIER"))
            {
                this.dateButee = form.getValeurChamp("DATE_BUTEE");
                if (this.dateButee.equals(""))
                    this.dateButee=null;
                String sprio = form.getValeurChamp("PRIORITE");
                if (sprio.equals(""))
                    this.priorite=0;
                else
                    this.priorite = Integer.parseInt(sprio);
                this.texte = form.getValeurChamp("TEXTE");
                form.fermer();
            }
    }
    
    public void ecrire(DataOutputStream dos) throws Exception
    {
        dos.writeUTF("TACHE");
        if (dateButee==null)
            dos.writeUTF("");
        else
            dos.writeUTF(this.dateButee);
        dos.writeInt(this.priorite);
        dos.writeUTF(this.texte);
    }

public void lire(DataInputStream dis) throws Exception
    {
        this.dateButee = dis.readUTF();
        if (this.dateButee.equals(""))this.dateButee=null;
        this.priorite  = dis.readInt();
        this.texte     = dis.readUTF();
    }

}

util
Terminal.java

package fr.cnam.util;

import java.io.*;
import java.util.*;

/** La classe terminal permet de réaliser ses premiers programmes Java en permettant d'afficher dans la console d'exécution des données de type différents, et en permettant de saisir au clavier des données de type différents.<BR>
    Elle permet aussi de lire et écrire un fichier texte
    Cette classe contient que des méthodes statiques. */
public class Terminal{

// Le buffer standard  de lecture = le clavier
    private static BufferedReader in =
        new BufferedReader(new InputStreamReader(System.in));

/** Cette méthode lit un fichier texte et retourne le contenu du fichier sous la forme d'un  tableau de String dont chaque element est une ligne du fichier.
        @param nomFichier le nom du fichier qui doit être dans le répertoire courant.
        @return String[] le contenu du fichier. 
        @exception TerminalException (de type RuntimeException) si erreur d'écriture<BR>
        Rappel : Une exception de type RuntimeException n'a pas l'obligation d'être capturée.
*/
    public static String[] lireFichierTexte(String nomFichier)
    {
        try{
            File fichier = new File(nomFichier);
            FileInputStream fis = new FileInputStream(new File(nomFichier));
            
            byte[] buffer = new byte[(int)fichier.length()];
            fis.read(buffer);
            fis.close();
            String str = new String(buffer);

// On enleve le caractère '\r' code 13 qui est ajouté en Windows
            // Les fins de ligne dans un fichier texte créé sous Windows
            //  se termine par \r\n.
            // Il faut enlever le \r car il a des effets perturbant sur
            //  la méthode System.out.print et est pris comme un caractère de plus
            //  qu'il faut éliminer
            //  
            String texte = str.replaceAll(""+(char)(13),"");
            
            // Les lignes du fichier sont mises dans un tableau
            //
            String[] mots = texte.split("\n");

return(mots);
        }
        catch(Exception ex)
            {
                exceptionHandler(ex);
            }
        return null;
    }

/** Cette méthode permet de créer un fichier texte à partir du contenu d'un StringBuffer.
        @param nomFichier Le nom du fichier qui est créé dans le répertoire courant
        @param strbuf Le StringBuffer contenant le texte à écrire. 
        @exception TerminalException (de type RuntimeException) si erreur d'écriture
    */
    public static void ecrireFichier(String nomFichier,
                                     StringBuffer strbuf)
    {
        try{
            File fichier = new File(nomFichier);
            FileOutputStream fos = new FileOutputStream(new File(nomFichier));
            
            byte[] buffer = strbuf.toString().getBytes();
            fos.write(buffer);
            fos.close();
        }
        catch(Exception ex)
            {
                exceptionHandler(ex);
            }
    }

/** Cette méthode lit une chaîne de caractère
        @return String la chaîne saisie dans la console d'exécution
       @exception TerminalException (de type RuntimeException) si erreur de lecture
    */
    public static String lireString() // Lire un String
    {
        String tmp="";
        char C='\0';
        try {
            tmp = in.readLine();
        }
        catch (IOException e)
            {
                exceptionHandler(e);
            }
        return tmp;
    }

/** Cette méthode lit un entier
        @return int L'entier saisi dans la console d'exécution
       @exception TerminalException (de type RuntimeException) si la saisie n'est pas un entier ou erreur de lecture
    */
    public static int lireInt()  // Lire un entier
    {
        int x=0;
        try {
            x=Integer.parseInt(lireString());
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }

/** Cette méthode lit un boolean (false ou true)
        @return boolean Le boolean saisi dans la console d'exécution
       @exception TerminalException (de type RuntimeException) si erreur de lecture. <BR>
       Tout autre valeur que TRUE, FALSE, true ou false, retourne la valeur false
    */
    public static boolean lireBoolean()  // Lire un entier
    {
        boolean b = true;
        try {
            b = Boolean.valueOf(lireString()).booleanValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return b;
    }

/** Cette méthode lit un double
        @return double Le double saisi dans la console d'exécution
       @exception TerminalException (de type RuntimeException) si la valeur saisie n'est pas un double ou ereur de lecture.
    */
    public  static double lireDouble()  // Lire un double
    {
        double x=0.0;
        try {
            x=Double.valueOf(lireString()).doubleValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }

/** Cette méthode lit un caractère.
       @exception TerminalException (de type RuntimeException) si erreur de lecture.<BR>
       Si on saisit plus d'1 caractère alors le caractère retourné est le premier.
    */
    public  static char lireChar()  // Lire un caractere
    {
        String tmp=lireString();
        if (tmp.length()==0)
            return '\n';
        else 
            {
                return tmp.charAt(0);
            }
    }

/** Cette méthode ecrit une chaine et ne revient pas à la ligne.
    */
    public static void ecrireString(String s){ // Afficher un String
        System.out.print(s);
    }

/** Cette méthode écrit une chaine et revient à la ligne.
    */
    public static void ecrireStringln(String s) // Afficher un String
    {
        ecrireString(s);
        sautDeLigne();
    }

/** Cette méthode ecrit un entier et ne revient pas à la ligne.
    */
    public static void ecrireInt(int i)  // Afficher un entier
    {
        ecrireString(""+i);
    }

/** Cette méthode écrit un entier et revient à la ligne.
    */
    public static void ecrireIntln(int i)  // Afficher un entier
    {
        ecrireString(""+i);
        sautDeLigne();
    }

/** Cette méthode écrit un booléan et ne revient pas à la ligne.
    */
    public static void ecrireBoolean(boolean b){
        ecrireString(""+b);
    }

/** Cette méthode écrit un booléan et revient à la line.
    */
    public static void ecrireBooleanln(boolean b){
        ecrireString(""+b);
        sautDeLigne();
    }

/** Cette méthode écrit un double et ne revient pas à la ligne.
    */
    public  static void ecrireDouble(double d)  // Afficher un double
    {
        ecrireString(""+d);
    }

/** Cette méthode écrit un double et revient à la ligne.
    */
    public  static void ecrireDoubleln(double d)  // Afficher un double
    {
        ecrireDouble(d);
        sautDeLigne();
    }

/** Cette méthode écrit un caractère et ne revient pas à la ligne.
    */
    public  static void ecrireChar(char c)  // Afficher un caractere
    {
        ecrireString(""+c);
    }

/** Cette méthode écrit un caractère et revient à la ligne.
    */
    public  static void ecrireCharln(char c)  // Afficher un caractere
    {
        ecrireChar(c);
        sautDeLigne();
    }

/** Cette méthode revient à la ligne.
    */
    public static void sautDeLigne(){
        try{
            System.out.println();
        }catch(Exception ex){
            exceptionHandler(ex);
        }
    }

/** Cette méthode retourne l'exception TerminalException
    */
    protected static void exceptionHandler(Exception ex){
        TerminalException err = new TerminalException(ex);
        throw err;
    }

/** Cette méthode écrit l'exception
    */
    public static void ecrireException(Throwable ex){
        ecrireString(ex.toString());
        ex.printStackTrace(System.err);
    }
}

/** Classe de définition de l'exception TerminalException qui peut être retournée dans l'usage des méthodes de la classe Terminal. */
class TerminalException extends RuntimeException{
    Exception ex;
    TerminalException(Exception e){
        ex = e;
    }
}

run.bat
toto

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE