{
"cells": [
{
"cell_type": "markdown",
"id": "087022f5-56f1-4088-8c08-604a3fddba0c",
"metadata": {},
"source": [
"---\n",
"title: Réutilisation et Héritage en Java\n",
"description: Ecrire des programmes réutilisable et maintenable en Java\n",
"notebook-links: false\n",
"categories: \n",
" - Java\n",
" - I111\n",
" - PO43\n",
" - Lecture\n",
"provide_notes: true\n",
"provide_slides: true\n",
"jupyter: java\n",
"echo: true\n",
"output: true\n",
"--- "
]
},
{
"cell_type": "markdown",
"id": "a1a50cba-d141-4d10-bffb-9cb7e60c84c8",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "a73a0ae3-abe6-4b97-84ba-e4ac556ae4a4",
"metadata": {},
"source": [
"## Pourquoi réutiliser ?\n"
]
},
{
"cell_type": "markdown",
"id": "8b9fd566",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- Structuration efficace grâce au paradigme objet.\n",
"- Réutilisation et partage des composants pour la conception et le développement.\n",
"- Extension des fonctionnalités existantes.\n",
"- Accélération du développement et simplification de la maintenance.\n",
"- Nécessite une planification et une conception initiales plus poussées.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "53c85cf6",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"L'utilisation du paradigme objet permet une structuration efficace des applications, facilitant ainsi la réutilisation et le partage des composants au sein des projets de conception et de développement. Ce paradigme favorise également l'extension des fonctionnalités existantes, accélérant le développement et simplifiant la maintenance des logiciels. Cependant, cette approche requiert une planification et une conception initiales plus poussées pour tirer pleinement parti de ses avantages.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "7df33f7a",
"metadata": {},
"source": [
"\n",
"## UML et Java\n"
]
},
{
"cell_type": "markdown",
"id": "5ab7f1a4",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
" * Dans cette partie nous nous limiterons aux modèles UML structurels dédiés aux aspects statiques des objets\n",
" * Les diagrammes de classe\n",
" * Les diagrammes d’instance\n",
" * Nous examinerons en parallèle l’implantation possible en Java\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "05500beb",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Dans cette partie, nous nous concentrerons sur les modèles UML structurels qui décrivent les aspects statiques des objets. Nous aborderons principalement deux types de diagrammes : les diagrammes de classes et les diagrammes d’instances. Les diagrammes de classes illustrent les relations et la structure entre différentes classes, tandis que les diagrammes d’instances montrent les objets concrets et leurs relations à un moment donné. Parallèlement, nous examinerons comment ces concepts peuvent être implémentés en Java, en offrant une compréhension pratique de la transition des modèles théoriques UML vers le code concret.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "9f755340-ceeb-486e-8e24-c7deb123b698",
"metadata": {},
"source": [
"## Association UML\n",
"\n",
":::: {.columns}\n",
"\n",
"::: {.column width=\"50%\"}\n"
]
},
{
"cell_type": "markdown",
"id": "092a1625",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- En analyse, un attribut ne peut pas être une classe.\n",
"- L'association définit une relation entre deux classes.\n",
"- Elle est caractérisée par un nom, une cardinalité et éventuellement des rôles.\n",
"- En Java, une association est souvent implémentée en utilisant des références entre objets dans les classes concernées, permettant ainsi de modéliser les relations entre instances.\n",
":::\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "59563415",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En analyse, un attribut ne peut pas être une classe. L'association, en revanche, définit une relation entre deux classes, caractérisée par un nom, une cardinalité et éventuellement des rôles. En Java, une association est souvent implémentée en utilisant des références entre objets dans les classes concernées. Cela permet de modéliser les relations entre instances, offrant ainsi une représentation fidèle des interactions et des dépendances entre les différentes entités du système.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "767733a9",
"metadata": {},
"source": [
"\n",
":::\n",
"\n",
"::: {.column width=\"50%\"}\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "e0a93228-8268-433a-8c73-1b4029666dbc",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"//| label: fig-uml-association\n",
"//| fig-cap: \"Une Personne possede un Chien\"\n",
"//| fig-format: svg\n",
"// PRINT SCHEMA\n",
"String script=\"\"\"\n",
"@startuml\n",
"\n",
"Chien \"compagnon *\" -- \"maitre 1\" Personne : < possede\n",
" \n",
"@enduml\"\"\";\n",
" \n",
"\n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n",
"return null; "
]
},
{
"cell_type": "markdown",
"id": "23a89dde-c7ad-41d8-9d8a-7a8078f046d7",
"metadata": {},
"source": [
":::\n",
"\n",
"::::"
]
},
{
"cell_type": "markdown",
"id": "1ec9c0b5-9cdf-4dd1-8f7a-77ebc959394a",
"metadata": {},
"source": [
"## L’aggrégation en Java\n",
"\n",
":::: {.columns}\n",
"\n",
"::: {.column width=\"50%\"}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5f71f2cd",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"* Les associations en Java se matérialisent par des attributs d'instance.\n",
"* Pour une cardinalité déterminée (n..m), un tableau peut être utilisé.\n",
" * Généralement, les Collections sont préférées pour plus de flexibilité.\n",
"* Les contraintes UML telles qu'ordonné, exclusif, sous-ensemble, etc., doivent être vérifiées par le programme.\n",
":::\n",
"\n",
"\n",
" \n"
]
},
{
"cell_type": "markdown",
"id": "895486f1",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En Java, les associations entre objets sont représentées à l'aide d'attributs d'instance. Lorsque la cardinalité est déterminée, par exemple n..m, un tableau peut être utilisé pour modéliser la relation. Cependant, pour une flexibilité accrue, il est généralement recommandé d'utiliser des Collections. De plus, les contraintes exprimées dans le modèle UML, telles que l'ordre, l'exclusivité ou les sous-ensembles, doivent être rigoureusement vérifiées par le programme pour garantir la cohérence des relations entre les instances.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "222bd03b",
"metadata": {},
"source": [
"::: \n",
"\n",
"::: {.column width=\"50%\"} "
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "d1b56194-c9d4-49ee-9ed4-192bbee160e8",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"//| label: fig-uml-aggregation\n",
"//| fig-cap: \"Un Employe est membre d'un Département\"\n",
"// PRINT SCHEMA\n",
"String script=\"\"\"\n",
"@startuml\n",
"\n",
"Employe \"membre *\" <-- \"1\" Departement\n",
"Employe \"directeur 0..1\" <-- \"1\" Departement\n",
" \n",
"@enduml\"\"\";\n",
" \n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n",
"return null; "
]
},
{
"cell_type": "markdown",
"id": "00c921cf-4a38-409a-81a8-40fcffe8820e",
"metadata": {},
"source": [
":::\n",
"\n",
"::::"
]
},
{
"cell_type": "markdown",
"id": "8ca6fc60-d2dc-4a9e-b51c-7c9ddffd5d34",
"metadata": {},
"source": [
"## La délégation"
]
},
{
"cell_type": "markdown",
"id": "7c363649",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"- La délégation est une solution de réutilisation en programmation orientée objet.\n",
"- Une classe ou une instance peut :\n",
" - Appeler une méthode d’une autre classe.\n",
" - Instancier un objet d’une autre classe et lui \"déléguer\" des traitements.\n",
"- Cela permet à une classe (`C1`) d'utiliser les fonctionnalités d'une autre classe (`C2`) sans hériter de ses méthodes ou attributs.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "7a5244eb",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"La délégation est une solution efficace de réutilisation en programmation orientée objet. Elle permet à une classe ou une instance d’appeler une méthode d’une autre classe ou d’instancier un objet d’une autre classe pour lui déléguer des traitements spécifiques. Cela signifie qu'une classe (`C1`) peut utiliser les fonctionnalités d'une autre classe (`C2`) sans hériter de ses méthodes ou attributs, offrant ainsi une flexibilité accrue dans la conception du code et la réutilisation des fonctionnalités.\n",
":::"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "0ed8e11a-5ce4-4f43-a61e-bee661e82bba",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"//| label: fig-uml-delegation\n",
"//| fig-cap: \"Un Comptable delegue a un Calculateur\"\n",
"// PRINT SCHEMA\n",
"String script=\"\"\"\n",
"@startuml\n",
"class Calculateur {\n",
" int add(int[])\n",
"} \n",
"class Comptable{\n",
" int calculerBilan(int[])\n",
"}\n",
" \n",
"Calculateur -left- Comptable : < owns\n",
"@enduml\"\"\"; \n",
"\n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n",
"return null; "
]
},
{
"cell_type": "markdown",
"id": "843bab63-9704-4e4c-9242-7e1fba095ffc",
"metadata": {},
"source": [
"## Exemple de délégation"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "e8510b19-e40e-4815-93e3-9f566bd68a6d",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"data": {
"text/plain": [
"REPL.$JShell$64$Calculateur@7e1275bb"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"//| echo: true\n",
"\n",
"public class Calculateur {\n",
" public int add(final int... valeurs) {\n",
" int somme=0;\n",
" for (int valeur:valeurs) somme+=valeur;\n",
" return somme;\n",
" }\n",
"}\n",
"\n",
"new Calculateur();"
]
},
{
"cell_type": "markdown",
"id": "bcd32e19-c17c-4e01-bec8-8d84c13bd215",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "7fa307f8-6b46-4028-8f66-660ccd8757d8",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"//| code-line-numbers: 2\n",
"\n",
"public class Comptable {\n",
" private Calculateur calculateur = new Calculateur();\n",
" \n",
" public void calculerBilan(int... depenses) {\n",
" System.out.println(\n",
" String.format(\"Dépenses: %d\", calculateur.add(depenses))\n",
" );\n",
" }\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "1aa012a4-ea43-4fd4-acea-6b7f5fc0a2fc",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dépenses: 80\n"
]
}
],
"source": [
"//| echo: true\n",
"//| output-location: fragment\n",
"new Comptable().calculerBilan(12,23,45);"
]
},
{
"cell_type": "markdown",
"id": "cb1e2c08-d104-4dce-a597-0469af3f1049",
"metadata": {},
"source": [
"## Implémentation de la Navigabilité UML en Java"
]
},
{
"cell_type": "markdown",
"id": "f239b48a",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Utilisation des Attributs et Accesseurs :** Les relations entre objets sont représentées par des attributs avec des accesseurs (getters/setters) pour obtenir et modifier les valeurs.\n",
" \n",
"- **Associations Bidirectionnelles :** Éviter les associations bi-directionnelles complexes pour limiter la complexité et maintenir la cohérence des données.\n",
"\n",
"- **Maintien de la Cohérence :** Assurer la synchronisation des données entre objets liés pour éviter les erreurs et les incohérences.\n",
"\n",
"- **Complexité des Associations :** Les associations bidirectionnelles ajoutent de la complexité et de la maintenance au code.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "707efbe7",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"notes\"}\n",
"La navigabilité en Java se matérialise principalement par l'utilisation d'attributs et d'accesseurs. Les relations entre objets sont représentées par des attributs dans les classes concernées, avec des méthodes d'accès (getters et setters) pour obtenir et modifier les valeurs de ces attributs. \n",
"\n",
"Il est crucial d'être prudent avec les associations bidirectionnelles. Bien que parfois nécessaires, elles ajoutent une couche de complexité supplémentaire et peuvent rendre la maintenance du code plus difficile. Les associations bidirectionnelles doivent être soigneusement gérées pour éviter les incohérences et les problèmes de synchronisation des données. \n",
"\n",
"Bien que les associations bidirectionnelles puissent être utiles, leur utilisation doit être limitée et bien gérée pour éviter d'ajouter une complexité excessive au système. Il est souvent préférable de simplifier les relations entre objets et d'utiliser des associations unidirectionnelles lorsque cela est possible pour maintenir un code propre et facile à maintenir.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "4b07a85b",
"metadata": {},
"source": [
"\n",
"## L’aggrégation et la composition en Java\n"
]
},
{
"cell_type": "markdown",
"id": "35a3c494",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"* L'agrégation par rapport à la composition est principalement sémantique.\n",
" * La composition impose une contrainte de co-existence : la destruction de l'objet composé entraîne la destruction de ses composants.\n",
" * De plus, la destruction d'un composant ne peut être autorisée sans s'assurer de la destruction préalable de l'objet composé.\n",
"* En Java, cette gestion est confiée au garbage collector, mais il est crucial d'éviter les références inutiles.\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "6a1eeed9",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"L'agrégation et la composition en programmation orientée objet présentent des distinctions importantes. L'agrégation permet à un objet de contenir d'autres objets qui peuvent également exister indépendamment. Par exemple, une classe \"Équipe\" peut agréger plusieurs objets \"Membre\", où chaque membre peut appartenir à plusieurs équipes. En revanche, la composition est une relation plus forte où un objet est composé d'autres objets qui n'existent que dans le contexte de cet objet composite. Par exemple, une classe \"Voiture\" est composée d'objets comme \"Moteur\", \"Roues\" et \"Carrosserie\", et leur durée de vie est liée à celle de la voiture elle-même. Techniquement, en Java on utilise le garbage collector pour détruire les objets non référencés, mais il est crucial de gérer soigneusement les relations pour éviter les références inutiles.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "e3cbcb3d-c80f-43ea-9e57-64c529503877",
"metadata": {},
"source": [
"## L’héritage en Java"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "60ede15e-5d8a-45ad-8a12-5fba96d9c709",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"//| label: fig-uml-heritage\n",
"//| fig-cap: \"Un Vélo electrique est un Vélo\"\n",
"// PRINT SCHEMA\n",
"String script=\"\"\"\n",
"@startuml\n",
"Velo <|-right- VeloElectrique\n",
"@enduml\"\"\"; \n",
"\n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n",
"return null; "
]
},
{
"cell_type": "markdown",
"id": "c0390d1f-cb0f-48f3-92a2-9c3150173452",
"metadata": {},
"source": [
" * On indique que la classe fille étend la classe mère : `extends`"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c466ab1d-fc63-415a-842e-ef32d7ec11de",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"public class Velo {\n",
" protected final String nom;\n",
" public Velo(String nom) {this.nom = nom;}\n",
" public void avancer() {\n",
" System.out.println(\n",
" String.format(\"%s avance.\",nom));\n",
" }\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "dbe5eeb3-fc05-47d9-83be-f68cec8fe206",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "272754cc-0d98-4dfa-9e2c-68a546d2757e",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"public class VeloElectrique extends Velo {\n",
" /* Augmentation de l’état interne */\n",
" private boolean etatDuMoteur = false; \n",
" public VeloElectrique(String nom) {super(nom);}; \n",
" public void avancer() {\n",
" System.out.println(\n",
" String.format(\"%s avance %s assistance.\",\n",
" nom,etatDuMoteur?\"avec\":\"sans\"));\n",
" }\n",
" /* Nouveau comportement */\n",
" public void inverserMoteur() {etatDuMoteur=!etatDuMoteur;} \n",
"}"
]
},