Avant de commencer
Dans ce premier TP, l’objectif est de nous permettre d’évaluer votre capacité à produire du code de qualité. Dans la première partie, les exercices à effectuer ne nécessitent pas de mettre en place une organisation particulière du code, si ce n’est de créer les classes correspondantes dans des packages. Pour ces exercices, vous ne mettrez pas non plus en place de tests unitaires, cela viendra dans la deuxième partie. Mais durant toute cette séance, vous appliquerez la consigne suivante :
PAS DE MOTEUR DE RECHERCHE / PAS D'IA (MÊME DANS L'IDE) / PAS DE STACKOVERFLOW...
LA SEULE PAGE AUTORISÉE EST : https://docs.oracle.com/en/java/javase/21/docs/api
Première partie
Exercice 1:
Ecrire un programme nommé HexadecimalToIntegerConverter qui affiche la valeur d'un nombre hexadécimal passé en paramètre. Le programme ne doit pas être sensible à la casse : 1a est un nombre valide. De plus, le programme doit vérifier que le nombre passé en argument est bien un nombre hexadécimal et le signaler à l'utilisateur dans le cas contraire. Un message est aussi affiché dans le cas où le nombre d'arguments est incorrect.
Exemples:
> java HexadecimalToIntegerConverter a
10
> java HexadecimalToIntegerConverter G
Erreur: G n'est pas un nombre hexadécimal.
> java HexadecimalToIntegerConverter B5
181
Exercice 2:
Écrire un programme qui crée un tableau d'entier de taille 100 initialisé avec les vingt premiers indexes à 0, les 60 suivants à 2 et les 20 derniers à 8. Ensuite le programme doit afficher le tableau avec le formatage précis suivant : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
Exercice 3:
Écrire un programme nommé FindDuplicatesInPhrase qui, pour un ensemble de mots passés en paramètre, affiche
- les mots qui ne sont pas répétés
- les mots qui sont répétés
- le nombre d’apparitions des mots répétés
Le tout en respectant l'ordre alphanumérique : chiffre > majuscule > minuscule
Exemple que vous devez pouvoir reproduire :
> java FindDuplicatesInPhrase I came I saw I left and came back
> In the phrase : I came I saw I left and came back
Unique words: [and, back, left, saw]
Duplicate words: [I, came]
"I" appears 3 times
"came" appears 2 times
Deuxième partie : TDD
Dans cette partie, vous allez mettre en place un développement dirigé par les tests. Le principe repose sur l’idée qu’il faut d’abord écrire les tests, puis implémenter le code de production. Dans cet esprit, il faut procéder comme indiqué sur la figure suivante :
Dans la pratique, comme les IDE ne compileront pas votre test s'ils ne trouvent pas la méthode correspondante dans la classe à tester, il faut d'abord implémenter les signatures correspondant aux spécifications dans la classe que vous voulez tester, puis immédiatement écrire le tests correspondants : ils doivent échouer car les corps des méthodes du code de production sont vides !
Exercice 4:
Prenons l’exemple d’une classe modélisant une personne et qui possède les caractéristiques suivantes : un nom, un prénom, une date de naissance, un sexe. En outre, tous les attributs d’une personne ne peuvent être modifiés une fois l’instance créée, sauf pour le nom de famille qui peut changer (mariage). On a en plus une méthode qui renvoie l'âge de la personne (calcul effectué par rapport à la date d'aujourd'hui).
La première des choses est d’écrire les tests liés au constructeur de la classe. Ainsi, une fois la classe Person créée, vous ajoutez simplement le constructeur adéquat qui compte 4 arguments.
Nous pouvons maintenant écrire les tests. Le client souhaite :
- qu’il soit impossible d’avoir des personnes qui ont plus de 130 ans au moment de la création, ou avec une date de naissance qui est dans le futur.
- le prénom et le nom doivent être absolument renseignés, et avoir un minimum de deux caractères.
Pour ce qui est des tests unitaires, n’oubliez pas qu’ils doivent tester une chose et une seule (un seul assert en première approche), autrement dit les spécifications précédentes nécessitent d’écrire beaucoup plus qu’un seul test avant de commencer le code de production. À vous de les trouver.
Toisième partie
Exercice 5:
Sans forcément appliquer le TDD, écrivez le code correspondant aux spécifications suivantes :
On veut modéliser une entreprise. Elle fonctionne avec un ensemble d'employés qui sont des personnes (utilisez la calsse précédente dans votre code). Tous les employés ont une base salariale identique, fixée par l'entreprise et modulée en fonction de leur position dans l'entreprise. Il existe en effet deux types d'employés : des employés internes qui possède un identifiant unique au sein de l'entreprise, et des employés externes à l'entreprise.
Le PDG souhaite que le comptable calcule les salaires de la manière suivante : base*1.2 et base*1.1 pour les externes.
La classe entreprise doit permettre :
- d'ajouter un nouvel employé à l'entreprise, uniquement s'il a plus de 18 ans et moins de 60 ans (calcul effectué par rapport à la date d'aujourd'hui).
- de calculer la masse salariale mensuelle totale
- d'afficher le prochain départ à la retraite (fixée à 60 ans) : qui et quand.
- de renvoyer la liste des salariés ayant un âge situé entre 30 et 40 ans
Exercice 6:
On veut maintenant pouvoir ajouter un nouveau type d'employé : expert externe avec un salaire calculé comme suit : base*2
Exercice 7:
Refactorez pour que votre code soit le plus propre possible.