olivier
/
cours0708
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cours0708/G5a/Materiel/iutsud/Console.java

650 lines
18 KiB
Java
Raw Permalink Blame History

package iutsud ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
/**
* Cette classe fournit des méthodes simples pour lire les types
* de base sur l'entrée standard (au clavier).<p>
* La lecture est faite par des instructions du type :
* <pre><code> int i = Console.<b>readInt()</b> ;
* double d = Console.<b>readDouble()</b> ;
* char c = Console.<b>readChar()</b> ;
* ...</code> </pre>
*
* <li>Le principe général est de lire ligne par ligne et de ne traiter
* qu'une seule donnée par ligne.
* <li>En cas d'erreur le programme est arrêté en levant une exception ;
* il affiche alors un message d'erreur ainsi que le contenu de la pile d'exécution.
* <li>L'introduction d'une ligne vide provoque une erreur sauf pour <code>readChar()</code>
* qui renvoie le caractère de fin de ligne <code>'\n'</code>, et sauf pour <code>readLine()</code>
* qui renvoie la chaîne vide.
* <li>La rencontre de la fin de fichier (Ctrl-D au clavier) est généralement
* considérée comme une erreur sauf pour <code>readLine()</code> qui renvoie <code>null</code>.
* <p>
* Le point de départ a été la classe <code>sdsu.io.Console</code> de l'université
* de San Diego (<a href="http://www.eli.sdsu.edu/java-SDSU">http://www.eli.sdsu.edu/java-SDSU</a>).
* Cette classe a été simplifiée pour répondre à nos besoins particuliers pour
* l'enseignement de l'introduction à l'algorithmique.
* Le code a été entièrement remanié pour utiliser les fonctions de
* conversion du langage Java.
* Des améliorations pourraient certainement y être apportées en utilisant
* la classe <code>Number</code> notamment pour les problèmes d'internationalisation,
* liés à l'écriture des nombres en <b>virgule</b> flottante.
* <p>
*
* <b>Utilisation</b> : <p>
* <li>Le fichier <code>Console.class</code> se trouve sous le répertoire
* <code>/usr/local/lib/java/iutsud</code>.
* <li>La variable <code>CLASSPATH</code> doit contenir
* <code>/usr/local/lib/java</code>. Sur <i>sterne</i> elle est initialisée
* automatiquement au démarrage de la session avec cette valeur.
* <li>Les classes utilisatrices doivent importer la classe
* <code>Console</code> depuis le package <code>iutsud</code> par l'instruction
* <code>import iutsud.Console</code>
*
*
* <p>Le document de présentation peut être généré depuis le source par la commande : <br>
* <code> javadoc -version -author iutsud</code>
* @author Raymond Schneider
* (<a href=mailto:Raymond.Schneider@iutsud.u-strasbg.fr>Raymond.Schneider@iutsud.u-strasbg.fr</a>)
* @version version 0.1 17/07/98
*/
public class Console {
private static BufferedReader cin = new BufferedReader(
new InputStreamReader(
System.in )) ;
private static void main(String args[]) {
while (true) {
System.out.print( "Print a Base ");
int base = Console.readInt() ;
System.out.print( "Print a Long in base " + base + " : ") ;
long lb = Console.readLong(base) ;
System.out.println( "You typed: " + lb );
System.out.print( "Print a Byte ");
byte k = Console.readByte() ;
System.out.println( "You typed: " + k );
System.out.print( "Print a Short ");
int j = Console.readShort() ;
System.out.println( "You typed: " + j );
System.out.print( "Print a Int ");
int i = Console.readInt() ;
System.out.println( "You typed: " + i );
System.out.print( "Print a Long ");
long l = Console.readLong() ;
System.out.println( "You typed: " + l );
System.out.print( "Print a Float ");
float f = Console.readFloat() ;
System.out.println( "You typed: " + f );
System.out.print( "Print a Double ");
double d = Console.readDouble() ;
System.out.println( "You typed: " + d );
System.out.print( "Print a Boolean ");
boolean b = Console.readBoolean() ;
System.out.println( "You typed: " + b );
System.out.print( "Print a Char ");
char c = Console.readChar() ;
System.out.println( "You typed: " + c );
}
}
private Console()
{
super() ;
}
/**
* Exception levée lors d'une erreur de lecture
*/
public static class ReadException extends RuntimeException
{
public ReadException(String message)
{
super(message) ;
}
} // end class ReadException
/**
* Exception levée lors d'une erreur de conversion
*/
public static class ConvertionException extends RuntimeException
{
public ConvertionException(String message)
{
super(message) ;
}
} // end class ConvertionException
/**
* Quitte le programme en levant l'exception e
* Le système afficheraé le message d'erreur associé
* ainsi que la pile d'ecxécution
* @param e l'exception à lever
*/
/*
* Exits programs after throwing an exception
* @param e exception to be thrown
*/
static final void exitProgram( RuntimeException e )
{
throw e ;
}
/**
* Quitte le programme suite à une erreur de conversion ;
* affiche un message d'erreur en levant l'exception
* <code>Console.ConvertionException</code>
* @param s la chaîne à convertir
* @param t le type vers lequel il fallait convertir
*/
/*
* Exits programs after displaying a conversion error message
* and after dumping the Thread's stack
* @param s String that could not be converted
* @param t Conversion Destination Type
*/
private static final void conversionError( String s , String t )
{
exitProgram( new ConvertionException(
conversionErrorMessage( s , t ) ) ) ;
}
/**
* Quitte le programme suite à une erreur de lecture ;
* affiche un message d'erreur en levant l'exception
* <code>Console.ReadException</code>
* @param s la raison de l'erreur à afficher
* @param t le type lu
*/
/*
* Exits programs after displaying a conversion error message
* and after dumping the Thread's stack
* @param s the error cause
* @param t Read Destination Type
*/
private static final void readError( String s , String t )
{
exitProgram( new ReadException ( s + " lors de la lecture d'un " + t) );
}
/**
* Compose le message d'erreur à afficher suite à une erreur de conversion ;
* @param s la chaîne à convertir
* @param t le type vers lequel il fallait convertir
*/
/*
* Bulids a conversion error message
* @param s String that could not be converted
* @param t Conversion Destination Type
*/
private static String conversionErrorMessage( String s, String t )
{
return '"' + s + '"' + " ne peut être convertie en " + t ;
}
// Input methods ----------------------------------------------------
/**
* Lit une valeur booléenne dans une ligne.
* Lit une ligne et détermine si elle représente <code>true</code> ou <code>false</code>.
* Les valeurs possibles sont : <i>true</i> and <i>false</i>,
* <i>vrai</i> and <i>faux</i>.
* La comparaison est insensible à la casse (majuscule, minuscule).
*
* Le programme stoppe en cas d'erreur de lecture ou en fin de fichier
* @return la valeur booléene correspondante.
*/
/*
* Reads an ASCII boolean value.
* It reads a word and determines if it represents <code>true</code> or
* <code>false</code>. Possible values are: <i>true</i> and <i>false</i>,
* <i>vrai</i> and <i>faux</i>.
* The comparison is case insensitive.
* Program exits on read errors or EOF
* @return the boolean.
*/
public static boolean readBoolean()
{
boolean b = false ;
String s ;
s= readLine("boolean") ;
if (s.equalsIgnoreCase(String.valueOf(false))
|| s.equalsIgnoreCase("faux") )
b= false;
else if (s.equalsIgnoreCase(String.valueOf(true))
|| s.equalsIgnoreCase("vrai") )
b= true;
else
conversionError( s , "boolean" ) ;
return b;
} // end readBoolean
/**
* Lit un caractère dans une ligne.
* La ligne lue doit contenir au maximum un caractère.
* Si la ligne est vide le caractère <code>'\n'</code> est renvoyé.
*
* Le programme stoppe en cas d'erreur de lecture ou en fin de fichier
* ou encore si la ligne contenait plusieurs caractères.
* @return le caractère lu ou <code>'\n'</code> si la ligne était vide.
*/
/*
* Reads one ASCII character and convert it into the internal <code>char</code>
* format. If the line is empty <code>'\n'</code> is returned.
* If more than one character are available in the line, only the first one is returned ; all other are
* ignored.
* Program exits on read errors or EOF or if more characters are available
* @return the character or <code>'\n'</code> if line was empty.
*/
public static char readChar()
{
String s ;
char c = '\n' ;
s= readNewLine("char");
if (s.length() == 1)
c= s.charAt(0);
else if ( s.length() != 0 )
exitProgram( new ReadException(
"La ligne lue contenait plus d'un caractère : "
+ '"' + s + '"' + '\n' )
);
return c ;
}
/**
* Lit un nombre en virgule flottante et en double précision dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>double</code> en Java et permettre la conversion par :
* <code>Double(String).doubleValue()</code>
* Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @return la valeur <code>double</code> correspondante.
*/
/*
* Reads an ASCII decimal floating point number.
* A floating point number should obey Java String conversion :
* <code>Double(String).doubleValue()</code>
* Program exits on read errors or EOF
* @return the double.
*/
public static double readDouble()
{
String s ;
double d = 0.0 ;
s= readLine("double");
try
{
d = new Double(s).doubleValue() ;
}
catch (NumberFormatException e)
{
conversionError( s, "double");
}
return d ;
}
/**
* Lit un nombre en virgule flottante et en simple précision dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>float</code> en Java et permettre la conversion par :
* <code>Float(String).floatValue()</code>
* Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @return la valeur <code>float</code> correspondante.
*/
/*
* Reads an ASCII decimal floating point number.
* A floating point number should obey Java String conversion :
* <code>Float(String).floatValue()</code>
* Program exits on read errors or EOF
* @return the double.
*/
public static float readFloat()
{
String s ;
float f = 0.0F ;
s= readLine("float");
try
{
f = new Float(s).floatValue() ;
}
catch (NumberFormatException e)
{
conversionError( s, "float" );
}
return f ;
}
/**
* Lit un nombre entier dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>int</code> en Java et permettre la conversion par :
* <code>Integer.parseInt(String)</code>.
* Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @return la valeur <code>int</code> correspondante.
*/
/*
* Reads an ASCII decimal integer conforming to <code>Integer.parseInt(String)</code>.
* Integers can be preceded by optional whitespace (SPACE or TAB).
* Program exits on read errors or EOF
* @return the integer.
*/
public static int readInt()
{
int i = 0 ;
String s ;
s= readLine("int");
try
{
i = Integer.parseInt(s) ;
}
catch (NumberFormatException e)
{
conversionError( s, "int" );
}
return i ;
}
/**
* Lit un nombre entier long écrit en base <code>b</code> dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>long</code> en Java et permettre la conversion par :
* <code>Long.parseLong(String,b)</code>
* Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @param b la base dans laquelle l'entier lu est exprimé
* @return la valeur <code>long</code> correspondante.
*/
/*
* Reads an ASCII long expressed in base <code>b</code> and conforming
* to <code>Long.parseLong(String,b)</code>
* Longs can be preceded by optional whitespace (SPACE or TAB).
* Program exits on read errors or EOF
* @param b the numbering base used to make the conversion
* @return the long.
*/
public static long readLong(int b)
{
long l = 0L;
String s ;
String t = "long" ;
if ( b != 10)
t= t + " in base " + b ;
s= readLine(t);
try
{
l = Long.parseLong(s, b) ;
}
catch (NumberFormatException e)
{
conversionError( s, t) ;
}
return l ;
}
/**
* Lit un nombre entier long dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>long</code> en Java et permettre la conversion par :
* <code>Long.parseLong(String)</code>
* Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @return la valeur <code>long</code> correspondante.
*/
/*
* Reads an ASCII decimal long conforming to <code>Long.parseLong(String)</code>
* Longs can be preceded by optional whitespace (SPACE or TAB).
* Program exits on read errors or EOF
* @return the long.
*/
public static long readLong()
{
return readLong(10) ;
}
/**
* Lit un nombre entier court dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>short</code> en Java et permettre la conversion par :
* <code>Short.parseShort(String)</code>
* Le nombre peut tre preécédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @return la valeur <code>short</code> correspondante.
*/
/*
* Reads an ASCII decimal short.
* Shorts can be preceded by optional whitespace (SPACE or TAB).
* Program exits on read errors or EOF
* @return the short.
*/
public static short readShort()
{
short j = 0 ;
String s = readLine("short");
try
{
j = Short.parseShort(s) ;
}
catch (NumberFormatException e)
{
conversionError( s, "short" );
}
return j ;
}
/**
* Lit un octet dans une ligne.
* Ces nombres doivent être conforme à l'écriture standard des constantes
* <code>byte</code> en Java et permettre la conversion par :
* <code>Byte.parseByte(String)</code>
* Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
*
* Le programme stoppe en cas d'erreur ou en fin de fichier
* @return la valeur <code>byte</code> correspondante.
*/
/*
* Reads an ASCII decimal byte.
* Bytes can be preceded by optional whitespace (SPACE or TAB).
* Program exits on read errors or EOF
* @return the byte.
*/
public static byte readByte()
{
byte b = 0 ;
String s = readLine("byte");
try
{
b = Byte.parseByte(s) ;
}
catch (NumberFormatException e)
{
conversionError( s, "byte" );
}
return b ;
}
/**
* Lit une ligne.
*
* Le programme stoppe en cas d'erreur de lecture.
* @return une chaîne indiquant le contenu de la ligne ou
* une chaîne vide lorsque la ligne était vide ou
* <code>null</code> en fin de fichier .
*/
/*
* Reads a line.
* Program exits on read errors
* @return the line content or an empty string if nothing entered or <code>null</code> if EOF reached .
*/
public static String readLine()
{
String s = null ;
try
{
s= cin.readLine();
}
catch ( java.io.EOFException error)
{
s = null ;
}
catch ( Exception error )
{
exitProgram( new RuntimeException(error.toString()) ) ;
}
return s ;
}
/**
* Lit une nouvelle ligne.
*
* Le programme stoppe en cas d'erreur de lecture ou si la fin de fichier
* est rencontrée.
* @param t chaîne indiquant le type de la donnée lue dans cette ligne
* @return une chaîne indiquant le contenu de la ligne ou
* une chaîne vide lorsque la ligne était vide .
*/
/*
* Reads a new line.
* Program exits on read errors or if EOF is reached.
* @param t String indicating the type expected in the line
* @return the line content or an empty string if nothing entered .
*/
private static String readNewLine(String t)
{
String s ;
s= readLine() ;
if ( s == null)
readError ( " Fin de fichier inattendue" , t) ;
return s ;
}
/**
* Lit une donnée de type <code>t</code> dans une ligne non vide.
*
* Le programme stoppe en cas d'erreur de lecture, de fin de fichier
* ou si la ligne était vide.
* @param t chaîne indiquant le type de la donnée lue dans cette ligne
* @return une chaîne indiquant le contenu non vide de la ligne.
*/
/*
* Reads a data of type <code>t</code> in a non empty line.
* Program exits on read errors or EOF or if line is empty
* @param t String indicating the type expected in the line
* @return the non empty line content
*/
private static String readLine(String t)
{
String s ;
s= readNewLine(t).trim() ;
if (s.length() == 0)
readError ( " Ligne vide" , t) ;
return s ;
}
} // end class Console
Reference in New Issue View Git Blame Copy Permalink