
{
"cell_type": "markdown",
"id": "c7cf7130-c0a2-42dd-99fc-3b88c1826d3c",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "5d34eead-aa33-435f-8db2-9484b36c0ca6",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"V1 avance.\n",
"V2 avance avec assistance.\n",
"V3 avance sans assistance.\n"
]
}
],
"source": [
"//| echo: true\n",
"Velo velo1 = new Velo(\"V1\");\n",
"velo1.avancer();\n",
"\n",
"VeloElectrique velo2 = new VeloElectrique(\"V2\");\n",
"velo2.inverserMoteur();\n",
"velo2.avancer();\n",
"\n",
"Velo velo3 = new VeloElectrique(\"V3\");\n",
"//velo3.inverserMoteur(); //Expliquer \n",
"velo3.avancer();"
]
},
{
"cell_type": "markdown",
"id": "ea224ad7-0a14-46fc-9f14-9b264affcc6f",
"metadata": {},
"source": [
"---\n"
]
},
{
"cell_type": "markdown",
"id": "829ad51f",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"* Si `extends` n’est pas précisé, la classe hérite implicitement de la classe `Object`.\n",
"* L'héritage multiple est interdit en Java.\n",
"* Dans une classe fille, il est possible de :\n",
" * Ajouter des variables, des méthodes et des constructeurs.\n",
" * **Redéfinir** ou **surcharger** des méthodes.\n",
":::\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "fe6196ab",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En Java, la gestion de l'héritage est fondamentale pour organiser et structurer les classes de manière hiérarchique. Lorsqu'une classe hérite d'une autre classe, elle acquiert toutes les variables et méthodes publiques et protégées de cette classe parente. Si aucune classe parente n'est spécifiée avec `extends`, la classe fille hérite automatiquement de la classe `Object`, qui est la racine de toutes les classes Java.\n",
"\n",
"Contrairement à certains langages de programmation qui permettent l'héritage multiple, Java restreint cette possibilité pour éviter les ambiguïtés et les conflits potentiels entre les méthodes et attributs hérités de différentes classes parentes. Ainsi, une classe Java ne peut hériter que d'une seule classe parente à la fois, garantissant ainsi une structure hiérarchique claire et évitant les complications liées à l'héritage multiple.\n",
"\n",
"Dans une classe fille en Java, il est possible d'enrichir l'héritage en ajoutant de nouvelles variables d'instance, méthodes, et même des constructeurs supplémentaires. Cela permet à la classe fille d'étendre les fonctionnalités de sa classe parente tout en maintenant la cohérence et la relation sémantique entre les deux. De plus, Java permet à une classe fille de redéfinir les méthodes héritées de sa classe parente. Ce processus, appelé redéfinition de méthode, permet à la classe fille de fournir une implémentation spécifique d'une méthode héritée pour adapter son comportement à des besoins particuliers, tout en respectant la signature de la méthode définie dans la classe parente.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "ae9f71ce",
"metadata": {},
"source": [
"\n",
"::: {#def-redefinition}\n",
"\n",
"La redéfinition d’une méthode consiste à définir une méthode ayant la même signature qu'une méthode définie dans une classe ancêtre.\n",
"\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "a91937ea-ca5a-475a-b335-bb4660c3f8ac",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "130ebaeb-92ad-452c-a9b3-b97edae16289",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"public class A {\n",
" public void m() {System.out.println(\"je suis un A.\");}\n",
"}\n",
"\n",
"public class B extends A {\n",
" public void m() {System.out.println(\"je suis un B.\");}\n",
"}\n",
"\n",
"public class C extends A {\n",
" public void m(String message) {System.out.println(\"je suis un C. \"+message);}\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "981b330c-02da-42fc-82b2-a2fa64ffb02c",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "f2d0939f-84a3-442d-b6df-34c8ede38844",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"je suis un A.\n",
"je suis un B.\n"
]
}
],
"source": [
"//| echo: true\n",
"A a1 = new A();\n",
"A a2 = new B();\n",
"A a3 = new C();\n",
"a1.m();\n",
"a2.m();"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ba913e6e-8ac5-4563-ac37-bdf0059dd79e",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"ename": "CompilationException",
"evalue": "",
"output_type": "error",
"traceback": [
"a3.m(\"Hello\");",
"method m in class A cannot be applied to given types;",
" required: no arguments",
" found: java.lang.String",
" reason: actual and formal argument lists differ in length",
""
]
}
],
"source": [
"//| echo: true\n",
"a3.m(\"Hello\");"
]
},
{
"cell_type": "markdown",
"id": "5e49b2ca-ef03-4a3f-915d-b1f7a2f6416a",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "markdown",
"id": "50e7453b-504e-47aa-b670-73e3789a759e",
"metadata": {},
"source": [
"## Condition d'utilisation \n"
]
},
{
"cell_type": "markdown",
"id": "1544165a",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"* Le principe d’utilisation de l’héritage en Java est le même que pour la conception :\n",
" * Si `B extends A` Alors `toute instance b de B est un (is a) A`\n",
" * Par exemple, toute Voiture v est un Vehicule\n",
" * Il est interdit d’utiliser l’héritage dans un autre contexte\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "e07d0a35",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En Java, le principe fondamental de l'héritage suit le concept de \"est un\" (is a), où une classe fille hérite non seulement des attributs et méthodes de sa classe parente, mais représente également une instance de cette classe parente. Par exemple, si une classe `B` étend une classe `A` avec `B extends A`, alors toute instance de `B`, comme `b`, est considérée comme une instance de `A`. Cette relation d'héritage reflète la nature \"est un\" dans laquelle une classe spécialisée (B) peut être vue comme un cas particulier de la classe plus générale (A).\n",
"\n",
"En Java, il est crucial de ne pas utiliser l'héritage en dehors de ce contexte spécifique de spécialisation \"est un\". L'héritage est conçu pour établir une relation de type \"est un\", ce qui signifie que la classe fille partage une relation sémantique forte avec sa classe parente. Utiliser l'héritage dans d'autres contextes pourrait conduire à une mauvaise conception et à une structure de classe incohérente, ce qui peut rendre le code plus difficile à maintenir et à comprendre. Ainsi, Java encourage l'utilisation de l'héritage de manière appropriée pour maintenir une hiérarchie claire et cohérente entre les classes.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "19c263db-5656-44b1-8979-504ddac013aa",
"metadata": {},
"source": [
"## Conséquences\n"
]
},
{
"cell_type": "markdown",
"id": "78c982ad",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"* La classe fille hérite de tous les membres (attributs et méthodes).\n",
" * L'accès aux membres peut être limité en fonction des protections.\n",
"\n",
"* Les constructeurs ne sont pas hérités car cela n'aurait pas de sens.\n",
"\n",
"* Toutefois, il est possible d'appeler explicitement un constructeur de la super classe avec `super()`.\n",
"\n",
"* Il est également possible d'appeler un autre constructeur de la même classe avec `this()`.\n",
"\n",
"* Attention, ces deux instructions (`super()` et `this()`) ne peuvent être que la première instruction d'un constructeur.\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "59765c49",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En Java, lorsqu'une classe fille hérite d'une classe mère à l'aide du mot-clé `extends`, elle acquiert tous les membres de la classe mère, y compris les attributs et les méthodes. L'accès à ces membres peut être restreint en fonction des niveaux de protection (public, private, protected) définis dans la classe mère.\n",
"\n",
"Contrairement aux attributs et aux méthodes, les constructeurs ne sont pas hérités. Cela est dû au fait que l'héritage d'un constructeur n'aurait pas de sens, car les constructeurs sont des méthodes spéciales utilisées pour initialiser les objets d'une classe particulière. Néanmoins, dans une classe fille, il est possible d'appeler explicitement un constructeur de sa classe mère à l'aide de `super()`. Cette instruction `super()` doit être la première instruction du constructeur fille si elle est utilisée.\n",
"\n",
"De plus, Java permet d'appeler un autre constructeur de la même classe à l'aide de `this()`. Cette flexibilité permet à une classe d'avoir plusieurs constructeurs qui peuvent être utilisés en fonction des besoins spécifiques sans répéter le code d'initialisation commun.\n",
"\n",
"Il est essentiel de noter que les instructions `super()` et `this()` ne peuvent être que la première instruction d'un constructeur. Cela garantit que l'initialisation de l'objet se fait correctement et dans l'ordre approprié, assurant ainsi la cohérence et la stabilité de l'objet instancié.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "21ad43be-0512-4780-a386-a963743eec68",
"metadata": {},
"source": [
"## Constructeur"
]
},
{
"cell_type": "markdown",
"id": "310d93c2",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"* En Java, si aucun `this()` ou `super()` n'est explicitement spécifié dans un constructeur, `super()` est ajouté par défaut.\n",
"* Cela signifie que le premier appel du \"dernier\" constructeur est à la super classe.\n",
"* Quel est donc le premier constructeur appelé et pourquoi ?\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "06883d3e",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En Java, lorsqu'aucun `this()` ou `super()` n'est explicitement spécifié dans un constructeur, le compilateur ajoute automatiquement `super()` comme première instruction. Cela signifie que le premier constructeur appelé est toujours celui de la super classe directe.\n",
"\n",
"Ce mécanisme est essentiel pour garantir que chaque instance d'une classe dérivée est correctement initialisée en appelant d'abord le constructeur de sa super classe. Cela assure une initialisation cohérente des objets tout au long de la hiérarchie d'héritage, en suivant la chaîne des constructeurs jusqu'à la classe la plus basique, qui est `Object` si aucune autre super classe n'est spécifiée explicitement.\n",
"\n",
"Ainsi, même si aucun `extends` n'est spécifié dans une classe, elle hérite implicitement de `Object`, et le constructeur par défaut de `Object` est appelé grâce à `super()`. Ce comportement garantit que tous les membres hérités sont initialisés correctement avant que les membres spécifiques à la classe fille ne soient initialisés, assurant ainsi la cohérence et l'intégrité des objets Java lors de leur création.\n",
":::"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "6e20ce8b-a52c-44cf-8b0f-9d05640b71c4",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"public class Animal {\n",
" private String espece;\n",
" public Animal (String espece) {this.espece=espece;}\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "c59257f7-0f9b-404a-94e8-4d26b3f4263f",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "1e5f72a0-7e07-406f-9ee5-5d25afe42ea2",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"public class Chien extends Animal {\n",
" private enum Race {BOXER , CANICHE , DOGUE} ;\n",
" private Race race ;\n",
" \n",
" public Chien() { super(\"canide\"); }\n",
" public Chien(Race race) {\n",
" this(); /* Que se passe−t−il sans this() ? */\n",
" this.race=race;\n",
" }\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "7a82f00a-b3de-4781-93fb-0c390d6c524f",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "markdown",
"id": "88859db3-2224-491b-93ed-2d07c27d94a8",
"metadata": {},
"source": [
"## Limitations"
]
},
{
"cell_type": "markdown",
"id": "74e26b85",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
" * Le type de retour d’une méthode surchargée doit être le même que celui de la méthode d’origine\n",
" * La nouvelle méthode ne doit pas être moins accessible\n",
" * Par exemple une méthode public ne peut pas devenir private\n",
" * Quelle est la raison ?\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "e0e30ba1",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"La raison principale pour laquelle une méthode surchargée ne peut pas devenir moins accessible que la méthode d'origine est liée au principe de substitution de Liskov, fondamental en programmation orientée objet. Ce principe stipule que les objets d'une classe dérivée doivent pouvoir être utilisés comme des objets de leur classe de base sans que le comportement de base de l'application soit modifié. \n",
"\n",
"Si une méthode d'origine est déclarée avec un niveau d'accès plus permissif (par exemple, `public`) et que cette méthode est surchargée dans une classe dérivée avec un niveau d'accès plus restrictif (par exemple, `private`), cela violerait ce principe. En effet, un objet de la classe dérivée ne pourrait pas remplacer sans restriction un objet de la classe de base, car il ne pourrait pas fournir toutes les méthodes accessibles au niveau de la classe de base.\n",
"\n",
"Cela compromettrait la capacité à utiliser le polymorphisme de manière efficace, ce qui est une pierre angulaire de la programmation orientée objet. En respectant cette règle, on garantit la cohérence et la prévisibilité du comportement des objets à travers la hiérarchie d'héritage, permettant ainsi une conception logicielle robuste et maintenable.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "9f651464-3991-4a88-a808-fac6a2246c4d",
"metadata": {},
"source": [
"## Le polymorphisme\n",
"\n",
"::: {#def-polymorphisme}\n",
"### Polymorphisme\n",
"Le **polymorphisme** est un mécanisme fondamental en programmation orientée objet qui permet à différents objets de réagir de manière spécifique à des messages identiques. \n",
":::\n",
"\n",
"::: {#def-typereel}\n",
"### Type réel\n",
"Le type **réel** est le type de l'objet réellement créé en mémoire.\n",
":::\n",
"\n",
"::: {#def-typedeclare}\n",
"### Type déclaré\n",
"Le type **déclaré** est celui de la référence par laquelle l'objet est manipulé dans le code.\n",
":::\n",
"\n",
"Le type déclaré détermine les messages disponibles pour l'objet, tandis que le type réel détermine quelle action spécifique sera exécutée lorsque le message est invoqué.\n"
]
},
{
"cell_type": "markdown",
"id": "2b8caa16-c254-4d4a-bf2f-077b0b4b261d",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "c4beb703-f9eb-4707-b33c-024a214e5d4f",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Je crie.\n",
"J'aboie\n",
"Je miaule\n"
]
}
],
"source": [
"//| echo: true\n",
"public class Animal {\n",
" void crier ( ) {System.out.println(\"Je crie.\");}\n",
" }\n",
"public class Chien extends Animal{\n",
" void crier ( ) {System.out.println(\"J'aboie\");}\n",
" }\n",
"public class Chat extends Animal{\n",
" void crier ( ) {System.out.println(\"Je miaule\");}\n",
" }\n",
"\n",
"Animal animaux [] = {new Animal(), new Chien() , new Chat()} ;\n",
"\n",
"for (Animal animal:animaux ) animal.crier();"
]
},
{
"cell_type": "markdown",
"id": "195802e1-ca7f-4799-89d5-efcb2bc4593c",
"metadata": {},
"source": [
"## Le transtypage\n"
]
},
{
"cell_type": "markdown",
"id": "6e9680b4",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"* Il est possible de forcer le compilateur à considérer un objet comme étant d’un type différent :\n",
" * de son type réel\n",
" * de son type déclaré\n",
"* Les seuls casts possibles sont ceux entre classes filles et mères. On distingue :\n",
" * l'upcast vers la classe mère (toujours possible)\n",
" * le downcast vers la classe fille (attention, risque de ClassCastException, cf. exemple suivant)\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "c5b2b135",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Il est possible de manipuler des objets en considérant des types différents de ceux déclarés ou réels grâce aux conversions de type, également appelées cast. Voici les principaux aspects à retenir :\n",
"\n",
"La conversion de type permet de forcer le compilateur à traiter un objet comme appartenant à un type différent de son type réel ou déclaré, en utilisant la syntaxe `(TypeCible) objet`.\n",
"\n",
"L'upcast consiste à convertir un objet vers le type de sa classe mère. Cette opération est sûre car une classe fille est toujours une instance valide de sa classe mère.\n",
"\n",
"En revanche, le downcast consiste à convertir un objet vers le type d'une classe fille. Cela peut entraîner une `ClassCastException` si l'objet ne peut pas être converti en cette classe fille spécifique. Il est donc important de vérifier avec `instanceof` avant de procéder à un downcast pour éviter des exceptions indésirées.\n",
"\n",
"En résumé, bien que les casts soient parfois nécessaires pour manipuler des objets de manière flexible, il est crucial d'être attentif aux conversions vers des classes filles afin de maintenir la sécurité et d'éviter les erreurs d'exécution.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "e8f8c58d-be6b-43cf-b452-97b8d1e27a69",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "859caa73-fde9-405c-b015-bf348dd729d4",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"grr grr\n"
]
}
],
"source": [
"//| echo: true\n",
"public abstract class Animal {\n",
" abstract void crier();\n",
" }\n",
"public class Chien extends Animal {\n",
" void mord() {System.out.println(\"grr grr\");}\n",
" void crier() {System.out.println(\"ouaf ouaf\");}\n",
" }\n",
"public class Chat extends Animal {\n",
" void crier() {System.out.println(\"miaou miaou\");} \n",
" }\n",
"\n",
"Animal animaux[] = {new Chat(), new Chien( ) , new Chat ()} ;\n",
"((Chien)animaux[1]).mord ( ) ;\n",
"/* Erreur a l ’ e x e c ut i o n mais pas a l a c o mp il a ti on\n",
"( ( Chien ) animaux [ 2 ] ) . mord ( ) ; */\n"
]
},
{
"cell_type": "markdown",
"id": "e6867ce5-1be2-4d7d-9568-8c9bb0763447",
"metadata": {},
"source": [
"## Les classes abstraites\n"
]
},
{
"cell_type": "markdown",
"id": "1dcf9b06",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"* En général, la spécialisation d’une classe peut entraîner la redéfinition d’une ou plusieurs méthodes.\n",
"* Dans certains cas, la définition du corps d’une méthode n’a pas de sens pour la classe mère.\n",
"* Par exemple, tous les animaux peuvent émettre un cri, mais le type spécifique de cri varie selon la sous-classe (Chien, Chat, ...).\n",
" * La définition de la méthode cri doit être abstraite dans la classe mère :\n",
" * Pour structurer le code de manière orientée objet.\n",
" * Pour permettre le polymorphisme via l'héritage.\n",
"* Ces classes abstraites ne peuvent pas être instanciées directement car elles contiennent des méthodes incomplètes.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "66f4b261",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"La spécialisation d'une classe peut souvent nécessiter la redéfinition de méthodes existantes. Il arrive que certaines méthodes n'aient pas de sens pour une classe mère en raison de la spécificité des sous-classes. Par exemple, tous les animaux peuvent émettre un cri, mais le type de cri varie selon l'espèce spécifique comme Chien, Chat, etc.\n",
"\n",
"Pour gérer cette situation de manière efficace et structurée, il est recommandé de définir la méthode cri comme abstraite dans la classe mère. Cela signifie que la classe mère déclare la méthode sans en fournir l'implémentation détaillée, laissant chaque sous-classe spécialisée (comme Chien ou Chat) fournir sa propre implémentation spécifique du cri.\n",
"\n",
"Les classes abstraites sont conçues spécifiquement pour être étendues et ne peuvent pas être instanciées directement. Elles servent de modèle pour d'autres classes qui étendent leur comportement et permettent de structurer le code de manière à favoriser le polymorphisme et la réutilisation du code par héritage. Ainsi, en Java, déclarer une classe comme abstraite garantit que toutes les sous-classes spécialisées implémenteront les méthodes nécessaires selon leur propre logique spécifique.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "f8c25abc-bbc2-44bb-baa9-76aa1dda9b41",
"metadata": {},
"source": [
"## Les classes abstraites\n"
]
},
{
"cell_type": "markdown",
"id": "ef05671e",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"* En Java, les méthodes sans implémentation doivent être marquées avec le mot-clé `abstract`.\n",
"* Les classes qui étendent une classe abstraite doivent fournir des implémentations pour toutes les méthodes abstraites ou être elles-mêmes marquées comme `abstract`.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "72a1c252",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En Java, lorsque vous avez des méthodes dans une classe qui sont déclarées mais n'ont pas d'implémentation concrète, vous devez les marquer avec le mot-clé `abstract`. Cela indique que la méthode est abstraite et n'a pas de corps défini dans la classe où elle est déclarée.\n",
"\n",
"Les classes abstraites elles-mêmes sont des classes spéciales conçues pour servir de modèle ou de structure de base à d'autres classes. Si une classe contient au moins une méthode abstraite, elle doit être déclarée comme abstraite en utilisant le mot-clé `abstract`. Cela signifie que la classe n'est pas complète et ne peut pas être instanciée directement. Au lieu de cela, elle doit être étendue par d'autres classes qui fourniront des implémentations concrètes pour toutes les méthodes abstraites de la classe parente.\n",
"\n",
"En résumé, en Java, les méthodes abstraites sont utilisées pour définir une interface commune que toutes les sous-classes doivent implémenter, tandis que les classes abstraites elles-mêmes fournissent cette interface et peuvent contenir à la fois des méthodes abstraites et des méthodes concrètes avec une implémentation.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "296e1750-6986-4ffb-84af-64ef282e9799",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "53635112-2b30-435b-bb75-25ed9fae9d97",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Je meugle.\n"
]
}
],
"source": [
"//| echo: true\n",
"public abstract class Animal {\n",
" public abstract void crier();\n",
" \n",
" public static void faireCrier(Animal[] animaux) {\n",
" for(Animal a:animaux) a.crier();\n",
" }\n",
"} \n",
"public abstract class Bovin extends Animal {\n",
" public abstract void ruminer() ;\n",
"}\n",
"public class Vache extends Bovin {\n",
" public void crier() {System.out.println(\"Je meugle.\");}\n",
" public void ruminer() {System.out.println(\"Je rumine.\");}\n",
"}\n",
"Animal.faireCrier(new Vache[]{new Vache()});"
]
},