{
"cells": [
{
"cell_type": "markdown",
"id": "6a21bebd-b700-48ef-b01c-5afea5b30094",
"metadata": {},
"source": [
"---\n",
"title: Introduction au langage Java\n",
"description: Présentation générale du langage 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",
"--- "
]
},
{
"cell_type": "markdown",
"id": "b434b5d3-8ef6-42de-bb31-b82ba91b5258",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "2bcc7c52",
"metadata": {},
"source": [
"## La modélisation objet\n"
]
},
{
"cell_type": "markdown",
"id": "93dedb14",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Origines** : Issue des problèmes de simulation dans les années 1960.\n",
"- **Utilisation** :\n",
" - En modélisation (UML).\n",
" - En programmation (Smalltalk, C++, Java, etc.).\n",
" - En bases de données (SGBDOO : presque disparus et SGBDRO).\n",
"- **Concept majeur** : L’encapsulation.\n",
"- **Communication entre objets** : Un objet communique avec un autre via un ensemble de messages prédéfinis, sans connaître leur implantation interne.\n",
"- **Regroupement en classe** : Les objets peuvent être regroupés en classe.\n",
"- **Autres concepts ajoutés** : Composition, délégation, héritage, etc.\n",
"- **Deux points de vue sur un objet** :\n",
" - **Structurel** : Instance d’un type (une classe) masquant une structure derrière des opérations.\n",
" - **Conceptuel** : Correspond à une entité du monde réel, généralisable ou spécialisée.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "ef19b019",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"La Programmation Orientée Objet (POO) trouve ses origines dans les problèmes de simulation des années 1960. Elle est largement utilisée dans divers domaines tels que la modélisation (UML), la programmation (Smalltalk, C++, Java, etc.) et les bases de données (SGBDOO, bien que presque disparus, et SGBDRO). Le concept majeur de la POO est l'encapsulation, où les objets communiquent entre eux via un ensemble de messages prédéfinis sans connaître leur implantation interne. Les objets peuvent être regroupés en classes, et d'autres concepts clés tels que la composition, la délégation et l'héritage enrichissent cette approche. Un objet peut être perçu sous deux angles : structurel, comme une instance d'un type masquant une structure derrière des opérations, et conceptuel, correspondant à une entité du monde réel pouvant être généralisée ou spécialisée.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "b09d0eab-81ad-46ba-b4ed-b88a91dcd335",
"metadata": {},
"source": [
"## Les objets"
]
},
{
"cell_type": "markdown",
"id": "9f9a0433",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"::: {#def-object}\n",
"### Objet\n",
"Représente une entité avec une identité, un état (attributs) et un comportement (méthodes).\n",
":::\n",
"\n",
"- **Comportement (Méthodes)** : Réagir aux messages selon son état interne, pouvant le modifier.\n",
"- **État Interne (Attributs)** : Noms et valeurs décrivant l'état.\n",
"- **Encapsulation** : Cache l'état interne et fournit des méthodes pour y accéder, améliorant la sécurité et l'évolutivité.\n",
"\n",
"- Avantages\n",
" - **Sécurité** : Protéger les données internes.\n",
" - **Évolutivité** : Modifier l'implémentation interne sans affecter le code externe.\n",
"- Inconvénients\n",
" - **Performance** : L'encapsulation peut entraîner une légère surcharge.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "35e19961",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"\n",
"::: {#def-object}\n",
"### Objet\n",
"Un objet en programmation orientée objet représente une entité avec une identité unique, un état défini par des attributs, et un comportement décrit par des méthodes. \n",
":::\n",
"\n",
"Les méthodes permettent à l'objet de réagir aux messages qu'il reçoit, et ces réactions peuvent modifier son état interne. Les attributs, nommés et valorisés, décrivent l'état interne de l'objet. L'encapsulation est un principe clé qui cache cet état interne et fournit des méthodes pour y accéder, ce qui améliore à la fois la sécurité et l'évolutivité du code. En encapsulant les données, on protège les informations internes des accès non autorisés et on permet de modifier l'implémentation interne sans impacter le code externe qui utilise l'objet. Cependant, cette encapsulation peut introduire une légère surcharge de performance en raison des méthodes d'accès et de modification des attributs.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "f8420bff-03e6-4be0-869e-ffb1c1d64550",
"metadata": {},
"source": [
"## Les messages\n"
]
},