{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b7c9c9ec-e954-46b9-bfc5-f967f9a44fd0",
   "metadata": {},
   "source": [
    "---\n",
    "title: TP - Bases de Java\n",
    "description: Pratique de base du langage Java.\n",
    "categories: \n",
    "  - Java\n",
    "  - I111\n",
    "  - PO43\n",
    "  - Exercices\n",
    "provide_notes: true\n",
    "provide_slides: false \n",
    "jupyter: java \n",
    "--- "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f6bb3ae-61c7-40f6-aa4f-bb74b2caa14d",
   "metadata": {},
   "source": [
    "## Création et instanciation d’une classe\n",
    "\n",
    "1. **Créer une classe Java exécutable nommée `Test`** qui appartient au paquetage `tp1`. Ajouter un prefixe de packages unique. La classe `Test` devra afficher “Hello”.\n",
    "\n",
    "2. **Créer une classe `Personne`** sans constructeur explicite qui décrit une personne ayant un nom, un prénom, un âge et un salaire. Créer les accesseurs et modificateurs correspondants à ces attributs (l’IDE peut le faire automatiquement). Vous vérifierez qu’un salaire ne peut pas être négatif. Instancier une personne `p1` dans la méthode `main` de la classe `Test`, puis mettre à jour ses informations et les afficher (Pierre Truc est âgé de 30 ans et gagne 2000€).\n",
    "\n",
    "4. **Ajouter des constructeurs dans la classe `Personne`** qui initialisent le nom et le prénom, l’âge et la profession. Les deux derniers sont optionnels. Modifier cette classe pour que le nom et le prénom ne puissent plus être modifiés après l’instanciation.\n",
    "\n",
    "5. **Ajouter un attribut qui indique l’année de naissance** et les accesseurs associés. Modifier la méthode qui retourne l’âge. L’année courante s’obtient avec `java.util.Calendar.getInstance().get(Calendar.YEAR)`.\n",
    "\n",
    "6. **Ajouter une méthode `comparerSalaire()`** qui prend en paramètre une personne et retourne -1, 0 ou 1 selon que celle-ci a un salaire supérieur, égal ou inférieur à l’instance courante. Créer une deuxième personne `p2` née la même année que `p1` mais qui gagne plus. Afficher le résultat de la comparaison des salaires de `p1` et `p2`.\n",
    "\n",
    "7. **Ajouter une méthode `comparerSalaire()`** qui prend en paramètre deux personnes et qui retourne un nombre négatif, nul ou positif selon que le salaire de la première est inférieur, égal ou supérieur à celui de la seconde.\n",
    "\n",
    "8. **Attention**, `comparerSalaire(Personne)` et `comparerSalaire(Personne, Personne)` sont-elles des méthodes de classe ou d’instance ?\n",
    "\n",
    "9. **Ajouter un attribut de classe `totalDesSalaires`** qui indique le total des salaires des personnes et un accesseur. Modifier les méthodes nécessaires pour que le salaire total soit maintenu à jour automatiquement. Est-ce risqué d'écrire simplement une telle méthode ?\n",
    "\n",
    "10. **Afficher le salaire total** après la création de chaque personne.\n",
    "\n",
    "## Les méthodes de base\n",
    "\n",
    "### toString()\n",
    "\n",
    "- Afficher directement l’objet `p1` dans la classe `Test`. \n",
    "- Ajouter une méthode `String toString()` à la classe `Personne` qui retourne une chaîne de caractères qui décrit la personne. \n",
    "- Exécuter `Test`.\n",
    "\n",
    "### equals()\n",
    "\n",
    "- On souhaite considérer que deux personnes sont “égales” dans notre application, si elles sont nées la même année. \n",
    "- Pour définir une relation d’égalité d’objets en Java, on redéfinit la méthode `boolean equals(Object)`. \n",
    "- Vérifier que `p1` et `p2` sont égales.\n",
    "\n",
    "## Définition de classes locales\n",
    "\n",
    "- Pour représenter le fait qu’une `Personne` a un cerveau, ajouter une définition de la classe `Cerveau` à l’intérieur de la définition de la classe `Personne`. \n",
    "- Ajouter un attribut `cerveau` à `Personne` et instancier un cerveau à chaque personne lors de sa création. \n",
    "- Compiler et exécuter `Test`. \n",
    "- Regarder dans le répertoire build les classes qui ont été compilées. \n",
    "- Essayer de créer une instance de `Cerveau` directement dans la classe `Test`.\n",
    "\n",
    "## Pour finir...\n",
    "\n",
    "Vous allez maintenant créer une classe `Entreprise` qui permet de représenter des entreprises qui comportent au maximum `MAX_EMPLOYES` personnes.\n",
    "\n",
    "1. **Ajouter les méthodes** pour créer une entreprise, ajouter des employés et afficher le nombre d’employés, un employé précis et tous les employés (en utilisant le `foreach`).\n",
    "\n",
    "2. **Catégoriser les entreprises** : Les entreprises doivent appartenir à l’une des trois catégories suivantes : `{PUBLIQUE, PME, GRAND GROUPE}`. Modifier la classe `Entreprise` pour représenter cela en utilisant un type `enum` et ajouter trois méthodes `isPUBLIQUE()`, `isPME()`, `isGRAND_GROUPE()` qui retournent un booléen.\n",
    "\n",
    "3. **Ajouter une méthode `miseEnForme()`** qui passe le nom de toutes les personnes d’une entreprise en majuscule.\n",
    "\n",
    "4. **Modifier votre classe `Test`**, pour qu’on puisse lui passer en paramètre le nom et le type d’une entreprise, puis la liste des personnes qui la composent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "859c39a5-e1f8-4613-bd4a-e73fd4ca38bb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e95cf58f-4f85-457e-b64e-7fef2f4ad832",
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "java",
   "language": "java",
   "name": "java",
   "path": "/opt/conda/share/jupyter/kernels/java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "21.0.4+7-LTS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}