
{
"cell_type": "markdown",
"id": "6037d224-3ef1-4d15-ae6f-4c337e4164f0",
"metadata": {},
"source": [
"## Les interfaces\n"
]
},
{
"cell_type": "markdown",
"id": "636c0cc2",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"* En Java, la définition d'une classe et l'héritage permettent de définir à la fois l'état interne des instances et leur comportement, souvent par spécialisation.\n",
"* Cependant, cela impose une relation hiérarchique stricte de type \"est un\".\n",
"* Parfois, il est nécessaire de pouvoir imposer à des objets, instances de classes sans relation d'héritage, de vérifier un même comportement.\n",
"* Java, tout comme UML, propose pour cela la notion d'interface.\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "44ce550b",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Lorsqu'on définit une classe et qu'on utilise l'héritage, on peut définir à la fois l'état interne des instances (attributs) et leur comportement (méthodes), souvent en les spécialisant pour des utilisations spécifiques. Cependant, cette approche impose une relation de type \"est un\", ce qui signifie qu'une classe fille est une spécialisation de sa classe mère.\n",
"\n",
"Parfois, il est nécessaire d'imposer à des objets, qui sont des instances de classes sans relation d'héritage directe, de se conformer à un ensemble commun de comportements. Pour résoudre ce besoin, Java, tout comme UML, propose la notion d'interface. Une interface en Java définit un contrat que les classes peuvent choisir de suivre (ou \"implémenter\"). Elle spécifie les méthodes que les classes doivent implémenter, mais ne fournit pas d'implémentation concrète de ces méthodes. Cela permet à des classes différentes, sans lien d'héritage direct, de partager un comportement commun sans partager d'implémentation de classe.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "df8140a7-e1f1-4b80-bbc4-7732b464e83e",
"metadata": {},
"source": [
"## Les interfaces\n",
" \n",
"::: {#def-interface}\n",
"En Java, une **interface** définit un contrat sous la forme d'un ensemble de signatures de méthodes. Les classes peuvent choisir de suivre ce contrat en implémentant l'interface correspondante.\n",
":::\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d26288cb",
"metadata": {},
"source": [
"\n",
"::: {.content-visible when-profile=\"slides\"}\n",
"* Une interface est déclarée à l'aide du mot-clé `interface`.\n",
"* Elle est similaire à une classe n'ayant que des méthodes abstraites et publiques.\n",
"* Les interfaces peuvent hériter d'autres interfaces, même de manière multiple.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "a3626ece",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Une interface en Java est déclarée à l'aide du mot-clé `interface`. Elle ressemble à une classe qui ne contiendrait que des méthodes abstraites et publiques, c'est-à-dire des méthodes déclarées mais non implémentées. Les interfaces servent principalement à définir un contrat que les classes peuvent choisir de suivre en implémentant toutes les méthodes spécifiées.\n",
"\n",
"Les interfaces en Java peuvent étendre d'autres interfaces, ce qui permet de définir une hiérarchie d'interfaces. Cette relation d'héritage entre interfaces peut être multiple, c'est-à-dire qu'une interface peut étendre plusieurs autres interfaces, lui permettant d'hériter de leurs méthodes abstraites et constantes. Cela permet de créer des ensembles de comportements réutilisables et facilite la mise en œuvre de polymorphisme au sein du code Java.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "065c6eb9-c4e0-404b-a87d-6bdfd2d59bdd",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "91157ea7-6179-4174-ac7a-d07235764914",
"metadata": {
"vscode": {
"languageId": "java"
}
},
"outputs": [],
"source": [
"//| echo: true\n",
"public interface TrucEmpruntable {\n",
" public void emprunter ( ) ;\n",
" public void rendre ( ) ;\n",
" }\n",
"public class Voiture implements TrucEmpruntable{\n",
" boolean disponible = true ;\n",
" public void emprunter ( ) {disponible = false ;}\n",
" public void rendre ( ) {disponible = true ;}\n",
" }\n",
"public class Stylo implements TrucEmpruntable {\n",
" boolean emprunte = false ;\n",
" public void emprunter ( ) {emprunte = true ;}\n",
" public void rendre ( ) {emprunte = false ;}\n",
" }\n",
"\n",
"TrucEmpruntable trucs[] = {new Stylo(), new Voiture()};\n",
"for(TrucEmpruntable trucEmpruntable:trucs) trucEmpruntable.emprunter();"
]
}
],
"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
}