
{
"cell_type": "markdown",
"id": "e3095a99",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Méthodes d'un Objet** :\n",
" - Un objet possède un ensemble de méthodes, qui peuvent être publiques ou privées.\n",
"\n",
"- **Interface Publique** :\n",
" - L'ensemble des méthodes publiques constitue l'interface de l'objet, représentant les messages qu'il peut recevoir et traiter.\n",
"\n",
"- **Exemples de Méthodes** :\n",
" - ```java\n",
" unePersonne.saluer(); // Méthode pour saluer\n",
" unePersonne.donnerPrénom(\"Pierre\"); // Méthode pour attribuer un prénom\n",
" unePersonne.afficherPrénom(); // Méthode pour afficher le prénom\n",
" unePersonne.retournerPrénom(); // Méthode pour retourner le prénom\n",
" ```\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "28c34ebe",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"En programmation orientée objet, chaque objet possède un ensemble de méthodes qui peuvent être soit publiques, soit privées. Les méthodes publiques constituent l'interface de l'objet, définissant l'ensemble des messages qu'il peut recevoir et traiter. Par exemple, considérez un objet `unePersonne` avec les méthodes suivantes : `saluer()`, `donnerPrénom(String prénom)`, `afficherPrénom()`, et `retournerPrénom()`. Voici comment ces méthodes peuvent être utilisées :\n",
"\n",
"- `unePersonne.saluer();` permet à l'objet de saluer.\n",
"- `unePersonne.donnerPrénom(\"Pierre\");` attribue le prénom \"Pierre\" à l'objet.\n",
"- `unePersonne.afficherPrénom();` affiche le prénom de l'objet.\n",
"- `unePersonne.retournerPrénom();` retourne le prénom de l'objet.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "a8b6fb9c-19f9-42ed-9e5b-37d0dcd384cb",
"metadata": {},
"source": [
"## Les classes - Définition"
]
},
{
"cell_type": "markdown",
"id": "d3b32cf7",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Similarités entre Objets** :\n",
" - Certains objets possèdent des propriétés très proches, voire identiques.\n",
" - Exemple : Les propriétés des voitures dans un programme ou, de manière plus générale, les propriétés communes entre différents véhicules.\n",
"\n",
"- **Notion de Classe** :\n",
" - Une classe est un ensemble d’objets présentant des similitudes en termes d'identification, de comportement, ou de description de l’état dans une application.\n",
" - On appelle **instance d’une classe** un objet qui appartient à cette classe.\n",
"\n",
"- **Exemples** :\n",
" - **Classe `Voiture`** :\n",
" - Attributs : `marque`, `modèle`, `année`, `couleur`.\n",
" - Méthodes : `démarrer()`, `arrêter()`, `accélérer()`.\n",
" - **Instances de la Classe `Voiture`** :\n",
" - `voiture1` : marque=\"Toyota\", modèle=\"Corolla\", année=2020, couleur=\"Rouge\".\n",
" - `voiture2` : marque=\"Honda\", modèle=\"Civic\", année=2018, couleur=\"Bleue\". \n",
":::\n",
"\n",
"::: {.content-visible when-profile=\"notes\"}\n",
"\n",
"Certains objets possèdent des propriétés très proches, voire identiques. Par exemple, les voitures dans un programme peuvent partager des caractéristiques communes telles que la marque, le modèle, l'année et la couleur.\n",
"\n",
"Une classe est un ensemble d’objets présentant des similitudes en termes d'identification, de comportement, ou de description de l’état dans une application. Une **instance d’une classe** est un objet qui appartient à cette classe.\n",
"\n",
"La classe Voiture peut être définie avec les attributs suivants : la marque, le modèle, l’année et la couleur. Elle peut également inclure des méthodes telles que démarrer, arrêter et accélérer.\n",
"Instances de la Classe Voiture\n",
"Prenons deux exemples d’instances de la classe Voiture :\n",
"La première instance, voiture1, a pour marque “Toyota”, pour modèle “Corolla”, pour année 2020 et pour couleur “Rouge”.\n",
"La deuxième instance, voiture2, a pour marque “Honda”, pour modèle “Civic”, pour année 2018 et pour couleur “Bleue”.\n",
"Ces instances partagent les mêmes attributs et méthodes définis par la classe Voiture, mais avec des valeurs spécifiques à chaque instance.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "35440308",
"metadata": {},
"source": [
"## Concept de Classe dans les langages de programmation"
]
},
{
"cell_type": "markdown",
"id": "b71532e0",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Chaque langage de programmation et modèle de conception comme UML présente des choix distincts en ce qui concerne le concept de classes, influencés par leurs principes de conception et objectifs spécifiques.\n",
"\n",
"En UML, les classes sont utilisées pour modéliser des entités du monde réel ou des concepts abstraits. Elles définissent les propriétés (attributs) et comportements (méthodes) des objets qui en sont des instances. UML permet de représenter la structure et les relations entre les classes à l'aide de diagrammes.\n",
"\n",
"Java, un langage orienté objet par excellence, met l'accent sur l'encapsulation, l'héritage et le polymorphisme à travers ses classes. Les classes Java sont des structures fondamentales pour organiser le code en modules réutilisables, encapsulant étroitement les données et les méthodes pour contrôler l'accès à celles-ci.\n",
"\n",
"Python utilise également des classes pour créer des objets, mais de manière plus flexible grâce à sa nature dynamique. Les classes Python permettent l'héritage multiple, le polymorphisme et la surcharge d'opérateurs, tout en soutenant les méthodes spéciales pour une personnalisation avancée du comportement des objets.\n",
"\n",
"JavaScript et TypeScript, bien que différents dans leur typage et structure, partagent le concept de classes introduit avec ECMAScript 6 (ES6). Les classes JavaScript simplifient la syntaxe de création d'objets en utilisant le mot-clé class, tout en restant fondamentalement basées sur des prototypes. TypeScript étend ce concept en ajoutant un typage statique aux classes JavaScript, offrant ainsi des fonctionnalités supplémentaires de vérification de types et d'autocomplétion dans les environnements de développement.\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "308f9d9b",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **UML** :\n",
" - Langage unifié utilisé pour modéliser des entités du monde réel ou des concepts abstraits.\n",
" - Définit les propriétés (attributs) et comportements (méthodes) des objets.\n",
" - Permet de représenter la structure et les relations entre les classes à l'aide de diagrammes.\n",
"\n",
"- **Java** :\n",
" - Langage orienté objet mettant l'accent sur l'encapsulation, l'héritage et le polymorphisme.\n",
" - Structure fondamentale pour organiser le code en modules réutilisables.\n",
" - Contrôle strictement l'accès aux données via les classes.\n",
"\n",
"- **Python** :\n",
" - Utilise des classes pour créer des objets de manière flexible et dynamique.\n",
" - Supporte l'héritage multiple, le polymorphisme et la surcharge d'opérateurs.\n",
" - Méthodes spéciales permettant une personnalisation avancée du comportement des objets.\n",
"\n",
"- **JavaScript et TypeScript** :\n",
" - Partagent le concept de classes introduit avec ECMAScript 6 (ES6).\n",
" - JavaScript simplifie la syntaxe de création d'objets avec `class`, basée sur des prototypes.\n",
" - TypeScript étend JavaScript avec un typage statique pour des fonctionnalités de vérification de types.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "2a70bcab-0cf0-432e-ae56-edfc0b4e6d2a",
"metadata": {},
"source": [
"## UML"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "3d14e1e8",
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"//| label: fig-uml-classe-voiture\n",
"//| fig-cap: \"Les Voiture en UML\"\n",
"//| fig-format: svg\n",
"// PRINT SCHEMA\n",
"String script=\"\"\"\n",
" @startuml\n",
"class Voiture {\n",
" - marque: String\n",
" - modele: String\n",
" - annee: int\n",
" - couleur: String\n",
" --\n",
" + demarrer(): void\n",
" + arreter(): void\n",
" + accelerer(vitesse: int): void\n",
"}\n",
" @enduml\n",
" \"\"\"; \n",
"\n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n",
"return null; "
]
},
{
"cell_type": "markdown",
"id": "ec954544",
"metadata": {},
"source": [
"### Java\n",
"\n",
"```Java\n",
"public class Voiture {\n",
" private String marque;\n",
" private String modele;\n",
" private int annee;\n",
" private String couleur;\n",
" private static int nombreDeVoitures = 0;\n",
"\n",
" public Voiture(String marque, String modele, int annee, String couleur) {\n",
" this.marque = marque;\n",
" this.modele = modele;\n",
" this.annee = annee;\n",
" this.couleur = couleur;\n",
" nombreDeVoitures++;\n",
" }\n",
"\n",
" public void demarrer() {\n",
" System.out.println(marque + \" \" + modele + \" démarre.\");\n",
" }\n",
"\n",
" public void arreter() {\n",
" System.out.println(marque + \" \" + modele + \" s'arrête.\");\n",
" }\n",
"\n",
" public void accelerer(int vitesse) {\n",
" System.out.println(marque + \" \" + modele + \" accélère à \" + vitesse + \" km/h.\");\n",
" }\n",
"\n",
" public static int getNombreDeVoitures() {\n",
" return nombreDeVoitures;\n",
" }\n",
"}\n",
"\n",
"```\n",
"\n",
"### Python\n",
"\n",
"```python\n",
"class Voiture:\n",
" nombre_de_voitures = 0\n",
"\n",
" def __init__(self, marque, modele, annee, couleur):\n",
" self.marque = marque\n",
" self.modele = modele\n",
" self.annee = annee\n",
" self.couleur = couleur\n",
" Voiture.nombre_de_voitures += 1\n",
"\n",
" def demarrer(self):\n",
" print(f\"{self.marque} {self.modele} démarre.\")\n",
"\n",
" def arreter(self):\n",
" print(f\"{self.marque} {self.modele} s'arrête.\")\n",
"\n",
" def accelerer(self, vitesse):\n",
" print(f\"{self.marque} {self.modele} accélère à {vitesse} km/h.\")\n",
"\n",
" @classmethod\n",
" def get_nombre_de_voitures(cls):\n",
" return cls.nombre_de_voitures\n",
"```\n",
"\n",
"### Kotlin\n",
"\n",
"```Kotlin\n",
"class Voiture(\n",
" private val marque: String,\n",
" private val modele: String,\n",
" private val annee: Int,\n",
" private val couleur: String\n",
") {\n",
" companion object {\n",
" var nombreDeVoitures: Int = 0\n",
" private set\n",
" }\n",
"\n",
" init {\n",
" nombreDeVoitures++\n",
" }\n",
"\n",
" fun demarrer() {\n",
" println(\"$marque $modele démarre.\")\n",
" }\n",
"\n",
" fun arreter() {\n",
" println(\"$marque $modele s'arrête.\")\n",
" }\n",
"\n",
" fun accelerer(vitesse: Int) {\n",
" println(\"$marque $modele accélère à $vitesse km/h.\")\n",
" }\n",
"}\n",
"```\n",
"\n",
"### Typescript\n",
"\n",
"```Typescript\n",
"class Voiture {\n",
" private static nombreDeVoitures: number = 0;\n",
"\n",
" constructor(\n",
" private marque: string,\n",
" private modele: string,\n",
" private annee: number,\n",
" private couleur: string\n",
" ) {\n",
" Voiture.nombreDeVoitures++;\n",
" }\n",
"\n",
" public demarrer(): void {\n",
" console.log(`${this.marque} ${this.modele} démarre.`);\n",
" }\n",
"\n",
" public arreter(): void {\n",
" console.log(`${this.marque} ${this.modele} s'arrête.`);\n",
" }\n",
"\n",
" public accelerer(vitesse: number): void {\n",
" console.log(`${this.marque} ${this.modele} accélère à ${vitesse} km/h.`);\n",
" }\n",
"\n",
" public static getNombreDeVoitures(): number {\n",
" return Voiture.nombreDeVoitures;\n",
" }\n",
"}\n",
"```\n",
"\n",
"### Javascript\n",
"\n",
"```Javascript\n",
"// Constructeur Voiture\n",
"function Voiture(marque, modele, annee, couleur) {\n",
" this.marque = marque;\n",
" this.modele = modele;\n",
" this.annee = annee;\n",
" this.couleur = couleur;\n",
" Voiture.nombreDeVoitures++;\n",
"}\n",
"\n",
"// Propriété statique pour compter le nombre de voitures\n",
"Voiture.nombreDeVoitures = 0;\n",
"\n",
"// Méthodes de la classe Voiture\n",
"Voiture.prototype.demarrer = function() {\n",
" console.log(this.marque + \" \" + this.modele + \" démarre.\");\n",
"};\n",
"\n",
"Voiture.prototype.arreter = function() {\n",
" console.log(this.marque + \" \" + this.modele + \" s'arrête.\");\n",
"};\n",
"\n",
"Voiture.prototype.accelerer = function(vitesse) {\n",
" console.log(this.marque + \" \" + this.modele + \" accélère à \" + vitesse + \" km/h.\");\n",
"};\n",
"\n",
"// Méthode statique pour obtenir le nombre de voitures\n",
"Voiture.getNombreDeVoitures = function() {\n",
" return Voiture.nombreDeVoitures;\n",
"};\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "4d993316",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Dans la programmation orientée objet, on remarque souvent que certains objets possèdent des propriétés très proches, voire identiques. Par exemple, dans un programme, les propriétés des voitures, telles que la marque, le modèle, l'année et la couleur, sont communes. De manière plus générale, ces propriétés communes peuvent exister entre différents types de véhicules.\n",
"\n",
"Pour organiser ces similitudes, on introduit la notion de classe. Une classe est un ensemble d’objets présentant des similitudes en termes d'identification, de comportement ou de description de l’état dans une application. Par exemple, une classe `Voiture` pourrait avoir des attributs comme la marque, le modèle, l'année, et la couleur, ainsi que des méthodes pour démarrer, arrêter, et accélérer. Un objet appartenant à une classe est appelé **instance** de cette classe.\n",
"\n",
"- **Classe `Voiture`** :\n",
" - **Attributs** : `marque`, `modèle`, `année`, `couleur`.\n",
" - **Méthodes** : `démarrer()`, `arrêter()`, `accélérer()`.\n",
"\n",
"- **Instances de la Classe `Voiture`** :\n",
" - `voiture1` : marque=\"Toyota\", modèle=\"Corolla\", année=2020, couleur=\"Rouge\".\n",
" - `voiture2` : marque=\"Honda\", modèle=\"Civic\", année=2018, couleur=\"Bleue\".\n",
"\n",
"Ces instances de la classe `Voiture` partagent les mêmes attributs et comportements, illustrant les similitudes entre objets et la puissance de la notion de classe en programmation orientée objet. La classe permet de créer des objets structurés de manière cohérente, facilitant ainsi leur gestion, réutilisation et maintenabilité.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "de7e270f-f4cc-4d6c-9573-c845cc0bcc6d",
"metadata": {},
"source": [
"## Les classes - Utilisation"
]
},