Cours CNAM par J. Laforgue

Outil00b_TerminalAvecPackage

Retour

Télécharger

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.

Elle permet aussi de lire et écrire un fichier texte.

Cette classe contient que des méthodes statiques.

Cette classe est dans le package fr.cnam.util.

TestTerminal.java

import fr.cnam.util.*;

/** Programme de test de la classe Terminal.
 */
public class TestTerminal
{
    /**
       Exécution de quelques cas d'utilisation des méthodes de la classe Terminal
       @param args (non utilisé)
    */
    public static void main(String... args)
    {
        Parametres params = new Parametres(args);

int toto = params.getInt("toto");
        String tata = params.getString("tata");
        double titi = params.getDouble("titi");

int    def1 = params.getInt("def1",100);
        String def2 = params.getString("def2","blabla");
        double def3 = params.getDouble("def3",1.0);

Terminal.ecrireStringln("---- Parametres");
        Terminal.ecrireStringln("" + toto+"\n"+tata+"\n"+titi);
        Terminal.ecrireStringln("" + def1+"\n"+def2+"\n"+def3);

String[] tabStr = Terminal.lireFichierTexte("../TestTerminal.java");
        for(int i=0;i<tabStr.length;i++)
            Terminal.ecrireStringln(String.format("%3d : %s",i,tabStr[i]));

Terminal.ecrireString("taper une touche puis entree pour continuer...");
        Terminal.lireString();

tabStr = Terminal.lireFichierTexte("FICHIER INCONNU"); 
        if (tabStr==null) System.out.println("Fichier inconnu");
        
        Terminal.ecrireString("taper une touche puis entree pour continuer...");
        Terminal.lireString();

try{
            Terminal.ecrireString("Saisir un entier : ");
            int i = Terminal.lireInt();
            Terminal.ecrireIntln(i);
        }catch(TerminalException ex){Terminal.ecrireException(ex);}

try{
            Terminal.ecrireString("Saisir un double : ");
            double d = Terminal.lireDouble();
            Terminal.ecrireDoubleln(d);
        }catch(TerminalException ex){Terminal.ecrireException(ex);}

try{
            Terminal.ecrireString("Saisir un booleen : ");
            boolean b = Terminal.lireBoolean();
            Terminal.ecrireBooleanln(b);
        }catch(TerminalException ex){Terminal.ecrireException(ex);}

try{
            Terminal.ecrireString("Saisir un char : ");
            char c = Terminal.lireChar();
            Terminal.ecrireCharln(c);
        }catch(TerminalException ex){Terminal.ecrireException(ex);}

}
}

      compil.bat
      doc.bat
      fr
         cnam
            util
               Parametres.java

package fr.cnam.util;

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

/**
   Classe de decodage des parametres en entree d'un programme java. 
   Les parametres doivent tous etre de la forme : param=value  
   Importe peu l'ordre des parametres
 */
public class Parametres
{
    private Hashtable<String,String> params;

/**
       Creer le decodage des parametres
       @param args tableau de string ou String...
       @exception ParametresSyntaxErrorException erreur de syntaxe (un des parametre n'est pas de la forme param=value)
     */
    public Parametres(String... args) throws ParametresSyntaxErrorException
    {
        params = new Hashtable<String,String>();

for(String param:args)
            {
                String[] targ = param.split("=");
                if (targ.length!=2)
                    throw new ParametresSyntaxErrorException(param);

params.put(targ[0],targ[1]);
            }
    }
    
    /**
       Retourne un parametre de valeur chaine
       @param param nom du parametre
       @return String la valeur du parametre
       @exception ParametresNotFoundException erreur si param n'est pas trouve
     */
    public String getString(String param) throws ParametresNotFoundException
    {
        String value = params.get(param);
        if (value==null) throw new ParametresNotFoundException(param);
        return value;
    }
    
    /**
       Retourne un parametre de valeur chaine
       @param param nom du parametre
       @param defaut valeur par defaut si le parametre n'existe pas
       @return String la valeur du parametre
     */
    public String getString(String param,String defaut)
    {
        String value = params.get(param);
        if (value==null) return defaut;
        return value;
    }
    
    /**
       Retourne un parametre de valeur int
       @param param nom du parametre
       @return int la valeur du parametre 
       @exception ParametresNotFoundException erreur si param n'est pas trouve
     */
    public int getInt(String param) throws ParametresNotFoundException
    {
        String value = params.get(param);
        if (value==null) throw new ParametresNotFoundException(param);
        return Integer.parseInt(value);
    }
    
    /**
       Retourne un parametre de valeur int
       @param param nom du parametre
       @param defaut valeur par defaut si le parametre n'existe pas
       @return int la valeur du parametre 
     */
    public int getInt(String param,int defaut)
    {
        String value = params.get(param);
        if (value==null) return defaut;
        return Integer.parseInt(value);
    }
    
    /**
       Retourne un parametre de valeur double
       @param param nom du parametre
       @return double la valeur du parametre 
       @exception ParametresNotFoundException erreur si param n'est pas trouve
     */
    public double getDouble(String param,String... defaut) throws ParametresNotFoundException
    {
        String value = params.get(param);
        if (value==null) throw new ParametresNotFoundException(param);
        return Double.parseDouble(value);
    }

/**
       Retourne un parametre de valeur double
       @param param nom du parametre
       @param defaut valeur par defaut si le parametre n'existe pas
       @return double la valeur du parametre 
     */
    public double getDouble(String param,double defaut)
    {
        String value = params.get(param);
        if (value==null) return defaut;
        return Double.parseDouble(value);
    }
}

               ParametresNotFoundException.java
               ParametresSyntaxErrorException.java
               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. 
    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 
        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);
            if (! fichier.exists())
                {
                    System.out.println("Le fichier "+nomFichier+" n'existe pas ou n'est pas accessible");
                    return null;
                }
            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.  
       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. 
       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 écrit une chaine et ne revient pas à la ligne.
        @param s la chaine à écrire
    */
    public static void ecrireString(String s){ // Afficher un String
        System.out.print(s);
    }

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

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

/** Cette méthode écrit un entier et revient à la ligne.
        @param i l'entier à écrire
    */
    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.
        @param b le booléen à écrire
    */
    public static void ecrireBoolean(boolean b){
        ecrireString(""+b);
    }

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

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

/** Cette méthode écrit un double et revient à la ligne.
        @param d le double à écrire
    */
    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.
        @param c le caractère à écrire
    */
    public  static void ecrireChar(char c)  // Afficher un caractere
    {
        ecrireString(""+c);
    }

/** Cette méthode écrit un caractère et revient à la ligne.
        @param c le caractère à écrire
    */
    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 une exception avec la pile dans la console
        @param ex l'exception à écrire
    */
    public static void ecrireException(Throwable ex){
        ecrireString(ex.toString());
        ex.printStackTrace(System.out);
    }
}

TerminalException.java
run.bat

Ces outils sont des packages de code facilitant la réalisation des exmeples, exercices et projets. Ils sont utilisés dans les cours de NFA 031, NFA032 et NSY102 Chaque outil est téléchargeable(zip) et consultable en ligne .

Outil00b_TerminalAvecPackage

Retour

Télécharger

TestTerminal.java

import fr.cnam.util.*;

int toto = params.getInt("toto");
        String tata = params.getString("tata");
        double titi = params.getDouble("titi");

int    def1 = params.getInt("def1",100);
        String def2 = params.getString("def2","blabla");
        double def3 = params.getDouble("def3",1.0);

Terminal.ecrireStringln("---- Parametres");
        Terminal.ecrireStringln("" + toto+"\n"+tata+"\n"+titi);
        Terminal.ecrireStringln("" + def1+"\n"+def2+"\n"+def3);

Terminal.ecrireString("taper une touche puis entree pour continuer...");
        Terminal.lireString();

}
}

      compil.bat
      doc.bat
      fr
         cnam
            util
               Parametres.java

package fr.cnam.util;

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

               ParametresNotFoundException.java
               ParametresSyntaxErrorException.java
               Terminal.java

package fr.cnam.util;

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

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

TerminalException.java
run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE