:: Enseignements :: Licence :: L3 :: 2024-2025 :: Programmation Objet avec Java ::

Revision

Ce TP est à faire seul, un peu dans les conditions d'un examen. Bien sûr, cela reste un TP, donc n'hésitez pas à appeler le chargé de TP si vous êtes bloqué.

Pour les exercices 2 et 3, vous devez savoir répondre à ces questions sans avoir besoin d'un ordinateur.

Exercice 1 - Problème

On souhaite créer des objets permettant de représenter des voitures. Toutes les classes seront écrites dans un package fr.uge.rental. On écrira une méthode main dans une classe Main pour faire les tests.

Une voiture (Car) est définie par un modèle (une chaîne de caractères model) ainsi qu’une année de fabrication year. De plus, elle peut être tout-terrain ou non (booléen offRoad). Indiquer le code de Car.

Ajouter un constructeur ne prenant en paramètre que le modèle et l’année pour créer des voitures qui ne sont pas tout-terrain par défaut.

Ajouter de quoi afficher une voiture de la façon suivante :

  var mustang = new Car("Ford Mustang", 2014);
  System.out.println(mustang);
  // Car Ford Mustang, 2014 model (off-road: no)
  var beetle = new Car("Coccinelle", 1985, true);
  System.out.println(beetle);
  // Car Coccinelle, 1985 model (off-road: yes)
 ...

Attention à bien avoir exactement le même affichage !

Écrire une classe Rental qui représente une agence de location de voitures et qui stocke les voitures qui peuvent être louées dans une liste, qui peut être modifiée. Une voiture pourra figurer plusieurs fois dans la liste. De plus, l'agence est créé avec une année courante (currentYear) non modifiable.
Ajouter ce qu’il faut pour pouvoir créer un Rental à partir de l’année courante.
```
          ...
          var rental = new Rental(2023);
          ...
        
```

Écrire une méthode add qui permet d’ajouter une voiture à l’agence.

    ...
    var ds = new Car("Citroen DS", 1970);
    rental.add(mustang);
    rental.add(beetle);
    rental.add(ds);
    ...

Ajouter de quoi afficher l’agence avec l’année courante suivie de double tirets puis toutes les voitures qu’elle peut louer, séparées par des tirets. L’implantation doit utiliser un stream.

    ...
    System.out.println(rental);
    // Rental (2023)
    // =====
    // Car Ford Mustang, 2014 model (off-road: no)
    // -----
    // Car Coccinelle, 1985 model (off-road: yes)
    // -----
    // Car Citroen DS, 1970 model (off-road: no)
    ...

Attention à bien avoir exactement le même affichage !

Le coût d’entretien d’une voiture dépend de son année de fabrication. Plus elle est récente plus elle coûte cher :
- Le coût d’entretien de base est de 100 euros.
- Si la voiture a été fabriquée après 2000, on ajoute 10 euros de plus par année après 2000 (+ 10 euros si elle est fabriquée en 2001, + 20 euros en 2002, ...).
- De plus, si la voiture est tout-terrain, on ajoute 50 euros.
Par exemple, la Ford mustang a un coût d’entretien de 240 euros et la Coccinelle, un coût de 150 euros. Écrire une méthode careCost permettant de calculer le coût d’entretien d’une voiture.
```
    ...
    System.out.println(mustang.careCost());
    // 240
    System.out.println(beetle.careCost());
    // 150
    ...
        
```

Écrire une méthode totalCareCost permettant de calculer le coût total d’entretien des voitures que possède une agence de location. L’implantation doit utiliser un stream.
```
    System.out.println(rental.totalCareCost());
    // 490
        
```

Pour attirer plus de clients, une agence de location peut désormais proposer des limousines (Limousine) qui possède les caractéristiques suivantes (model, year, ainsi qu'un nombre de places (nbSeats).
```
    ...
    var limo = new Limousine("Cadillac", 2012, 13);
    ...
        
```

Les limousines ont un coût d’entretien de 600 euros plus, si la limousine a été fabriquée après 2000, 10 euros de plus par année après 2000. Écrire une méthode pour calculer le coût d’entretien d’une limousine.
```
    ...
    System.out.println(limo.careCost());
    // 720
    ...
        
```

Ajouter de quoi afficher une limousine ainsi :

    ...
    System.out.println(limo);
    // Limousine Cadillac, 2012 model, number of seats: 13
    ...

Attention à bien avoir exactement le même affichage !

On souhaite pouvoir ajouter une limousine dans la liste des véhicules d’une agence. Modifier le code pour que Rental continue de fonctionner correctement. L’implantation de totalCareCost doit toujours utiliser un stream.
```
    ...
    rental.add(limo);
    System.out.println(rental.totalCareCost());
    ...
        
```

Dans le but d'établir un inventaire, on souhaite pouvoir compter tous les véhicules en fonction de leur année. Pour cela, on va écrire la méthode countInYears(function) avec function une fonction qui prend en paramètre une année et indique si oui ou non le véhicule qui a cette année doit être compté.
Voici un exemple d'utilisation
```
    ...
    System.out.println(rental.countInYears(year -> year >= 1950 && year <= 2000));
    // 2
    ...
       
```
Attention de bien typé correctement la fonction prise en paramètre de countInYears(function).

Toujours pour attirer les clients, l’agence souhaite éditer une brochure publicitaire où elle fera figurer ses véhicules les plus intéressants par catégorie:
- tous les véhicules de moins de 20 ans (par rapport à l’année courante de Rental),
- tous les véhicules dont le modèle commence par "Ford"
Écrire une méthode allNice(category) qui renvoie la liste non modifiable de tous les véhicules que l’agence de cette catégorie. Pour modéliser différentes les categories, on va utiliser un enum. L’implantation de allNice(category) doit utiliser un stream.
Voici un exemple d’utilisation de cette méthode :
```
    System.out.println(rental.allNice(Category.LESS_THAN_20_YEARS));
    // [Car Ford Mustang, 2014 model (off-road: no), Limousine Cadillac, 2012 model, number of seats: 13]
    System.out.println(rental.allNice(Category.ALL_FORD));
    // [Car Ford Mustang, 2014 model (off-road: no)]
        
```

Pour que la brochure soit encore plus attrayante, on ajoute les catégories
- tous les véhicules tout-terrain (les limousines ne sont pas tout-terrain),
- toutes les limousines de plus de 12 places.
Voici un exemple d’utilisation
```
    System.out.println(rental.allNice(Category.OFF_ROAD));
    // [Car Coccinelle, 1985 model (off-road: yes)]
    System.out.println(rental.allNice(Category.BIG_LIMO));
    // [Limousine Cadillac, 2012 model, number of seats: 13]
       
```
Ajouter les deux nouvelles catégories à l'enum et faite les changements correspondants sachant que l'on vous demande de ne pas utiliser le polymorphisme (et pas de instanceof bien sûr).
Note: si vous n'arrivez pas à faire cette question, passez à la suite !

L’agence souhaite maintenant disposer d’un accès rapide à tous les véhicules qui ont la même année de fabrication. Écrire une méthode vehiclesByYear qui renvoie une map associant à chaque année de fabrication la liste des véhicules (voitures ou limousines) qui ont cette année de fabrication. On doit utiliser des stream.
```
    ...
    System.out.println(rental.vehiclesByYear());
    // {1985=[Car Coccinelle, 1985 model (off-road: yes)], 1970=[Car Citroen DS, 1970 model (off-road: no)], 2012=[Limousine Cadillac, 2012 model, number of seats: 13], 2014=[Car Ford Mustang, 2014 model (off-road: no)]}
            ...
        
```

L’agence souhaite aussi disposer d’un accès rapide à toutes les voitures (les Car) qui ont la même année de fabrication. Écrire une méthode carsByYear qui renvoie une map associant à chaque année de fabrication une liste de véhicules qui contient (uniquement les voitures (pas les limousines) qui ont cette année de fabrication. On doit utiliser des stream.
```
      ...
      System.out.println(rental.carsByYear());
       // {1985=[Car Coccinelle, 1985 model (off-road: yes)], 1970=[Car Citroen DS, 1970 model (off-road: no)], 2014=[Car Ford Mustang, 2014 model (off-road: no)]}
        ...
        
```

Enfin, pour les plus balèzes, dans le but de simplifier le code de la méthode allNice(category) et écrire une nouvelle méthode allNice(function) tel que le code ci-dessous fonctionne, puis simplifier le code de la méthode allNice(category).

     ...
     System.out.println(rental.allNice(_ -> true));
     // [Car Ford Mustang, 2014 model (off-road: no), Car Coccinelle, 1985 model (off-road: yes), Car Citroen DS, 1970 model (off-road: no), Limousine Cadillac, 2012 model, number of seats: 13]

Exercice 2 - Interfaces fonctionnelles ?

Quelle est le nom de l’interface fonctionnelle qui prend une String et renvoie un boolean ? Écrire un exemple de code créant une lambda qui prend paramètre une String et renvoie true si la chaîne de caractères commence par "toto”.

Quelle est le nom de l’interface fonctionnelle qui prend un int et renvoie un int ? Écrire un exemple de code créant une lambda qui prend paramètre un int et renvoie la valeur de cet int au carré. Écrire le même code, mais en utilisant une méthode référence à la place de la lambda.

Quelle est l’interface fonctionnelle qui ne prend rien en entrée et renvoie void ? Écrire un exemple de code créant une lambda qui affiche sur la sortie standard "coucou". Écrire le code qui permet d’exécuter le code de la lambda.

Exercice 3 - Redéfinition ou surcharge ?

Dans les codes ci-dessous chaque classe ou interface est dans un fichier de même nom.

Le code suivant compile-t-il, si non pourquoi ? Si oui, y a t’il redéfinition ou surcharge entre les méthodes toto ?

public interface I {
  I toto(int i);
}
public class A implements I {
  A toto(int i) {
    return new A();
  }
}

Le code suivant compile-t-il, si non pourquoi ? Si oui, y a t’il redéfinition ou surcharge entre les méthodes toto ?

interface I {
  I toto(int i);
}
public class B implements I {
  public B toto(int i) {
    return new B();
  }
}

Le code suivant compile-t-il, si non pourquoi ? Si oui, y a t’il redéfinition ou surcharge entre les méthodes toto ?

public class C {
  C toto(C i) {
    return new C();
  }
}
public class D extends C {
  C toto(D i) {
    return new D();
  }
}