à partir du corrigé de l'exercice Agence Immobilière, faire l'exercice ci-dessous:
source ici
1) Fixer les constantes MAX_BIENS MAX_CLIENTS attributs d'Agence à 2
afin de mettre en évidence l'erreur qui se produit en cas de dépassement de capacité d'un tableau:
class Agence {
public static final int MAX_BIENS = 2;
public static final int MAX_CLIENTS = 2;
etc ....
BienImmo ajouteBien(BienImmo m) throws ExceptionDepassement {
if (nbBiens < MAX_BIENS) {
stocknbBiens++ = m;
}
else {
throw new ExceptionDepassement(nbBiens, m);
}
return m;
}
Que se passerait-il si on ne gérait pas cette erreur avec la classe ExceptionDepassement ?
Tester cette situation.
en supprimant la gestion de l'erreur:
BienImmo ajouteBien(BienImmo m) {
stocknbBiens++ = m;
return m;
}
2) Fixer maintenant les tailles de tableaux à une valeur supérieure:
class Agence {
public static final int MAX_BIENS = 20;
public static final int MAX_CLIENTS = 20;
Mettre hors-service (entre commentaires) la capture des Exceptions génériques dans la fonction main:
/*
catch (Exception e) {
System.out.println(e.getMessage());
}
*/
Ecrire une méthode getPrixAuMetre() qui calcule le prix au mètre-carré d'un bien immobilier et l'appeller dans la fonction main.
System.out.println("prix au mètre carré pour "+b1.getDenomination()+":"+b1.getPrixAuMetre()+" Euros");
System.out.print("prix au mètre carré pour "+b2.getDenomination()+":"+b2.getPrixAuMetre()+" Euros");
Dans quelle condition cette méthode peut-elle provoquer une erreur ?
Expérimenter cette hypothèse:
Affectez une surface nulle au bien b2:
BienImmo b2 = fnaim.ajouteBien(new Usine("usine récente",
"agro-alimentaire", 10000000,
0,
BienImmo.MODE_VENTE,
"atelier;entrepots", 1000));
Pourquoi l'exception attendue n'est-elle pas levée dans le cas où prix et durface sont des types double?
Modifier la classe BienImmo pour que les attributs prix et surface ne soient plus des types double mais des types int.
Refaire l'expérimentation de la condition d'erreur.
Remplacer l'exception originelle par une nouvelle classe d'exception métier:
class ExceptionZero
extends Exception {
public BienImmo enErreur;
ExceptionZero(String msg, BienImmo enErreur) {
super("erreur zéro:" + msg + " ! ");
this.enErreur=enErreur;
}
}
Capturer cette exception au niveau de la fonction main. Que se passe-t-il lorsque l'exception est levée ?
Est il légitime dans ce cas précis d'interrompre brutalement l'exécution du programme à cause d'une valeur erronnée dans un objet ?
Gérer cette exception de façon à poursuivre le programme malgré l'erreur.
3) Ecrire un méthode valider() pour BienImmo.
Pour une Maison, cette méthode vérifie qu'il y a au moins une salle de bains pour 4 pièces.
Pour une Usine, cette méthode vérifie qu'il y a au moins 1 KWh de puissance électrique installée pour 10 m2 de surface.
Cette méthode sera appelée par une méthode de la classe Agence (sur demande de la fonction main() bien entendu).
Deux stratégies peuvent être mises en oeuvre:
a) retourner une valeur fausse si la condition n'est pas vérifiée.
b) lever une exception métier:
class ExceptionValidationMetier
extends Exception {
ExceptionValidationMetier(String msg) {
super("erreur Validation métier:" + msg + "!");
}
}
Implémenter chacune de ces stratégies, et dans le cas de l'exception, la capturer de manière pertinente.
/////////////////////////// corrigé de l'exercice précédent ////////////////////
package agence;
////////////////////////////////////////////////////////////////////////////////
class ExceptionZero
extends Exception {
public BienImmo enErreur;
ExceptionZero(String msg, BienImmo enErreur) {
super("erreur Zero:" + msg + "!");
this.enErreur = enErreur;
}
}
class ExceptionValidationMetier
extends Exception {
ExceptionValidationMetier(String msg) {
super("erreur Validation métier:" + msg + "!");
}
}
class ExceptionDepassement
extends Exception {
ExceptionDepassement(int indice, Object m) {
super("erreur ajout de \n" + m.toString() + "impossible à l'indice:" +
indice + "!");
}
}
////////////////////////////////////////////////////////////////////////////////
class Client {
private String nom;
private boolean particulier; //personne morale ou physique
private String adresse;
private String commune;
public Client(String nom, String adresse, String commune) {
this.nom = nom;
this.adresse = adresse;
this.commune = commune;
}
public String toString() {
return " nom:" + nom + (particulier ? "(particulier)" : "(personne morale)") +
"; adresse:" + adresse + "; commune:" + commune + "\n";
}
}
////////////////////////////////////////////////////////////////////////////////
class BienImmo {
public static final int MODE_LOCATION = 1;
public static final int MODE_VENTE = 2;
public static final int MODE_LOCATION_VENTE = 3;
private String denomination;
private String nature; //appartement, entrepot, atelier, villa
private int prix;
private int surface;
private int mode; //1= location; 2=vente; 3=location-vente
private Client proprietaire;
private Client acquereur;
public BienImmo() {
}
public BienImmo(String denomination, String nature, int prix,
int surface, int mode) {
this.denomination = denomination;
this.nature = nature;
this.prix = prix;
this.surface = surface;
this.mode = mode;
}
public String getDenomination() {
return denomination;
}
public void setProprietaire(Client p) {
proprietaire = p;
}
public void setAcquereur(Client p) {
acquereur = p;
}
public String toString() {
String mod = "";
switch (mode) {
case MODE_LOCATION:
mod = "location";
break;
case MODE_VENTE:
mod = "vente";
break;
case MODE_LOCATION_VENTE:
mod = "location vente";
break;
}
String prop = "pas de proprio";
String acq = "pas d'acquéreur";
if (proprietaire != null) {
prop = proprietaire.toString();
}
if (acquereur != null) {
acq = acquereur.toString();
}
return " dénomination:" + denomination + "; nature:" +
nature + "; prix:" + prix
// + "; prix au mètre:" + getPrixAuMetre()
+ " Euros; mode:" +
mod + "; propriétaire:" + prop + "; acquéreur:" + acq + "\n";
}
}
////////////////////////////////////////////////////////////////////////////////
class Maison
extends BienImmo {
private int nbPieces;
private int nbSallesDeBain;
public Maison(String denomination, String nature, int prix,
int surface, int mode, int nbPieces, int nbSallesDeBain) {
super(denomination, nature, prix, surface, mode);
this.nbPieces = nbPieces;
this.nbSallesDeBain = nbSallesDeBain;
}
public String toString() {
return super.toString() + " nb de pièces:" + nbPieces +
"; nb de salles de bains:" + nbSallesDeBain + "\n";
}
}
////////////////////////////////////////////////////////////////////////////////
class Usine
extends BienImmo {
private String equipement; //exemple: pont roulant, vestiaires, réfectoire à séparer par des points-virgules
private int puissanceElectrique; //en kw
public Usine() {
}
public Usine(String denomination, String nature, int prix, int surface,
int mode, String equipement, int puissanceElectrique) {
super(denomination, nature, prix, surface, mode);
this.equipement = equipement;
this.puissanceElectrique = puissanceElectrique;
}
public String toString() {
return super.toString() + " équipement:" + equipement +
"; puissance électrique:" + puissanceElectrique + " kw\n";
}
}
////////////////////////////////////////////////////////////////////////////////
class Agence {
public static final int MAX_BIENS = 20;
public static final int MAX_CLIENTS = 20;
private int nbBiens = 0;
private int nbClients = 0;
private BienImmo stock = new BienImmoMAX_BIENS;
private Client clientele = new ClientMAX_CLIENTS;
public Agence() {
}
BienImmo ajouteBien_(BienImmo m) {
stocknbBiens++ = m;
return m;
}
BienImmo ajouteBien(BienImmo m) throws ExceptionDepassement {
if (nbBiens < MAX_BIENS) {
stocknbBiens++ = m;
}
else {
throw new ExceptionDepassement(nbBiens, m);
}
return m;
}
Client ajouteClient(Client m) throws ExceptionDepassement {
if (nbClients < MAX_CLIENTS) {
clientelenbClients++ = m;
}
else {
throw new ExceptionDepassement(nbClients, m);
}
return m;
}
void setProprietaire(BienImmo b, Client c) {
b.setProprietaire(c);
}
void setAcquereur(BienImmo b, Client c) {
b.setAcquereur(c);
}
public String toString() {
String result = "";
result += "Stock:\n";
for (int i = 0; i < nbBiens; i++) {
result += stocki.toString();
}
result += "Clientele:\n";
for (int i = 0; i < nbClients; i++) {
result += clientelei.toString();
}
return result;
}
public static void main(String args) {
}
}
////////////////////////////////////////////////////////////////////////////////
public class Immo {
public static void main(String args) {
Agence fnaim = new Agence();
try {
BienImmo b1 = fnaim.ajouteBien(new Maison("appartement ensoleillé", "F3",
100000, 80,
BienImmo.MODE_LOCATION, 3, 1));
BienImmo b2 = fnaim.ajouteBien(new Usine("usine récente",
"agro-alimentaire", 10000000,
6000,
BienImmo.MODE_VENTE,
"atelier;entrepots", 1000));
BienImmo b3 = fnaim.ajouteBien(new Maison("appartement exceptionnel",
"F2",
800000, 60, BienImmo.MODE_VENTE,
2, 1));
BienImmo b4 = fnaim.ajouteBien(new Maison("appartement standing", "T6",
1800000, 160,
BienImmo.MODE_LOCATION_VENTE, 6,
2));
BienImmo b5 = fnaim.ajouteBien(new Usine("atelier", "électronique",
6000000, 2000,
BienImmo.MODE_VENTE,
"atelier;vestiaires", 100));
Client c1 = fnaim.ajouteClient(new Client("Dupont", "10 rue des lilas",
"30100 Alès"));
Client c2 = fnaim.ajouteClient(new Client("Durand", "12 rue des roses",
"30100 Alès"));
Client c3 = fnaim.ajouteClient(new Client("Trucmuche",
"100 boulevard des fleurs",
"30000 Nimes"));
fnaim.setProprietaire(b1, c1);
fnaim.setProprietaire(b2, c3);
fnaim.setProprietaire(b3, c1);
fnaim.setAcquereur(b3, c1); //doit provoquer une erreur
fnaim.setAcquereur(b1, c3);
System.out.println(fnaim);
}
catch (ExceptionDepassement e) {
System.out.println(e.getMessage());
}
/*
catch (Exception e) {
System.out.println(e.getMessage());
}*/
}
}
////////////////////////////////////////////////////////////////////////////////