
{
"cell_type": "markdown",
"id": "b68cc5cd",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Description des Propriétés des Instances** :\n",
" - Une classe décrit les propriétés de ses instances en définissant leurs variables d'état et leurs méthodes.\n",
"\n",
"- **Instanciation de Nouveaux Objets** :\n",
" - Une classe permet de créer de nouveaux objets via des constructeurs.\n",
"\n",
"- **Partage d'Informations** :\n",
" - Une classe facilite le partage d'informations entre objets et la gestion des instances.\n",
" - Pour ce faire, des propriétés peuvent être associées aux classes elles-mêmes, plutôt qu'aux objets individuels.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "9f469b3d",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Une classe décrit les propriétés de ses instances en définissant leurs variables d'état et leurs méthodes. Les variables d'état, ou attributs, représentent les données propres à chaque instance, tandis que les méthodes définissent les comportements que les instances peuvent effectuer.\n",
"\n",
"Une classe permet de créer de nouveaux objets via des constructeurs. Les constructeurs sont des méthodes spéciales qui initialisent les nouvelles instances de la classe en leur assignant des valeurs initiales pour leurs attributs.\n",
"\n",
"Une classe facilite également le partage d'informations entre objets et la gestion des instances. Pour ce faire, des propriétés peuvent être associées aux classes elles-mêmes, plutôt qu'aux objets individuels. Ces propriétés de classe, également appelées attributs ou méthodes statiques, sont partagées par toutes les instances de la classe et peuvent être utilisées pour maintenir des informations communes ou pour coordonner les actions entre les instances.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "502c3f80-a49c-4f6d-bfe7-ad14edbc2c97",
"metadata": {},
"source": [
"## Origines et Motivations de la Création du Langage Java"
]
},
{
"cell_type": "markdown",
"id": "fe775ebf",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Java a été créé par James Gosling et une équipe de développeurs chez Sun Microsystems au début des années 1990. Les origines du langage remontent à 1991, lorsque Sun Microsystems a initié le projet \"Green\" pour développer une technologie pour les appareils électroménagers intelligents. L'équipe a rapidement constaté que les langages existants, comme C++ et C, étaient inadaptés pour les applications distribuées et portables. Le langage Java a donc été conçu pour répondre à plusieurs besoins spécifiques : offrir une portabilité maximale (écrire une fois, exécuter partout), améliorer la sécurité et la robustesse des applications, simplifier le développement en éliminant les aspects complexes de C++, et fournir des fonctionnalités intégrées pour la gestion de la mémoire. Java a été officiellement lancé en 1995, et sa capacité à fonctionner sur n'importe quel dispositif grâce à la machine virtuelle Java (JVM) a été une révolution, faisant de lui un langage incontournable pour le développement web et d'applications mobiles. En 2010, Oracle a racheté Sun Microsystems, acquérant ainsi Java et poursuivant son développement et son évolution. Java est distribué sous une licence open source pour son code source, tandis que les binaires sont disponibles sous une licence propriétaire. Cela permet aux développeurs de contribuer au code source tout en respectant les restrictions associées aux binaires distribués par Oracle. Des distributions de binaires libres, telles que Temurin (anciennement AdoptOpenJDK), fournissent une alternative open source populaire pour les utilisateurs soucieux de la liberté d'utilisation et de distribution des logiciels Java.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "1c7e3231",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Origines** :\n",
" - Créé par James Gosling et son équipe chez Sun Microsystems dans les années 1990.\n",
" - Projet \"Green\" pour les appareils électroménagers intelligents.\n",
"\n",
"- **Motivations** :\n",
" - Portabilité maximale grâce à la machine virtuelle Java (JVM).\n",
" - Sécurité renforcée et robustesse des applications.\n",
" - Simplification du développement par rapport à C++.\n",
"\n",
"- **Évolution** :\n",
" - Lancé officiellement en 1995.\n",
" - Acquis par Oracle en 2010, continué sous leur direction.\n",
" - Licence open source pour le code source, avec des binaires sous licence propriétaire.\n",
"\n",
"- **Distributions de Binaires Libres** :\n",
" - Exemple : Temurin (AdoptOpenJDK), une alternative populaire open source.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "af6b60e2-3c22-4989-81d6-c7d349c7be9e",
"metadata": {},
"source": [
"## Les caractéristiques de Java"
]
},