Bonjour a tous, je commence à peine a programmer avec Java et j'aurais quelques question concernant un petit programme que je doit faire pour l'école. Le programme utilise une classe appelée "Clavier" pour la saisie des données au clavier.
Mon probleme majeur est que lorsque j'entre un code different de 's', 'a', 'f', 'd', ou 'q' voici ce que sa me donne:
---------------------------------------------------
Entrez le code de l'infraction :
z
Les codes d'infraction permis sont : s, a, f, d et q pour quitter
Entrez le code de l'infraction :
Les codes d'infraction permis sont : s, a, f, d et q pour quitter
la boucle est effectuée 2 fois et je ne comprend pas pourquoi.
Je crois que cela a un lien avec les méthodes "lireChar()" et "lireFinLigne()" de la classe "Clavier" fournis par le prof que je dois obligatoirement utilisée pour la saisie de données. Dans mon prog je n'utilise que la méthode "lireChar" mais je ne comprend ce quelle fait ni ce que la méthode "lireFinLigne" fait...donc si vous pourriez m'aider en regardant mon petit programme et la class "Clavier" je vous en serais extremement reconnaissante.
while ( vitesseConstatee - vitesseMax <= 0 ) { // validation vitesse
System.out.println ( "\n" + "La vitesse constatée doit être plus grande que la vitesse maximale permise" );
System.out.println ( "\n" + "Entrez la vitesse constatée : " );
vitesseConstatee = Clavier.lireInt();
} // while valiadtion vitesse
} else if ( codeInfraction == 'f') {
libelle = "Omission de se conformer à un feu rouge ou à un panneau d'arrêt";
nbrPoint = 3;
} else if ( codeInfraction == 'a') {
libelle = "Vitesse ou action imprudente";
nbrPoint = 4;
} else if ( codeInfraction == 'd') {
libelle = "Omission d’arrêter avant d’effectuer un virage à droite sur feu rouge";
nbrPoint = 3;
} //
/* antecedent : -
* consequent : Retourne le mot lu, a partir du curseur.
* Les separateurs (voir plus haut) de debut sont
* ignores. La fin du mot est determinee par un sepa-
* rateur. Le separateur qui suit le mot est lu.
* Le curseur est rendu sur le premier caractere suiv-
* ant le separateur ayant determine la fin du mot.
*/
String resultat = "";
char car; // caractere lu
// Sauter les separateurs
do {
car = lireChar();
} while ( Character.isWhitespace( car ) );
// car ne contient pas un separateur.
// Lire et stocker dans resultat jusqu'a un separateur
do {
resultat = resultat + car;
car = lireChar();
} while ( ! Character.isWhitespace( car ) );
// car contient un separateur.
// S'il s'agit de CR, il faut qu'il soit suivi de LF
if ( car == '\r' ) { // CR
car = lireChar();
if ( car != '\n' ) { // LF
System.out.println(
"Erreur fatale dans la methode lireMot de la classe Clavier.");
System.exit(1); // 1 : pour signifier un arret anormal
} // if non LF
} // if CR
return resultat;
} // lireMot
public static void viderTampon() {
/* antecedent : -
* consequent : Vide le tampon d'entree associe a la console.
*/
try {
System.in.skip( System.in.available() );
} catch( IOException e ) {
System.out.println ( "Le tampon d'entree ne peut etre vide." );
}
} // viderTampon
public static void lireFinLigne() {
/* antecedent :
* consequent : Lit les caracteres, a partir du curseur.
* La fin de la ligne est determinee par :
* LF (line feed) ou par CR (carriage return)
* suivi de LF.
* LF et CR seront lus.
*/
char prochain_caractere;
boolean fini = false;
while ( ! fini ) {
prochain_caractere = lireChar(); // Lire un caractere
if ( prochain_caractere == '\r' ) { // CR
prochain_caractere = lireChar();
if ( prochain_caractere == '\n' ) { // LF
fini = true;
} else { // CR doit etre suivi de LF, sous Windows
System.out.println (
"Erreur fatale dans la methode lireLigne de la classe Clavier.");
System.exit(1); // 1 : pour signifier un arret anormal
} // if non LF
} else if ( prochain_caractere == '\n' ) { // UNIX, Linux et Mac OS X
fini = true;
}
} // while
} // lireFinLigne
public static String lireString() {
/* antecedent :
* consequent : Retourne la chaine lue, a partir du curseur.
* La fin de la chaine est determinee par :
* LF (line feed) ou par CR (carriage return)
* suivi de LF.
* Ni LF ni CR ne seront presents dans la chaine mais
* auront ete lus.
*/
char prochain_caractere;
String resultat = "";
boolean fini = false;
while ( ! fini ) {
prochain_caractere = lireChar(); // Lire un caractere
if ( prochain_caractere == '\r' ) { // CR
prochain_caractere = lireChar();
if ( prochain_caractere == '\n' ) { // LF
fini = true;
} else { // CR doit etre suivi de LF, sous Windows
System.out.println (
"Erreur fatale dans la methode lireLigne de la classe Clavier.");
System.exit(1); // 1 : pour signifier un arret anormal
} // if non LF
} else if ( prochain_caractere == '\n' ) { // UNIX et Mac OS X
fini = true;
} else { // concatener le caractere a la fin de la chaine
resultat = resultat + prochain_caractere;
}
} // while
return resultat;
} // lireString
public static byte lireByte() {
/* antecedent : -
* consequent : retourne le nombre entier octet lu, a partir du
* curseur. La fin du nombre est determinee par un
* separateur (voir ci-haut). Le separateur est lu.
* Le nombre peut commencer par - (negatif) mais ne
* peut commencer par +.
*/
/* antecedent : -
* consequent : retourne le nombre entier court lu, a partir du
* curseur. La fin du nombre est determinee par un
* separateur (voir ci-haut). Le separateur est lu.
* Le nombre peut commencer par - (negatif) mais ne
* peut commencer par +.
*/
/* antecedent : -
* consequent : retourne le nombre entier lu, a partir du
* curseur. La fin du nombre est determinee par un
* separateur (voir ci-haut). Le separateur est lu.
* Le nombre peut commencer par - (negatif) mais ne
* peut commencer par +.
*/
/* antecedent : -
* consequent : retourne le nombre entier long lu, a partir du
* curseur. La fin du nombre est determinee par un
* separateur (voir ci-haut). Le separateur est lu.
* Le nombre peut commencer par - (negatif) mais ne
* peut commencer par +.
*/
/* antecedent : -
* consequent : retourne le nombre reel lu, a partir du
* curseur. La fin du nombre est determinee par un
* separateur (voir ci-haut). Le separateur est lu.
* Le nombre peut commencer par - (negatif) ou + (positif).
* Le nombre peut ne pas contenir le point decimal.
*/
/* antecedent :
* consequent : retourne le nombre reel double lu, a partir du
* curseur. La fin du nombre est determinee par un
* separateur (voir ci-haut). Le separateur est lu.
* Le nombre peut commencer par - (negatif) ou + (positif).
* Le nombre peut ne pas contenir le point decimal.
*/
Je sais tres bien que mon programme est mal fait mais le plus important serais qu'il fonctionne et non son efficacité coté temps.
Pour ce qui est des validations je doit seulement fair les validations logiques en assumant que l'utilisateur entrera le bon type lorsque demandé.
Donc si quelqu'un pouvait m'aider ;) je crois que je doit utiliser la méthode "lireFinLigne()" mais je ne sais pas ou et comment.
Canard007
Messages postés5929Date d'inscriptionmercredi 26 mai 2004StatutContributeurDernière intervention18 septembre 2009215 21 févr. 2005 à 08:22
Je pense que l' "erreur" vient juste de la methode lirechar en effet
quand tu tape z + enter le z doit etre placé dans le char et enterreste en attente jusaqu'au passage du prochain read.
La solution serai sans doute d'utiliser lireString qui te renvoie une chaine de caracteres que tu compare ensuite avec ce que tu veux :
exemple:
System.out.println ( "\n" + "Entrez le code de l'infraction : " );
String codeInfraction = Clavier.lireString();
while ( codeInfraction .equalsIgnoreCase ("q") ) {
System.out.println ( "\n" + "Les codes d'infraction permis sont : s, a, f, d et q pour quitter" );
}else if ( ............................................
pour le equalsIgnoreCase en fait cela fait une comparaison de chaine en ignorant la case (ce qui est pratique dans ton cas)
verifie par contre que cela s'ecrit bien comme ca...je n'ai pas de compilo java sous la main la...
n'hesite pas si tu as d'autres questions..bon courage et bonne journée
