public class Lire { // Par défaut, la bibliothèque ne lit que les premiers caractères de chaque ligne private static boolean filtre = true; // Filtre : // si leFiltre = vrai, seul le premier caractère de chaque ligne // sera lu par la fonction Lire.c() (appel automatique de la fonction Purge) // sinon tous les caractères sont lus, y compris les caractères de contrôle public static void Filtre ( boolean leFiltre) { filtre = leFiltre; } // Purge : élimine tous les caractères jusqu'à la fin de la ligne public static void Purge() { try { char car ; // car qui sert de poubelle do { car = (char) System.in.read (); } while (car != '\n'); } catch (java.io.IOException e) { System.out.println ("Erreur de saisie"); System.exit (0); } } // Lecture d'une chaine terminée par un "RETURN" : saute la fin de ligne public static String Chaine() { char car ; String result = ""; try { car = (char) System.in.read (); //lecture de la ligne jusqu'au retour charriot (13, 0xD) // pour unix/linux et windows while (car != '\r' && car != '\n') { result = result + car; car = (char) System.in.read (); } // Saut du fin de ligne (10, 0xA) if ( car != '\n') System.in.skip (1);// skip = sauter ; //"System.in.skip (1)" => idem que la fonction "purge" } catch (java.io.IOException e) { System.out.println ("Erreur de saisie"); System.exit (0); } return result; } //------------------------- OVERLOAD n°1 de Chaine ------------------------------ public static String Chaine(String message) { char car ; String result = ""; try { System.out.print(message); car = (char) System.in.read (); //lecture de la ligne jusqu'au retour charriot (13, 0xD) while (car != '\r') { result = result + car; car = (char) System.in.read (); } // Saut du fin de ligne (10, 0xA) System.in.skip (1); } catch (java.io.IOException e) { System.out.println ("Erreur de saisie"); // System.exit (0); } return result; } // Lecture d'un caractère : uniquement le premier caractère de la nouvelle ligne // si filtrage, n'importe quel caractère sinon public static char Caractere () { char result = 0; try { result = (char) System.in.read (); } catch (java.io.IOException e) { System.out.println ("Erreur de saisie"); System.exit (0); } if (filtre) { Purge (); } return result; } public static int Entier () { int result = 0; try { result = Integer.parseInt ( Chaine () ); } catch (NumberFormatException e) { System.out.println ("Format entier incorrect !"); System.exit(0); } return result; } public static short EntierCourt () { short result = 0; try { result = Short.parseShort ( Chaine () ); } catch (NumberFormatException e) { System.out.println ("Format entier incorrect !"); System.exit(0); } return result; } public static long EntierLong () { long result = 0; try { result = Long.parseLong ( Chaine () ); } catch (NumberFormatException e) { System.out.println ("Format entier incorrect !"); System.exit(0); } return result; } public static float Reel () { float result = 0; try { result = Float.valueOf( Chaine() ).floatValue () ; } catch (NumberFormatException e) { System.out.println ("Format reel incorrect!"); System.exit(0); } return result; } public static double ReelDouble () { double result = 0; try { result = Double.valueOf( Chaine() ).doubleValue () ; } catch (NumberFormatException e) { System.out.println ("Format reel incorrect!"); System.exit(0); } return result; } // Attente : permet de visualiser les résultats avant la sortie // de l'application. public static void Attente() { System.out.println (); System.out.println ("*** Tapez Entree pour Terminer ***"); Lire.c(); } // Attente : permet de visualiser les résultats avant la suite // de l'application. public static void Suite() { System.out.println (); System.out.println ("*** Tapez Entree pour Continuer ***"); Lire.c(); } public static boolean Question(String msg) { char reponse ; do { System.out.print (msg + " (O/N ) ?" ); reponse = Lire.c(); }while ((reponse!='O')&&(reponse!='o')&&(reponse!='n')&&(reponse!='N')); // arrêt quand reponse est égal à O,o,N,n return (reponse == 'O') || (reponse == 'o') ; } // Alias des fonctions public static String S () { return Chaine(); } public static short s () { return EntierCourt(); } public static long l () { return EntierLong(); } public static int i () { return Entier(); } public static char c () { return Caractere(); } public static float f () { return Reel (); } public static double d () { return ReelDouble (); } // Fonction qui lit un tableau de char et renvoi ce tableau public static char[] remplirTableau(String invite, int motSize) { final int MOT_SIZE = motSize ; final char TERMINATEUR = '.'; char mot[] ; char actualCar ; int count ; count = 0 ; mot = new char[MOT_SIZE] ; System.out.println(invite); Lire.Filtre(false); do { actualCar = Lire.c(); mot[count] = actualCar ; count ++ ; } while(actualCar != '\r' && actualCar != '\n' && actualCar != TERMINATEUR && count < mot.length) ; if(actualCar != TERMINATEUR) { mot[count - 1] = TERMINATEUR ; } if(actualCar != '\n') { Lire.Purge(); } Lire.Filtre(true); return mot; /* Fonction qui lit un tableau de char sans terminateur et renvoi ce tableau */ public static char[] remplirMot(String invite) // invite est la chaine affichée à l'écran avant la saisie // le tableau retourné est le mot saisi, et sa longueur est la longueur du mot. { char mot[] ; char actualCar ; int count ; count = 0 ; mot = new char[80]; System.out.println(invite); Lire.Filtre(false); actualCar = Lire.c(); while (actualCar != '\r' && actualCar != '\n' && count < mot.length) { mot[count] = actualCar ; count ++ ; actualCar = Lire.c(); } if(actualCar != '\n') { Lire.Purge(); } Lire.Filtre(true); char [] newMot= new char[count]; for (int i =0; i<count;i++) { newMot[i] = mot[i]; } return newMot; } public static void afficheMot(char[] mot) { for (int i = 0; i< mot.length; i++) { System.out.print(mot[i]); } } public static void afficheTableau(char[] mot) { int i; for (i = 0; i< mot.length && mot[i] != '.'; i++) { System.out.print(mot[i]); } System.out.print(mot[i]); } }
public class BoiteAOutil { /*** * fonction booleanne test entree alphanumerique * @param entree chaine entree * @return vrai */ public static boolean estAlpha(String entree) { if(entree != null && !entree.trim().isEmpty() && entree.matches("^[\\p{L} ]+$")) { return true; } else { return false; } } public static boolean isInteger(String entree) { if(entree != null && !entree.trim().isEmpty() && entree.matches("[0-9]")) { return true; } else { return false; } } /*** * fonction booleanne test entree numerique avec 3 chiffres * @param entree * @return vrai */ public static boolean isEntierNumeroRue(String entree) { if(entree != null && !entree.trim().isEmpty() && entree.matches("[0-9]{3}")) { return true; } else { return false; } } /*** * fonction booleanne test entree numerique avec 5 chiffres pour le code postale * @param entree * @return vrai */ public static boolean isEntierCodePostal(String entree) { if(entree != null && !entree.trim().isEmpty() && entree.matches("[0-9]{5}")) { return true; } else { return false; } } public static boolean isFloat(String entree) { if(entree != null && !entree.trim().isEmpty() && entree.matches("^([+-]?\\d*\\.?\\d*)$")) { return true; } else { return false; } } }
L'individu idéal ou primitif, tel que tout type d'individu instanciable en héritera les propriétés.
public abstract class Individu { private String m_strNom; private String m_strPrenom; private Adresse m_adresse = new Adresse(); //-------------------------------------- CONSTRUCTEUR PAR DEFAUT ----------------------------------------- public Individu () { this("mon nom est personne", "mon prénom est personne,", new Adresse()); } //---------------------------------------- CONSTRUCTEUR ------------------------------------------------ /** * * @param strNom * @param strPrenom * @param adresse */ public Individu (String strNom, String strPrenom, Adresse adresse) { // si les valeurs données ne satisfont pas les "set", alors valeur par défaut : if (!setNom( strNom)) setNom("mon nom est personne"); if (!setPrenom( strPrenom)) setPrenom("mon prénom est personne"); if (adresse == null) { m_adresse = new Adresse(); } else { m_adresse = adresse; } } //------------------------------------------------------------ /** Affecte (si possible) la chaîne donnée à la propriété m_strNom. * * @param nomSaisi : Chaîne à affecter (doit être alphabétique, plus : espace, tiret, apostrophe). * @return VRAI si affectation possible. */ public boolean setNom(String nomSaisi) { boolean oK = false; if (OutilsTests.estAlphaPlus(nomSaisi)) { oK = true; m_strNom = nomSaisi.trim(); } return oK; } //------------------------------------------------------------ /** Affecte (si possible) la chaîne donnée à la propriété m_strPrenom. * * @param prenomSaisi : Chaîne à affecter (doit être alphabétique, plus : espace, tiret, apostrophe). * @return VRAI si affectation possible. */ public boolean setPrenom(String prenomSaisi) { boolean oK = false; if (OutilsTests.estAlphaPlus(prenomSaisi)) { oK = true; m_strPrenom = prenomSaisi.trim(); } return oK; } //------------------------------------------------------------ /** Affecte (si possible) la chaîne donnée à la propriété m_adresse. * * @param adresseSaisie : Chaîne à affecter (voir contrainte de la class Adresse). * @return VRAI si affectation possible. */ public boolean setAdresse(String adresseSaisie) { return (m_adresse.setStructAdresse(adresseSaisie)); } //------------------------------------------------------------ /** Récupère la propriété m_strNom. * * @return Contenu de m_strNom. */ public String getNom() { return m_strNom; } //------------------------------------------------------------ /** Récupère la propriété m_strPrenom. * * @return Contenu de m_strPrenom. */ public String getPrenom() { return m_strPrenom; } //------------------------------------------------------------ /** Récupère la propriété m_adresse. * * @return Contenu de m_adresse. */ public String getAdresse() { return m_adresse.toString(); } //------------------------------------------------------------ /** Acquisition des propriétés de l'individu. * */ public void lire() { String saisie, invite; // Acquisition du nom : invite = "Donnez un nom : "; do { saisie = Lire.Chaine(invite); } while (!(this.setNom(saisie))); // Arrêt quand la saisie est correcte // Acquisition du prénom : invite = "Donnez un prénom : "; do { saisie = Lire.Chaine(invite); } while (!(this.setPrenom(saisie))); // Arrêt quand la saisie est correcte // Acquisition de l'adresse : remarque ! L'adresse se lit elle-même tout comme l'individu se lit lui-même m_adresse.lire(); } //------------------------------------------------------------ /** Afficher les propriétés de l'individu. * */ public void afficher() { System.out.println(this.getPrenom() + " " + this.getNom()); //System.out.println(this.getAdresse()); m_adresse.affiche(); } }
public class Adresse { private int m_numRue; private String m_strNomRue; private int m_nCodePost; private String m_strVille; //----------------------------------------------------------- public static final String SEP_ADR = ","; // Séparateur des différents champs d'une adresse de type String //----------------------------------------------------------- //------------------------------- CONSTRUCTEUR --------------------------------- /** * * @param strNom * @param strPrenom * @param adresse */ public Adresse (int numRue, String strNomRue, int nCodePost, String strVille) { if(!setNumRue( numRue)) {setNumRue ("pas de nom");}; if(!setNomRue(strNomRue)) {setNomRue ("pas de prénom");}; if(!setCP( nCodePost)) {setCP("pas d'adresse");}; if(!setVille( strVille)) {setVille("pas d'adresse");}; } /*------------------------------ CONSTRUCTEUR PAR DEFAUT ------------------------------------------*/ public Adresse () { this(00, "RueInconnue", 99999, "VilleInconnue"); } /* ***************************** GETTER LES PROPRIETES ***************************************** */ /** Récupère la propriété m_numRue. * * @return Contenu de m_numRue. */ public int getNumRue() { return m_numRue; } //----------------------------------------------------------- /** Récupère la propriété m_strNomRue. * * @return Contenu de m_strNomRue. */ public String getNomRue() { return m_strNomRue; } //----------------------------------------------------------- /** Récupère la propriété m_nCodePost. * * @return Contenu de m_nCodePost. */ public int getCP() { return m_nCodePost; } //----------------------------------------------------------- /** Récupère la propriété m_strVille. * * @return Contenu de m_strVille. */ public String getVille() { return m_strVille; } // ***************************** SETTER LES PROPRIETES ****************************************** /** Affecte (si possible) la chaîne donnée à la propriété m_strNomRue. * * @param strSaisi : Chaîne à affecter (doit être alphabétique, plus : noombres, espace, tiret, apostrophe). * @return VRAI si affectation possible. */ public boolean setNomRue(String strSaisi) { boolean oK = false; if (OutilsTests.estAlphaPlus(strSaisi)) { oK = true; m_strNomRue = strSaisi.trim(); } return oK; } //----------------------------------------------------------------------------------------------------- /** Affecte (si possible) la chaîne donnée à la propriété m_strVille. * * @param strSaisi : Chaîne à affecter (doit être alphabétique, plus : espace, tiret, apostrophe, slash). * @return VRAI si affectation possible. */ public boolean setVille(String strSaisi) { boolean oK = false; if (OutilsTests.estAlphaPlus2(strSaisi)) { oK = true; m_strVille = strSaisi.trim(); } return oK; } //-------------------------------------------------------------------------------------------------- /** Affecte (si possible) la convertion de la chaîne donnée à la propriété m_numRue. * * @param numSaisi : Chaîne à affecter (doit représenter un entier). * @return VRAI si affectation possible. */ private boolean setNumRue(String numSaisi) { boolean oK = false; numSaisi = numSaisi.trim(); if (OutilsTests.estEntier(numSaisi)) { oK = setNumRue(Integer.parseInt(numSaisi)); } return oK; } //-------------------------------------------------------------------------------------------------- public boolean setNumRue(int numSaisi) { boolean oK = false; if (numSaisi>0) { oK = true; m_numRue =numSaisi ; } return oK; } //---------------------------------------------------------------------------------------------------- /** Affecte (si possible) la convertion de la chaîne donnée à la propriété m_nCodePost. * * @param numSaisi : Chaîne à affecter (doit représenter un entier de 5 chiffres). * @return VRAI si affectation possible. */ private boolean setCP(String numSaisi) { boolean oK = false; numSaisi = numSaisi.trim(); if (OutilsTests.estCP(numSaisi)) { oK = true; m_nCodePost = Integer.parseInt(numSaisi) ; } return oK; } //---------------------------------------------------------------------------------------------------- public boolean setCP(int numSaisi) { boolean oK = false; if(numSaisi>0) { oK = true; m_nCodePost = numSaisi; } return oK; } //----------------------------------------------------------------------------------------------------- /** Découpe et affecte (si possible) la chaîne donnée aux différentes propriétés de Adresse. * * @param strSaisie : Chaîne à traiter/affecter selon la structure : "entier, nom rue, code postal, nom ville". * @return VRAI si affectation possible. */ public boolean setStructAdresse(String strSaisie) { boolean oK = false ; // A priori, c'est pas bon. if (strSaisie != null) { // la chaîne saisie doit se composer de 4 parties séparées par des SEP_ADR : String[] strDecoupe = strSaisie.split(SEP_ADR); if ((strDecoupe.length == 4) && (this.setNumRue(strDecoupe[0])) && (this.setNomRue(strDecoupe[1])) && (this.setCP(strDecoupe[2])) && (this.setVille(strDecoupe[3]))) { oK = true; } } return oK; } //--------------------- remarque sur l'override du string ----------------------------------------- // Si on ne crée pas d'override, objet.toString() => renvoie le nom de la classe de l'objet // l'override ci-dessous permet d'afficher les propriétés de l'objet @Override public String toString() { return Integer.toString(this.getNumRue()) + SEP_ADR+ this.getNomRue() + SEP_ADR+ Integer.toString(this.getCP()) + SEP_ADR+ this.getVille(); } //------------------- permet à l'adresse de se lire elle-même ---------------------------------------- public void lire() { // lire le n° de rue : String saisie; String invite = "Donnez un numéro de rue : "; do { saisie = Lire.Chaine(invite); } while (!(this.setNumRue(saisie))); // Arrêt quand la saisie est correcte // lire la rue : invite = "Donnez le nom de la rue : "; do { saisie = Lire.Chaine(invite); } while (!(this.setNomRue(saisie))); // Arrêt quand la saisie est correcte // lire la ville : invite = "Donnez la Ville : "; do { saisie = Lire.Chaine(invite); } while (!(this.setVille(saisie))); // Arrêt quand la saisie est correcte // lire le code postal : invite = "Donnez le code postal : "; do { saisie = Lire.Chaine(invite); } while (!(this.setCP(saisie))); // Arrêt quand la saisie est correcte } // permet d'afficher une adresse : public void affiche() { System.out.println(this.toString()); } }
public class Groupe { /*** * Attribut de la classe groupe MAx,m_nCpt,m_tableauindividu[] */ private static final int MAX= 20; private int m_nCpt=0; private static int m_nMax; private Individu m_tableauindividu[]; /*** * constructeur par defaut */ public Groupe() { this(MAX); setMax(MAX); } /*** * Constructeur d'initialisation * @param n : c'est le nombre d'individu */ public Groupe(int n) { if (n>0) { m_tableauindividu = new Individu[n]; setMax(n); } else { m_tableauindividu = new Individu[MAX]; setMax(MAX); } } /*** * fonction get m_nCpt qui retourne le nombre effectif dans le groupe * @return m_nCpt le retourne le nombre d'individus effectifs */ public int getNb() { return m_nCpt; } /*** * fonction set du m_nCpt met à jour le nombre effectif d'individus * @param m_nCpt */ private void setM_nCpt(int m_nCpt) { this.m_nCpt = m_nCpt; } /*** * Fonction de la saisie lire() permet de saisir les donnees de chaque personne */ public void lire() { //int i =0; int i = getNb(); if (isfull(i)) { } else { do { System.out.println("Tapper votre choix"); System.out.println(); System.out.println("Client '0' ... Salairé '1' ... Commercial '2' ... Individu '3'"); char d =Lire.c(); switch(d) { case '0': System.out.println("Saisie d'un client"); m_tableauindividu[i] = new Client(); m_tableauindividu[i].lire(); break; case '1': System.out.println("Saisie d'un salarié"); m_tableauindividu[i] = new Employé(); m_tableauindividu[i].lire(); break; case '2': System.out.println("Saisie d'un Commercial"); m_tableauindividu[i] = new Commercial(); m_tableauindividu[i].lire(); break; case '3': System.out.println("Saisie d'un individu"); m_tableauindividu[i] = new Personne(); m_tableauindividu[i].lire(); break; } i = i + 1; }while(!isfull(i) && Lire.Question("Voulez enregistrer d'autres informations ? [o/n] : ")); this.setM_nCpt(i); } } /*** * fonction afficher() qui permet d'afficher chaque personne du groupe */ public void afficher() { int i =0; if(getNb()==0) { System.out.println("le tableau est vide"); } else { do { System.out.println("Individu N° " + i + " : "); System.out.println(); m_tableauindividu[i].afficher(); System.out.println(); i = i+1; }while(i < getNb()); System.out.println(); System.out.println("Nous avons " + getNb()+ " personne(s) de rentrée(s)"); } } /*** * * @return max */ public int getMax() { return m_nMax; } /*** * renvoie une reference sur l'individu dans la case visée * @param i * @return */ public Individu individuAt(int i) { if( i < 0 && i > getNb()) { return null; } else { return m_tableauindividu[i]; } } /*** * permet de voir si le groupe est rempli * @param i * @return */ public boolean isfull(int i) { if (i==getMax()) { System.out.println("le tableau est plein"); return true; } else { return false; } } private void setMax(int m_nMax) { Groupe.m_nMax = m_nMax; } }
public class Personne extends Individu { public Personne() { } public Personne(String nom, String prenom, Adresse adresse) { super(nom, prenom, adresse); } }
abstract class Salarié extends Individu { private final float SALAIREDEFAUT =2000; private float m_salaire; private int m_statut; /*** * Constructeur par defaut */ public Salarié() { this.setSalaire(SALAIREDEFAUT); this.setStatut("1"); } /*** * Constructeur d'initialisation * @param nom * @param prenom * @param adresse * @param salaire * @param statut */ public Salarié(String nom,String prenom,Adresse adresse,float salaire,int statut) { super( nom, prenom, adresse); if(!setSalaire(salaire))this.setSalaire(SALAIREDEFAUT); if(!setStatut(statut))this.setStatut("1"); } @Override public String toString() { return super.toString()+ " votre salaire est de : "+ getSalaire()+ " votre satatut est : "+ getStatut(); } /*** * cette methode recupere le salaire * @return le salsaire */ public float getSalaire() { return m_salaire; } /*** * cette methode met a jour le salaire l'entree est en float * @param m_salaire * @return retourne ok */ public boolean setSalaire(float m_salaire) { boolean ok = false; if(m_salaire>0.0) { this.m_salaire = (m_salaire); ok =true; } else { ok=false; } return ok; } /*** * cette methode (polymorphe) de la methode setSalaire (float)met à jour le salaire l'entree en string * @param m_salaire * @return ok */ private boolean setSalaire(String m_salaire) { boolean ok = false; if(BoiteAOutil.isFloat(m_salaire)) { ok=setSalaire(Float.parseFloat(m_salaire)); } else { ok=false; } return ok; } /*** * cette methode recupere le stat * @return le statut */ public int getStatut() { return m_statut; } /*** * cette methode met à jour le stat * @param m_statut * @return bollean ok */ public boolean setStatut(int m_statut) { boolean ok = false; if(m_statut> 0) { this.m_statut = (m_statut); ok =true; } else { ok=false; } return ok; } /*** * cette methode (polymorphe) de la methode setstat (float)met à jour le statut l'entree en string * @param m_statut * @return boolean ok */ private boolean setStatut(String m_statut) { boolean ok = false; if(BoiteAOutil.isInteger(m_statut)) { ok = setStatut(Integer.parseInt(m_statut)); } else { ok=false; } return ok; } /*** * Methode lire qui permet de récuperer les donnees saisie par l'opérateur */ @Override public void lire() { super.lire(); boolean oksalaire = false; boolean okstatut = false; System.out.println(); while (!oksalaire) { System.out.println("Combien gagnez-vous? "); oksalaire = this.setSalaire(Lire.S()); } System.out.println(); while (!okstatut) { System.out.println("Quel est votre statut? "); okstatut= this.setStatut(Lire.S()); } } }
public class Employé extends Salarié { public Employé() { } public Employé(String nom, String prenom, Adresse adresse, float salaire, int statut) { super(nom, prenom, adresse, salaire, statut); } }
public class Commercial extends Salarié { private float m_chiffreaffaire; private float m_ratio; private final float CADEFAUT=0; private final float RATIO=0.1f; // f : pour lui dire qu'il s'agit d'un float ; pareil que convertTo float sur un double /*** * constructeur par defaut */ public Commercial() { this.setChiffreAffaire(CADEFAUT); this.setRatio(RATIO); } /*** * constructeur d'initialisation * @param nom * @param prenom * @param adresse * @param salaire * @param statut * @param chiffreaffaire * @param ratio */ public Commercial(String nom,String prenom,Adresse adresse,float salaire,int statut,float chiffreaffaire,float ratio) { super(nom, prenom, adresse, salaire, statut); if(!setChiffreAffaire(chiffreaffaire))this.setChiffreAffaire(CADEFAUT); if(!setRatio(ratio))this.setRatio(RATIO); } /*** * methode getsalaire du commercial qui en plus rajoutte le chiffre d affaire et le ratio */ @Override public float getSalaire() { return super.getSalaire()+getChiffreAffaire()*getRatio(); } /*** * cette methode recupere le chiffre d affaire * @return chiffreaffaire */ private float getChiffreAffaire() { return m_chiffreaffaire; } /*** * cette methode met à jour le ca l'entree est en float * @param m_chiffreaffaire * @return ok */ private boolean setChiffreAffaire(float m_chiffreaffaire) { boolean ok = false; if(m_chiffreaffaire>0.0) { this.m_chiffreaffaire = (m_chiffreaffaire); ok =true; } else { ok=false; } return ok; } /*** * cette methode (polymorphe) de la methode setChiffreAffaire (float)met à jour le ca l'entree en string * @param m_chiffreaffaire * @return */ private boolean setChiffreAffaire(String m_chiffreaffaire) { boolean ok = false; if(BoiteAOutil.isFloat(m_chiffreaffaire)) { ok=setChiffreAffaire(Float.parseFloat(m_chiffreaffaire)); } else { ok=false; } return ok; } /*** * cette methode récupère le ratio * @return ratio */ private float getRatio() { return m_ratio; } /*** * cette methode met a jour le ratio l'entree est en float * @param m_ratio * @return ok */ private boolean setRatio(float ratio) { boolean ok = false; if(ratio>=0.02f && ratio <=0.1f) { this.m_ratio = (ratio); ok =true; } else { ok=false; } return ok; } private boolean setRatio(String m_ratio) { boolean ok = false; if(BoiteAOutil.isFloat(m_ratio)) { ok=setRatio(Float.parseFloat(m_ratio)); } else { ok=false; } return ok; } /*** * methode to string de la classe commercial */ @Override public String toString() { return super.toString()+ " votre chiffre d'affaire est de : " + getChiffreAffaire()+ " votre ratio est de : " + getRatio(); } /*** * methode lire de la classe commercial */ @Override public void lire() { super.lire(); boolean okchiffreaffaire = false; boolean okratio = false; System.out.println(); while (!okchiffreaffaire) { System.out.println("Quel est votre chiffre d'affaire? "); okchiffreaffaire = this.setChiffreAffaire(Lire.S()); } System.out.println(); while (!okratio) { System.out.println("Quel est votre ratio? "); okratio= this.setRatio(Lire.S()); } } }
public class Program { public static void main(String[] args) { Groupe monGroupe = new Groupe(); // Groupe des individus saisis // Affichage du nom et de la version du programme System.out.println("**** Saisie et affichage d'un tableau (groupe) d'individus (V1.0, 25/03/2015) ****" ); System.out.println(""); // Acquisition + affichage d'un certain nombre d'individus : do { System.out.println("--- Saisie d'au plus "+ monGroupe.getMax() +" personnes ---" ); System.out.println(""); // Acquisition d'un certain nombre d'individus : int i = 0; // indice de parcours du tableau d'individus do { monGroupe.lire(); i = i + 1; } while (Lire.Question("Voulez-vous saisir un autre individu ?") // Arrêt quand "non" && (i < monGroupe.getMax())) ; // ou si tableau plein // Affichage des individus saisis : System.out.println(""); monGroupe.afficher(); } while (Lire.Question("Voulez-vous saisir un autre groupe d'individus ?") ) ; // Arrêt quand "non" } }