
{
"cell_type": "markdown",
"id": "c15fdb13",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Orienté objet** : Encourage la modélisation des problèmes sous forme d'objets.\n",
"\n",
"- **Portable** : Grâce à la JVM, permet de \"Compiler une fois, exécuter partout\".\n",
"\n",
"- **Sécurité** : Typage fort et mécanismes de vérification préventifs.\n",
"\n",
"- **Multi-Tâche** : Supporte la programmation multi-thread pour l'exécution concurrente.\n",
"\n",
"- **Dynamique** : Permet le chargement des classes pendant l'exécution.\n",
"\n",
"- **Complet** : Bibliothèque riche d'API pour le développement d'applications (IHM, réseau, bases de données, etc.).\n",
"\n",
"- **Interprété mais compilé** : Compilation en bytecode portable et interprétation par la JVM avec optimisations JIT. Intégration de l'AOT et optimisation JIT pour améliorer les performances.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "70a159bf",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Java est un langage de programmation orienté objet célèbre pour sa portabilité grâce à la machine virtuelle Java (JVM), permettant de \"Compiler une fois, exécuter partout\". Il se distingue par sa sécurité renforcée grâce à un typage fort et des mécanismes de vérification tout au long de l'exécution. Java facilite la programmation multi-thread, essentielle pour gérer des tâches concurrentes, et offre la flexibilité de charger des classes dynamiquement pendant l'exécution. Sa bibliothèque standard complète inclut des API pour les interfaces graphiques, le réseau, les bases de données, et plus encore. Java utilise un modèle d'exécution combinant compilation en bytecode portable et interprétation par la JVM, avec des optimisations JIT pour améliorer les performances. De récentes avancées comme l'AOT (Ahead-Of-Time Compilation) et une optimisation JIT continue renforcent encore ses capacités d'exécution, consolidant Java comme un choix privilégié pour les applications critiques et distribuées à grande échelle.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "67786280-f50d-41d7-9a53-b0b0cb8659d8",
"metadata": {},
"source": [
"## Du code source à l’exécution\n"
]
},
{
"cell_type": "markdown",
"id": "7c57bb0b",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Compilation** :\n",
" - À partir du code source (fichiers .java) avec le compilateur (commande javac).\n",
" - Création de bytecode Java (fichiers .class), un pseudo-code compréhensible par la JVM.\n",
"\n",
"- **Bytecode Java** :\n",
" - Code assembleur Java, composé d'une suite d’instructions pour la machine virtuelle Java.\n",
"\n",
"- **Machine Virtuelle** :\n",
" - JVM : Java Virtual Machine.\n",
" - Implémentation de la JVM pour différents systèmes (Windows, Unix, MacOS, etc.).\n",
"\n",
"- **Interprétation et Optimisation du Code** :\n",
" - La JVM interprète le bytecode Java pour l'exécuter.\n",
" - Oracle fournit une implantation de référence et des optimisations JIT (Just-In-Time) pour améliorer les performances.\n",
"\n",
"[documentation Java SE](https://docs.oracle.com/javase/specs/).\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "51bc1d45",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Le processus d'exécution d'un programme Java commence par la compilation du code source, écrit en fichiers ``.java`` à l'aide du compilateur Java (`javac`). Ce processus transforme le code source en bytecode Java, représentant un pseudo-code compréhensible par la Java Virtual Machine (JVM). La JVM, une machine virtuelle spécifique à Java, est ensuite implémentée sur différents systèmes d'exploitation tels que Windows, Unix et MacOS, assurant ainsi la portabilité des applications Java. Lors de l'exécution, la JVM interprète le bytecode Java et peut optimiser le code en utilisant des techniques JIT (Just-In-Time), fournissant des améliorations de performance au fur et à mesure de l'exécution. Oracle propose une implantation de référence de la JVM et fournit des outils pour faciliter le développement et l'optimisation des applications Java. Pour des détails techniques approfondis sur la spécification du bytecode Java, consultez la [documentation Java SE](https://docs.oracle.com/javase/specs/).\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "d48ea896-8ba2-4a51-8a49-23f9d2557058",
"metadata": {},
"source": [
"## Code source et bytecode"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "e115d5a4-47aa-465f-901b-c5e340b0b266",
"metadata": {},
"outputs": [],
"source": [
"//| echo: true\n",
"\n",
"/**\n",
"* Cette application Java affiche simplement \n",
"* ”Bonjour à tous !”\n",
"* sur la sortie standard.\n",
"*/\n",
"class BonjourATous {\n",
" public static void main ( String [ ] args ) {\n",
" System.out.println(\"Bonjour a tous !\");\n",
" }\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "b556f7c0-ccf6-4653-a5f0-3e673541ea6e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"//| echo: false\n",
"//| output: false\n",
"String script=\"\"\"\n",
"cat << EOF > /tmp/BonjourATous.java\n",
"/**\n",
"* Cette application Java affiche simplement \n",
"* ”Bonjour à tous !”\n",
"* sur la sortie standard.\n",
"*/\n",
"class BonjourATous {\n",
" public static void main ( String [ ] args ) {\n",
" System.out.println(\"Bonjour a tous !\");\n",
" }\n",
"}\n",
"EOF \n",
"\"\"\";\n",
"\n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"shell\",List.of(\"\"),script); "
]
},
{
"cell_type": "markdown",
"id": "981184f8-c627-465b-8372-1ff3ac02715b",
"metadata": {},
"source": [
"La classe peut être compilée: `javac BonjourATous.java`"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "c944fa10-1fbf-454a-927d-57cc75be2eb2",
"metadata": {},
"outputs": [],
"source": [
"//| output: true\n",
"//| echo: false\n",
"String script=\"\"\"\n",
"cd /tmp\n",
"javac BonjourATous.java\n",
"\"\"\";\n",
" \n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"shell\",List.of(),script); \n",
"return null;"
]
},
{
"cell_type": "markdown",
"id": "7f61787f-4597-4099-b0c4-91df572e583c",
"metadata": {},
"source": [
"puis exécutée:`java BonjourATous`"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "0f238cd4-5a1f-45e7-a2f9-7c5f51b448c3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bonjour a tous !\n"
]
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"String script=\"\"\"\n",
"cd /tmp\n",
"java BonjourATous\n",
"\"\"\";\n",
" \n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"shell\",List.of(),script); \n",
"return null;"
]
},
{
"cell_type": "markdown",
"id": "bf97c151-9ac6-425f-9786-5e3861286cf8",
"metadata": {},
"source": [
"il est aussi possible de consulter le bytecode: `javap -c BonjourATous.class`"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "cfacc0a1-9b14-4873-a22a-54f779948837",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Compiled from \"BonjourATous.java\"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"class BonjourATous {\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" BonjourATous();\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Code:\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0: aload_0\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 1: invokespecial #1 // Method java/lang/Object.\"\":()V\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 4: return\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" public static void main(java.lang.String[]);\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Code:\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream;\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 3: ldc #13 // String Bonjour a tous !\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 5: invokevirtual #15 // Method java/io/PrintStream.println:(Ljava/lang/String;)V\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 8: return\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"}\n"
]
}
],
"source": [
"//| output: true\n",
"//| echo: false\n",
"String script=\"\"\"\n",
"cd /tmp\n",
"javap -c BonjourATous.class\n",
"\"\"\";\n",
"\n",
"IJava.getKernelInstance().getMagics().applyCellMagic(\"shell\",List.of(),script); \n",
"return null;"
]
},
{
"cell_type": "markdown",
"id": "710fc243-4b80-44c2-9bc0-745cb2b5b189",
"metadata": {},
"source": [
"## Implantation et Versions"
]
},
{
"cell_type": "markdown",
"id": "828c62d9",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Implantation de Référence** : Fournie par Oracle, consultez la [documentation Java SE](https://docs.oracle.com/en/java/javase/21/).\n",
"\n",
"- **Java Development Kit (JDK)** : Utilisé pour le développement et l'exécution des programmes Java.\n",
"\n",
"- **Java Runtime Environment (JRE)** : Utilisé uniquement pour l'exécution des programmes Java.\n",
"\n",
"- **Gestion des Versions** :\n",
" - Java évolue avec l'apparition de nouvelles fonctionnalités et la disparition de certaines marquées comme obsolètes (deprecated).\n",
" - https://www.java.com/releases/\n",
" - Consultez le [roadmap de support Oracle](https://www.oracle.com/java/technologies/java-se-support-roadmap.html) pour les détails sur les versions à long terme (LTS) :\n",
" - Java 8 (mars 2014, support illimité)\n",
" - Java 11 (septembre 2018, support jusqu'en 2024)\n",
" - Java 17 (septembre 2021, support jusqu'en 2027)\n",
" - **Java 21 (septembre 2023, support jusqu'en 2028)**\n",
" - Java 25 (septembre 2025, support jusqu'en 2030)\n",
" - Non LTS: Java 22 (mars 2024) puis Java 23 (septembre 2024)\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "5ed55bbe",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Java, développé par Oracle, est soutenu par une implantation de référence que vous pouvez explorer via la [documentation Java SE](https://docs.oracle.com/en/java/javase/21/). Le Java Development Kit (JDK) est essentiel pour le développement et l'exécution des applications Java, tandis que le Java Runtime Environment (JRE) permet uniquement l'exécution. Le langage Java évolue régulièrement, introduisant de nouvelles fonctionnalités tout en retirant celles devenues obsolètes, marquées comme deprecated. Pour planifier vos déploiements et migrations, référez-vous au [roadmap de support Oracle](https://www.oracle.com/java/technologies/java-se-support-roadmap.html) qui détaille les versions à long terme (LTS) comme Java 8, Java 11, Java 17, et Java 21, chacune avec des périodes de support spécifiques allant jusqu'en 2028.\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "1c4bf8c1-cf52-4def-b246-4e72368b361d",
"metadata": {},
"source": [
"## Environnement de Développement Java"
]
},