```java
throw new AppartementNonDisponibleException("L'appartement n'est pas
disponible.");
}
appartement.setDisponible(false);
ContratLocation contrat = new ContratLocation(locataire, appartement,
dateDebut, dateFin, loyerMensuel, "Actif");
return contrat;
}
}
```
### 5. Créez une exception personnalisée `AppartementNonDisponibleException`
```java
public class AppartementNonDisponibleException extends Exception {
public AppartementNonDisponibleException(String message) {
super(message);
}
}
```
### 6. Créez une classe `Main` avec une méthode principale pour tester toutes les
fonctionnalités de votre application
```java
import java.util.Date;
public class Main {
public static void main(String[] args) {
try {
// Création de la gestion immobilière
GestionImmobiliere gestion = new GestionImmobiliere();
// Création et ajout d'appartements
Appartement app1 = new Appartement("123 Rue de Paris", 45.0, 2, true);
Appartement app2 = new Appartement("456 Rue de Lyon", 75.5, 3, true);
gestion.ajouter(app1);
gestion.ajouter(app2);
// Affichage des appartements
System.out.println("Liste des appartements :");
gestion.afficher();
// Création et ajout de locataires
Locataire loc1 = new Locataire(1, "Dupont", "Jean");
Locataire loc2 = new Locataire(2, "Martin", "Claire");
gestion.ajouter(loc1);
gestion.ajouter(loc2);
// Affichage des locataires
System.out.println("\nListe des locataires :");
gestion.afficher();
// Création d'un contrat de location
Date dateDebut = new Date();
Date dateFin = new Date(dateDebut.getTime() + (1000L * 60 * 60 * 24 *
365)); // +1 an
ContratLocation contrat = gestion.creerContrat(loc1, app1, dateDebut,
dateFin, 1200.0);
// Affichage du contrat
System.out.println("\nContrat de location créé :");
System.out.println("Locataire : " +
contrat.getLocataire().getFullName());
System.out.println("Appartement : " +
contrat.getAppartement().getAdresse());
System.out.println("Date de début : " + contrat.getDateDebut());
System.out.println("Date de fin : " + contrat.getDateFin());
System.out.println("Loyer mensuel : " + contrat.getLoyerMensuel());
System.out.println("État du contrat : " + contrat.getEtatContrat());
} catch (AppartementNonDisponibleException e) {
e.printStackTrace();
}
}
}
```
### Explications supplémentaires :
1. **Classes `Appartement`, `Locataire`, et `ContratLocation`** : Ces classes
définissent les entités principales de l'application.
2. **Classe abstraite `Personne` et classe `Locataire`** : `Locataire` hérite de
`Personne` et implémente les méthodes `getId()` et `getFullName()`.
3. **Interfaces `GererAppartement` et `GererLocataire`** : Elles définissent les
méthodes de gestion des appartements et des locataires.
4. **Classe `GestionImmobiliere`** : Cette classe implémente les interfaces et
fournit des méthodes pour gérer les appartements et les locataires, ainsi que pour
créer des contrats de location.
5. **Classe `AppartementNonDisponibleException`** : Exception personnalisée pour
gérer les cas où un appartement n'est pas disponible.
6. **Classe `Main`** : Point d'entrée de l'application pour tester les
fonctionnalités.
Avec cette structure, vous devriez être en mesure de gérer la liste des
appartements, les locataires et les contrats de location selon les spécifications
données dans l'énoncé.
Pour répondre aux questions de l'exercice, voici les réponses correspondantes
basées sur les informations fournies et les spécifications demandées.
### 1. Créez les classes selon les spécifications données.
Cela a déjà été fait dans le code fourni précédemment.
### 2. Implémentez la classe `Personne` et assurez-vous que `Locataire` hérite de
cette classe.
```java
public abstract class Personne {
protected String nom;
protected String prenom;
public Personne(String nom, String prenom) {
this.nom = nom;
this.prenom = prenom;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public String getPrenom() {
return prenom;
}
public void setPrenom(String prenom) {
this.prenom = prenom;
}
public abstract int getId();
public abstract String getFullName();
}
public class Locataire extends Personne {
private int idLocataire;
public Locataire(int idLocataire, String nom, String prenom) {
super(nom, prenom);
this.idLocataire = idLocataire;
}
@Override
public int getId() {
return idLocataire;
}
@Override
public String getFullName() {
return nom + " " + prenom;
}
}
```
### 3. Implémentez la classe `GestionImmobiliere` qui contiendra des méthodes pour
ajouter, supprimer et afficher les appartements et les locataires.
Cela a déjà été fait dans le code fourni précédemment.
### 4. Implémentez une méthode pour créer un contrat de location.
Cette méthode est incluse dans la classe `GestionImmobiliere`.
```java
public ContratLocation creerContrat(Locataire locataire, Appartement appartement,
Date dateDebut, Date dateFin, double loyerMensuel) throws
AppartementNonDisponibleException {
if (!appartement.isDisponible()) {
throw new AppartementNonDisponibleException("L'appartement n'est pas
disponible.");
}
appartement.setDisponible(false);
ContratLocation contrat = new ContratLocation(locataire, appartement,
dateDebut, dateFin, loyerMensuel, "Actif");
return contrat;
}
```
### 5. Créez une classe `Principale` avec une méthode main qui permettra de tester
toutes les fonctionnalités de gestion immobilière.
Cela a déjà été fait dans le code fourni précédemment.
```java
public class Main {
public static void main(String[] args) {
try {
GestionImmobiliere gestion = new GestionImmobiliere();
// Ajout d'appartements
Appartement app1 = new Appartement("123 Rue de Paris", 45.0, 2, true);
Appartement app2 = new Appartement("456 Rue de Lyon", 75.5, 3, true);
gestion.ajouter(app1);
gestion.ajouter(app2);
// Affichage des appartements
System.out.println("Liste des appartements :");
gestion.afficher();
// Ajout de locataires
Locataire loc1 = new Locataire(1, "Dupont", "Jean");
Locataire loc2 = new Locataire(2, "Martin", "Claire");
gestion.ajouter(loc1);
gestion.ajouter(loc2);
// Affichage des locataires
System.out.println("\nListe des locataires :");
gestion.afficher();
// Création d'un contrat de location
Date dateDebut = new Date();
Date dateFin = new Date(dateDebut.getTime() + (1000L * 60 * 60 * 24 *
365)); // +1 an
ContratLocation contrat = gestion.creerContrat(loc1, app1, dateDebut,
dateFin, 1200.0);
// Affichage du contrat
System.out.println("\nContrat de location créé :");
System.out.println("Locataire : " +
contrat.getLocataire().getFullName());
System.out.println("Appartement : " +
contrat.getAppartement().getAdresse());
System.out.println("Date de début : " + contrat.getDateDebut());
System.out.println("Date de fin : " + contrat.getDateFin());
System.out.println("Loyer mensuel : " + contrat.getLoyerMensuel());
System.out.println("État du contrat : " + contrat.getEtatContrat());
} catch (AppartementNonDisponibleException e) {
e.printStackTrace();
}
}
}
```
### Résumé des réponses :
1. **Création des classes `Appartement`, `Locataire`, `ContratLocation`** : Voir
les sections de code fournies.
2. **Implémentation de `Personne` et héritage de `Locataire`** : Voir les sections
de code fournies.
3. **Implémentation de la classe `GestionImmobiliere`** : Voir les sections de code
fournies.
4. **Création d'un contrat de location** : Voir les sections de code fournies.
5. **Classe principale `Main` pour tester les fonctionnalités** : Voir les sections
de code fournies.
Avec cette mise en œuvre, toutes les fonctionnalités demandées dans l'exercice sont
couvertes et les spécifications respectées.
