MàJ par récupération sur Clé USB et dans /mnt/hd/Chargement du pc portable

G5a/Materiel/iutsud/Console.java

@@ -0,0 +1,649 @@
+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<74>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<EFBFBD>ral est de lire ligne par ligne et de ne traiter
+ *  qu'une seule donn<6E>e par ligne.
+ *  <li>En cas d'erreur le programme est arr<72>t<EFBFBD> en levant une exception  ;
+ *	il affiche alors un message d'erreur ainsi que le contenu de la pile d'ex<65>cution.
+ *	<li>L'introduction d'une ligne vide provoque une erreur sauf pour <code>readChar()</code>
+ *	qui renvoie le caract<63>re de fin de ligne <code>'\n'</code>, et sauf pour <code>readLine()</code>
+ *	qui renvoie la cha<68>ne vide.
+ *	<li>La rencontre de la fin de fichier (Ctrl-D au clavier) est g<>n<EFBFBD>ralement
+ *	consid<69>r<EFBFBD>e comme une erreur sauf pour <code>readLine()</code> qui renvoie <code>null</code>.
+ *  <p>
+ *	Le point de d<>part a <20>t<EFBFBD> la classe <code>sdsu.io.Console</code> de l'universit<69>
+ *	de San Diego (<a href="http://www.eli.sdsu.edu/java-SDSU">http://www.eli.sdsu.edu/java-SDSU</a>).
+ *	Cette classe a <20>t<EFBFBD> simplifi<66>e pour r<>pondre <20> nos besoins particuliers pour 
+ *	l'enseignement de l'introduction <20> l'algorithmique.
+ *	Le code a <20>t<EFBFBD> enti<74>rement remani<6E> pour utiliser les fonctions de 
+ *	conversion du langage Java.
+ *	Des am<61>liorations pourraient certainement y <20>tre apport<72>es en utilisant
+ *	la classe <code>Number</code> notamment pour les probl<62>mes d'internationalisation,
+ *	li<6C>s <20> l'<27>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<69>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<70>sentation peut <20>tre g<>n<EFBFBD>r<EFBFBD> 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<65>e lors d'une erreur de lecture
+	 */
+ 
+	public static class ReadException extends RuntimeException	
+	{
+		public ReadException(String message)
+		{
+			super(message) ;
+		}
+	}	// end class ReadException
+	
+	/**
+	 *	Exception lev<65>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<73>me affichera<72> le message d'erreur associ<63>
+	 *	ainsi que la pile d'ecx<63>cution
+	 *	@param	e	l'exception <20> 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 <20> une erreur de conversion ;
+	 * 	affiche un message d'erreur en levant l'exception
+	 *	<code>Console.ConvertionException</code> 
+	 *	@param	s			la cha<68>ne <20> 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 <20> une erreur de lecture ;
+	 * 	affiche un message d'erreur en levant l'exception
+	 *	<code>Console.ReadException</code> 
+	 *	@param	s			la raison de l'erreur <20> 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 <20> afficher suite <20> une erreur de conversion ;
+	 *	@param	s			la cha<68>ne <20> 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 <20>tre convertie en " + t ;
+		}
+		
+    // Input methods ----------------------------------------------------
+
+    /**
+     * Lit une valeur bool<6F>enne dans une ligne.
+     * Lit une ligne et d<>termine si elle repr<70>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 <20> la casse (majuscule, minuscule).
+	 *
+     * Le programme stoppe en cas d'erreur de lecture ou en fin de fichier
+     * @return la valeur bool<6F>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<63>re dans une ligne.
+	 * La ligne lue doit contenir au maximum un caract<63>re. 
+	 * Si la ligne est vide le caract<63>re <code>'\n'</code> est renvoy<6F>. 
+     * 
+     * Le programme stoppe en cas d'erreur de lecture ou en fin de fichier 
+	 * ou encore si la ligne contenait plusieurs caract<63>res.
+     * @return le caract<63>re lu ou <code>'\n'</code> si la ligne <20>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<63>re : " 
+							+ '"' + s + '"' + '\n' )
+					);	
+	
+	return c ;
+	
+}
+
+    /**
+     * Lit un nombre en virgule flottante et en double pr<70>cision dans une ligne. 
+	 * Ces nombres doivent <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>double</code> en Java et permettre la conversion par :
+     * 		<code>Double(String).doubleValue()</code>
+	 * Le nombre peut <20>tre pr<70>c<EFBFBD>d<EFBFBD> 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<70>cision dans une ligne. 
+	 * Ces nombres doivent <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>float</code> en Java et permettre la conversion par :
+	 * 		<code>Float(String).floatValue()</code>
+	 * Le nombre peut <20>tre pr<70>c<EFBFBD>d<EFBFBD> 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 <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>int</code> en Java et permettre la conversion par :
+	 * 		<code>Integer.parseInt(String)</code>.
+	 * Le nombre peut <20>tre pr<70>c<EFBFBD>d<EFBFBD> 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 <20>crit en base <code>b</code> dans une ligne. 
+	 * Ces nombres doivent <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>long</code> en Java et permettre la conversion par :
+     * 		<code>Long.parseLong(String,b)</code>
+	 * Le nombre peut <20>tre pr<70>c<EFBFBD>d<EFBFBD> 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<69>  
+     * @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 <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>long</code> en Java et permettre la conversion par :
+     * 		<code>Long.parseLong(String)</code>
+	 * Le nombre peut <20>tre pr<70>c<EFBFBD>d<EFBFBD> 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 <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>short</code> en Java et permettre la conversion par :
+     * 		<code>Short.parseShort(String)</code>
+	 * Le nombre peut tre pre<72>c<EFBFBD>d<EFBFBD> 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 <20>tre conforme <20> l'<27>criture standard des constantes 
+	 * <code>byte</code> en Java et permettre la conversion par :
+     * 		<code>Byte.parseByte(String)</code>
+	 * Le nombre peut <20>tre pr<70>c<EFBFBD>d<EFBFBD> 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<68>ne indiquant le contenu de la ligne ou
+     * une cha<68>ne vide lorsque la ligne <20>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<74>e.
+     * @param	t	cha<68>ne indiquant le type de la donn<6E>e lue dans cette ligne
+     * @return une cha<68>ne indiquant le contenu de la ligne ou
+     * une cha<68>ne vide lorsque la ligne <20>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<6E>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 <20>tait vide.
+     * @param	t	cha<68>ne indiquant le type de la donn<6E>e lue dans cette ligne
+     * @return une cha<68>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