
{
"cell_type": "markdown",
"id": "81b1f121",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Prérequis** :\n",
" - Au minimum, nécessitez un JDK (Java Development Kit) et un éditeur de texte.\n",
"\n",
"- **Outils de Gestion de Projet** :\n",
" - Utilisez des outils comme [Maven](https://maven.apache.org/) ou Gradle pour la gestion des dépendances et la construction de projets.\n",
"\n",
"- **Environnement de Développement Intégré (IDE)** :\n",
" - Les IDE offrent une assistance complète au développement avec des fonctionnalités telles que la navigation dans les sources, la saisie assistée, et le débogage.\n",
" - Choisissez parmi plusieurs solutions :\n",
" - Eclipse, un projet open source supporté par IBM, offre une suite complète d'outils (http://www.eclipse.org).\n",
" - IntelliJ IDEA de JetBrains, disponible en versions communautaire et commerciale, est réputé pour son éditeur performant (https://www.jetbrains.com/idea).\n",
" - Pour une expérience légère mais puissante, Visual Studio Code propose des extensions pour le développement Java (https://code.visualstudio.com/docs/languages/java).\n",
":::"
]
},
{
"cell_type": "markdown",
"id": "da1660e5",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Pour démarrer efficacement le développement Java, il est essentiel de disposer au minimum du JDK (Java Development Kit) ainsi que d'un éditeur de texte adapté. Ces outils vous permettent de compiler, exécuter et gérer vos projets Java de manière optimale. Pour une gestion avancée des dépendances et la construction de projets structurés, Maven ou Gradle sont recommandés, offrant des fonctionnalités robustes et une gestion efficace des bibliothèques externes.\n",
"\n",
"En ce qui concerne l'environnement de développement intégré (IDE), plusieurs options s'offrent à vous pour bénéficier d'une assistance complète tout au long du processus de développement. Eclipse, projet open source soutenu par IBM, propose une suite complète d'outils pour le développement Java, accessible via http://www.eclipse.org. IntelliJ IDEA, développé par JetBrains, est largement plébiscité pour son éditeur performant et ses fonctionnalités avancées, disponibles en versions communautaire et commerciale sur https://www.jetbrains.com/idea. Pour une approche plus légère mais puissante, Visual Studio Code offre des extensions dédiées au développement Java, permettant une personnalisation selon vos besoins via https://code.visualstudio.com/docs/languages/java.\n",
"::: \n"
]
},
{
"cell_type": "markdown",
"id": "6880856d-8d66-4ac5-b59b-2e6a3e7ea1a2",
"metadata": {},
"source": [
"## Java en résumé"
]
},
{
"cell_type": "markdown",
"id": "9ac1c609",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"slides\"}\n",
"- **Avantages**\n",
" - **Portabilité** : Le bytecode Java est exécutable sur n’importe quelle JVM, assurant une grande portabilité des applications.\n",
" - **Sécurité** : Java est conçu avec des mécanismes de sécurité intégrés, renforcés par les vérifications effectuées par la JVM lors de l’exécution.\n",
" - **Richesse des Bibliothèques** : Java offre une vaste collection de bibliothèques standard, facilitant le développement d'applications variées et complexes.\n",
"\n",
"- **Inconvénients**\n",
" - **Performance** : L'interprétation du bytecode et les vérifications effectuées par la JVM peuvent entraîner des ralentissements lors de l'exécution des programmes Java.\n",
" - Les JVM, comme HotSpot, intègrent des techniques d'optimisation à la volée pour améliorer les performances, mais elles peuvent ne pas suffire dans les cas où la vitesse est critique.\n",
" - Pour des performances maximales, les développeurs peuvent choisir des langages comme C ou C++.\n",
" - L'intégration de code natif en Java est possible mais au prix de la portabilité de l'application.\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "c04b0f5a",
"metadata": {},
"source": [
"::: {.content-visible when-profile=\"notes\"}\n",
"Java présente plusieurs avantages significatifs pour le développement logiciel. Tout d'abord, sa portabilité est une caractéristique majeure grâce au bytecode Java, qui peut s'exécuter sur n'importe quelle machine virtuelle Java (JVM), garantissant ainsi une compatibilité sur divers systèmes d'exploitation. De plus, Java est reconnu pour sa sécurité robuste, intégrant des mécanismes de vérification lors de l'exécution par la JVM pour prévenir les failles potentielles. En outre, Java dispose d'une vaste bibliothèque standard qui facilite le développement d'applications complexes en offrant des fonctionnalités prêtes à l'emploi pour divers domaines.\n",
"\n",
"Cependant, Java est confronté à des défis en matière de performance. L'interprétation du bytecode Java ainsi que les vérifications effectuées par la JVM peuvent entraîner des ralentissements par rapport à des langages compilés directement en code machine. Bien que des techniques d'optimisation à la volée comme HotSpot soient intégrées dans les JVM pour améliorer les performances, celles-ci peuvent ne pas toujours être suffisantes pour les applications nécessitant une réactivité maximale. Pour de telles exigences, les développeurs peuvent opter pour des langages comme C ou C++, qui offrent des performances optimisées au prix d'une portabilité potentiellement réduite lors de l'intégration de code natif avec Java.\n",
":::"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e6e730f3-b276-4a33-bc23-5f484245b87e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 9,
"id": "9bdcb388-8687-4ef3-b306-1db98e2504dd",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 10,
"id": "00b4bea6-559c-48d2-9762-2a35028bb081",
"metadata": {},
"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
}