{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "title: \"Les bases du langage Java\"\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", "metadata": {}, "source": [ "## Les Types en Java\n", "\n", "Java est un langage **fortement typé**. Chaque variable et chaque expression a un type défini à la compilation.\n", "\n", "### Types Primitifs\n", "* **Booléen : boolean** (1 bit) : Vrai ou faux\n", "* **Entiers :** byte (1 octet), short (2 octets), int (4 octets), long (8 octets)\n", "* **Flottants :** float (4 octets), double (8 octets)\n", "* **Caractère : char** (2 octets, Unicode)\n", "\n", "### Références\n", "* **Pointent vers des objets**\n", "* **Incluent :** classes, interfaces, tableaux\n", "\n", "**Remarque :**\n", "* Les types primitifs sont stockés directement dans la variable.\n", "* Les références stockent l'adresse mémoire de l'objet.\n", "\n", "```java\n", "int age = 30; // Type primitif\n", "String nom = \"Dupont\"; // Référence à un objet de type String\n", "```\n", "\n", "## Les identificateurs en Java\n", "\n", "Les identificateurs sont les noms que nous attribuons aux différents éléments de notre code Java (classes, variables, méthodes, etc.).\n", "\n", "* **Définition:** Un identificateur est une séquence de caractères utilisée pour nommer un élément dans un programme.\n", "* **Règles de formation:**\n", " * **Début:** Doit commencer par une lettre (majuscule ou minuscule) ou un underscore (_).\n", " * **Suite:** Peut contenir n'importe quelle combinaison de lettres, de chiffres et d'underscores.\n", " * **Caractères:** Privilégier les caractères ASCII pour une meilleure portabilité. Les caractères Unicode sont autorisés.\n", "* **Restrictions:**\n", " * **Mots-clés:** Ne doit pas être un mot-clé réservé du langage (ex: `int`, `class`, `public`).\n", " * **Constantes:** Ne doit pas être identique à `true`, `false` ou `null`.\n", " * **Casse:** Java est sensible à la casse (exemple: `age` et `Age` sont différents).\n", "\n", "## Les Constantes en Java\n", "\n", "Une constante est une valeur qui ne peut pas être modifiée une fois initialisée. Elles sont généralement déclarées avec le mot-clé `final`.\n", "\n", "* **Types de constantes:**\n", " * **Numériques:**\n", " * **Entières:**\n", " * **long:** Suffixé par `L` (exemple: `long MAX_VALUE = Long.MAX_VALUE;`)\n", " * **int:** Sans suffixe (exemple: `int MAX_INT = 2147483647;`)\n", " * **Flottantes:**\n", " * **double:** Sans suffixe (exemple: `double PI = 3.14159;`)\n", " * **float:** Suffixé par `f` (exemple: `float EPSILON = 1e-6f;`)\n", " * **Caractères:** Un caractère Unicode entre simples quotes (exemple: `char SEPARATEUR = ',';`)\n", " * **Booléennes:** `true` et `false` (exemple: `boolean EST_VALIDE = true;`)\n", " * **Références:** `null` (indique une absence de référence)\n", "\n", "```java\n", "final int AGE_MINIMAL = 18;\n", "final double TAUX_TVA = 0.2;\n", "```\n", "\n", "## Les Objets et les Références en Java\n", "\n", "### Les Objets\n", "Un objet est une instance d'une classe. Il représente une entité réelle ou conceptuelle avec ses propres attributs (champs) et comportements (méthodes).\n", "\n", "### Les Références\n", "Une référence est une valeur qui pointe vers un objet en mémoire. Elle est stockée dans une variable.\n", "\n", "* **null:** Une référence peut avoir la valeur `null`, indiquant qu'elle ne pointe vers aucun objet.\n", "* **Opérateurs sur les références:**\n", " * **Accès aux champs:** `objet.champ`\n", " * **Appel de méthodes:** `objet.methode()`\n", " * **Transtypage (cast):** `(Type)objet`\n", " * **Concaténation de chaînes:** `chaine + objet` (appelle `objet.toString()`)\n", " * **instanceof:** Vérifie si un objet est d'un certain type (`objet instanceof Type`)\n", " * **Comparaison:** `==` compare les références (si elles pointent vers le même objet), `!=` compare l'inverse.\n", " * **Opérateur conditionnel:** `condition ? valeurSiVraie : valeurSi fausse`\n", "\n", "## La Classe Object en Java\n", "\n", "La classe `Object` est la classe de base de toutes les classes en Java. Cela signifie que toutes les classes, même si vous ne les en faites pas explicitement hériter, héritent indirectement de `Object`.\n", "\n", "### Rôle de la classe Object\n", "* **Classe racine:** Tous les objets en Java sont des instances de `Object` ou de ses sous-classes.\n", "* **Méthodes de base:** Fournit un ensemble de méthodes de base que toutes les classes peuvent utiliser ou redéfinir.\n", "\n", "### Méthodes principales de Object\n", "* **getClass():** Retourne un objet de type `Class` représentant la classe de l'objet courant. Cette méthode est utilisée pour l'introspection, c'est-à-dire pour obtenir des informations sur la classe d'un objet à l'exécution.\n", "* **toString():** Retourne une représentation sous forme de chaîne de caractères de l'objet. Par défaut, elle retourne le nom de la classe suivi de son hashcode.\n", "* **equals(Object obj):** Détermine si deux objets sont égaux. Par défaut, elle compare les références (c'est-à-dire si les deux objets sont le même objet).\n", "* **hashCode():** Retourne un code hash, un entier qui sert à placer les objets dans des structures de données comme les `HashMap`.\n", "* **clone():** Crée une copie de l'objet. Cette méthode doit être redéfinie dans les sous-classes pour permettre le clonage.\n", "* **finalize():** Méthode appelée par le garbage collector juste avant de détruire un objet. Elle est rarement utilisée et peut entraîner des comportements imprévisibles.\n", "\n", "## Les Variables en Java (1/2)\n", "\n", "En Java, les variables sont utilisées pour stocker des données. Leur portée et leur durée de vie varient en fonction de leur type.\n", "\n", "### Les différents types de variables\n", "\n", "| Type de variable | Portée | Durée de vie | Initialisation |\n", "|---|---|---|---|\n", "| Instance | Toute la classe | Par instance | Déclaration ou constructeur |\n", "| Classe | Toute la classe | Une fois par classe | Lors du chargement de la classe |\n", "| Locale | Bloc | Pendant le bloc | Déclaration |\n", "| Tableau | Tableau | Tant que le tableau existe | Lors de la création du tableau |\n", "| Paramètre de méthode | Méthode | Pendant la méthode | Passage d'arguments |\n", "| Paramètre de constructeur | Constructeur | Pendant le constructeur | Passage d'arguments |\n", "| Paramètre d'exception | Bloc catch | Pendant le bloc catch | Capture d'exception |\n", "\n", "## Variables finales en Java\n", "\n", "* **Immutable après initialisation.**\n", "* **Référence finale:** pointe toujours vers le même objet, mais l'état de l'objet peut changer.\n", "* **Variable d'instance finale:** constante par instance.\n", "* **Initialisation obligatoire:** avant toute utilisation.\n", "* **Valeurs par défaut:** 0 pour les numériques, false pour les booléens, null pour les références.\n", "\n", "**Pourquoi ?**\n", "* **Fiabilité.**\n", "* **Lisibilité.**\n", "* **Optimisation.**\n", "\n", "**Exemple:**\n", "```java\n", "final double PI = 3.14159;\n", "```\n", "\n", "## Familles de méthodes en Java\n", "\n", "Les méthodes en Java peuvent être classées en différentes familles selon leur rôle et leur visibilité :\n", "\n", "* **Accesseurs et modificateurs :** Permettent respectivement de lire et de modifier les attributs d'un objet.\n", "* **Méthodes privées :** Utilisées en interne à une classe, elles ne sont pas accessibles depuis l'extérieur.\n", "* **Méthodes publiques :** Constituent l'interface de la classe, elles sont accessibles depuis n'importe où.\n", "\n", "## Surcharge de méthodes\n", "\n", "**Définition:** La surcharge consiste à définir plusieurs méthodes dans une même classe portant le même nom mais ayant des signatures différentes.\n", "\n", "**Signature d'une méthode:** La signature d'une méthode est composée de :\n", "* **Nom de la méthode:** Le nom qu'on utilise pour appeler la méthode.\n", "* **Liste des paramètres:** Le nombre et le type des paramètres que la méthode prend en entrée.\n", "\n", "**Important:** Le type de retour ne fait pas partie de la signature. Deux méthodes ne peuvent donc pas être surchargées uniquement en changeant leur type de retour.\n", "\n", "## Exemple \n", "\n", "```Java\n", "public class Voiture {\n", " // Instance variables\n", " private String immatriculation; // Vehicle registration number\n", " private String marque; // Brand\n", " private boolean enMarche; // Running status\n", "\n", " // Constructors\n", " public Voiture(String immatriculation, String marque) {\n", " this.immatriculation = immatriculation;\n", " this.marque = marque;\n", " this.enMarche = false; // Initialize running status to false\n", " }\n", "\n", " public Voiture(String immatriculation) {\n", " this(immatriculation, \"\");\n", " }\n", "\n", " // Modifiers\n", " public void setMarque(String marque) {\n", " this.marque = marque;\n", " }\n", "\n", " // Accessors\n", " public String getImmatriculation() {\n", " return immatriculation;\n", " }\n", "\n", " public String getMarque() {\n", " return marque;\n", " }\n", "\n", " public boolean isEnMarche() {\n", " return enMarche;\n", " }\n", "\n", " // Methods\n", " public void demarrer() {\n", " if (!enMarche) {\n", " enMarche = true;\n", " System.out.println(\"La voiture démarre.\");\n", " } else {\n", " System.out.println(\"La voiture est déjà en marche.\");\n", " }\n", " }\n", "\n", " public void arreter() {\n", " if (enMarche) {\n", " enMarche = false;\n", " System.out.println(\"La voiture s'arrête.\");\n", " } else {\n", " System.out.println(\"La voiture est déjà arrêtée.\");\n", " }\n", " }\n", "}\n", "```" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "VoitureString immatriculationString marqueboolean enMarcheVoiture(String immatriculation, String marque)Voiture(String immatriculation)void setMarque(String marque)String getImmatriculation()String getMarque()boolean isEnMarche()void demarrer()void arreter()" ], "text/plain": [ "VoitureString immatriculationString marqueboolean enMarcheVoiture(String immatriculation, String marque)Voiture(String immatriculation)void setMarque(String marque)String getImmatriculation()String getMarque()boolean isEnMarche()void demarrer()void arreter()" ] }, "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", " - String immatriculation\n", " - String marque\n", " - boolean enMarche\n", " + Voiture(String immatriculation, String marque)\n", " + Voiture(String immatriculation)\n", " + void setMarque(String marque)\n", " + String getImmatriculation()\n", " + String getMarque()\n", " + boolean isEnMarche()\n", " + void demarrer()\n", " + void arreter()\n", "}\n", "@enduml\n", " \"\"\"; \n", "\n", "IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n", "return null; " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "voiture1immatriculation : \"AA-123-BB\"marque : \"Renault\"enMarche : truevoiture2immatriculation : \"CC-456-DD\"marque : \"Peugeot\"enMarche : false" ], "text/plain": [ "voiture1immatriculation : \"AA-123-BB\"marque : \"Renault\"enMarche : truevoiture2immatriculation : \"CC-456-DD\"marque : \"Peugeot\"enMarche : false" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "//| output: true\n", "//| echo: false\n", "//| label: fig-uml-objets-voiture\n", "//| fig-cap: \"Les Voiture en UML\"\n", "//| fig-format: svg\n", "// PRINT SCHEMA\n", "String script=\"\"\"\n", "@startuml\n", "object voiture1 {\n", " immatriculation : \"AA-123-BB\"\n", " marque : \"Renault\"\n", " enMarche : true\n", "}\n", "\n", "object voiture2 {\n", " immatriculation : \"CC-456-DD\"\n", " marque : \"Peugeot\"\n", " enMarche : false\n", "}\n", "@enduml\n", " \"\"\"; \n", "\n", "IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n", "return null; " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Les paramètres en Java : Passage par valeur\n", "\n", "* En Java, tous les paramètres sont passés par valeur.** Cela signifie qu'une copie de la valeur de chaque argument est transmise à la méthode appelée.\n", "\n", "* Cas particuliers des références\n", "\n", " * **Modification de la référence:** Si on tente de modifier la valeur de la référence elle-même à l'intérieur d'une méthode, cette modification n'aura aucun effet en dehors de cette méthode.\n", " * **Modification de l'objet référencé:** Si on modifie les propriétés de l'objet référencé par la référence passée en paramètre, ces modifications seront visibles en dehors de la méthode, car on travaille sur l'objet d'origine.\n", "\n", "### Exemple\n", "\n", "```java\n", "class Voiture {\n", " private String immatriculation;\n", " private String marque;\n", "\n", " // ... constructeurs et getters/setters ...\n", "}\n", "\n", "public class Parametres {\n", " public static void main(String[] args) {\n", " Voiture uneVoiture = new Voiture(\"1234 AB 83\");\n", " uneVoiture.setMarque(\"Rolls-Royce\");\n", "\n", " // La méthode changeMarque modifie l'objet uneVoiture\n", " changeMarque(uneVoiture);\n", " System.out.println(uneVoiture); // Affiche toujours \"Rolls-Royce\"\n", "\n", " // La méthode abandonner ne modifie pas la référence uneVoiture\n", " abandonner(uneVoiture);\n", " System.out.println(uneVoiture); // Affiche toujours l'objet, même si la référence locale a été mise à null\n", " }\n", "\n", " private static void abandonner(Voiture v) {\n", " v = null; // Cette modification n'a pas d'effet sur uneVoiture\n", " }\n", "\n", " private static void changeMarque(Voiture v) {\n", " v.setMarque(\"Fiat\"); // Modifie l'objet uneVoiture\n", " }\n", "}\n", "```\n", "\n", "## Méthodes et variables de classe\n", "\n", "* Variables de classe (statiques)\n", "\n", " * **Déclaration:** Utiliser le mot-clé `static` pour déclarer une variable appartenant à la classe elle-même plutôt qu'à une instance particulière.\n", " * **Constantes de classe:** Lorsqu'une variable de classe est déclarée `final`, elle devient une constante pour l'ensemble du programme.\n", " * **Initialisation:** Les variables de classe sont initialisées lors du chargement de la classe.\n", " * **Accès:** Elles peuvent être accédées directement depuis la classe, sans avoir besoin d'instancier un objet.\n", "\n", "* Méthodes de classe (statiques)\n", "\n", " * **Invocation:** S'appellent directement à partir de la classe (e.g., `NomDeLaClasse.nomDeLaMethode()`).\n", " * **Contexte:** Ne peuvent accéder qu'à des variables et méthodes statiques.\n", " * **Signature:** Ne peuvent pas avoir la même signature qu'une méthode d'instance.\n", "\n", "### Bloc statique\n", "\n", "* **Initialisation complexe:** Utilisé pour effectuer des initialisations complexes de variables de classe, qui ne peuvent pas être faites directement dans la déclaration.\n", "* **Exécution:** S'exécute une seule fois, lors du chargement de la classe.\n", "\n", "### Pourquoi utiliser les méthodes et variables de classe ?\n", "\n", "* **Partage:** Les variables de classe sont partagées par toutes les instances de la classe.\n", "* **Utilitaires:** Les méthodes de classe peuvent être utilisées sans créer d'instance.\n", "* **Constantes:** Les constantes de classe sont idéales pour des valeurs qui ne changent jamais.\n", "\n", "### Exemple 1\n", "\n", "```java\n", "public class MathUtils {\n", " public static final double PI = 3.14159;\n", "\n", " static {\n", " System.out.println(\"La classe MathUtils est chargée\");\n", " }\n", "\n", " public static int factorielle(int n) {\n", " // ...\n", " }\n", "}\n", "```\n", "\n", "### Exemple 2\n", "\n", "```{Java}\n", "public class Chien {\n", " // Attributs\n", " private String tatouage; // Tatouage unique du chien\n", " private String nom; // Nom du chien\n", " private static int nbChiens = 0; // Nombre total de chiens créés\n", " private static final int NB_REFUGES = 3; // Nombre de refuges\n", " private static int[] occupationRefuge = new int[NB_REFUGES]; // Occupation des refuges (-1: libre, 0: occupé)\n", "\n", " // Constructeur\n", " public Chien(String tatouage, String nom) {\n", " this.tatouage = tatouage;\n", " this.nom = nom;\n", " nbChiens++; // Incrémente le nombre de chiens à chaque création\n", " }\n", "\n", " // Méthodes statiques pour gérer les informations globales\n", " public static int getNbChiens() {\n", " return nbChiens;\n", " }\n", "\n", " // Méthode pour ajouter un chien à un refuge (on incrémente l'occupation)\n", " public static boolean ajouterChienAuRefuge(int numeroRefuge) {\n", " if (numeroRefuge < 0 || numeroRefuge >= NB_REFUGES) {\n", " System.err.println(\"Numéro de refuge invalide\");\n", " return false;\n", " } else occupationRefuge[numeroRefuge]++;\n", " return true;\n", " }\n", "\n", " // Méthode pour enlever un chien d'un refuge (on décrémente l'occupation)\n", " public static boolean enleverChienDuRefuge(int numeroRefuge) {\n", " if (numeroRefuge < 0 || numeroRefuge >= NB_REFUGES) {\n", " System.err.println(\"Numéro de refuge invalide\");\n", " return false;\n", " } else if (occupationRefuge[numeroRefuge] > 0) {\n", " occupationRefuge[numeroRefuge]--;\n", " return true;\n", " } else {\n", " System.err.println(\"Le refuge est déjà vide\");\n", " return false;\n", " }\n", " } \n", "\n", " // Bloc statique pour initialiser le tableau des refuges\n", " static {\n", " for (int i = 0; i < NB_REFUGES; i++) {\n", " occupationRefuge[i] = -1;\n", " }\n", " }\n", "}\n", "```\n", "\n", "## Protection en Java : Niveaux d'accès\n", "\n", "* Le principe de base\n", "\n", "En Java, la protection d'un élément (méthode ou attribut) définit l'ensemble des entités qui peuvent y accéder. **Cette protection s'applique au niveau de la classe et non de l'objet.**\n", "\n", "* Les différents niveaux d'accès\n", "\n", "| Modificateur | Dans la même classe | Dans le même package | Dans un sous-package | Depuis une autre classe |\n", "|---|---|---|---|---|\n", "| **private** | Oui | Non | Non | Non |\n", "| **(aucun)** | Oui | Oui | Non | Non |\n", "| **protected** | Oui | Oui | Oui | Non (sauf si sous-classe) |\n", "| **public** | Oui | Oui | Oui | Oui |\n", "\n", "\n", "### Exemple concret\n", "\n", "```java\n", "public class Personne {\n", " /**\n", " * Le nom de la personne.\n", " * Cet attribut est privé pour garantir l'encapsulation des données.\n", " */\n", " private String nom;\n", "\n", " /**\n", " * L'âge de la personne.\n", " * Cet attribut est protégé pour permettre l'accès aux sous-classes.\n", " */\n", " protected int age; \n", "\n", " /**\n", " * L'adresse de la personne.\n", " * Cet attribut est public pour être accessible de n'importe où.\n", " */\n", " public String adresse;\n", "\n", " /**\n", " * Le numéro de téléphone de la personne.\n", " * Cet attribut est accessible uniquement depuis le même package.\n", " */\n", " String telephone; \n", "\n", " // ... méthodes ...\n", "}\n", "```\n", "\n", "## Structure d'un programme Java\n", "\n", "* Un programme Java est un ensemble de **classes**. Chaque classe définit un nouveau type d'objet. Pour qu'un programme soit exécutable, il doit contenir au moins une classe avec une méthode `main`.\n", "\n", "* La méthode `main` : le point d'entrée\n", "\n", "* **Signature:** `public static void main(String[] args)`\n", " * `public` : accessible de partout\n", " * `static` : appartient à la classe, pas à une instance\n", " * `void` : ne retourne rien\n", " * `String[] args` : tableau de chaînes de caractères pour les arguments en ligne de commande\n", "\n", "### Exemple : un programme simple\n", "\n", "```java\n", "public class BonjourATous {\n", " public static void main(String[] args) {\n", " System.out.println(\"Bonjour à tous !\");\n", " }\n", "}\n", "```\n", "\n", "## L'instanciation et les constructeurs\n", "\n", "* **L'instanciation**, c'est créer un objet (un instance) à partir d'une classe.\n", "\n", "* **Le constructeur** est une méthode spéciale qui :\n", " * A le même nom que la classe.\n", " * Est appelée automatiquement lors de la création d'un objet.\n", " * Sert à initialiser les attributs de l'objet.\n", " * Ne retourne aucune valeur.\n", " * Peut être surchargé.\n", "\n", "* **Syntaxe d'instanciation:**\n", " ```java\n", " Classe nomDeLaVariable = new Classe(paramètres);\n", " ```\n", "\n", "### Le constructeur par défaut\n", "\n", "* **Création automatique:**\n", " * Si vous ne définissez pas de constructeur, le compilateur en crée un par défaut.\n", " * Il est sans paramètres.\n", " * Il a la même visibilité que la classe.\n", " * Il initialise les attributs à leurs valeurs par défaut (null, 0, etc.).\n", "\n", " ```java\n", " public class Personne {\n", " private String nom;\n", " private int age;\n", " // Constructeur par défaut créé implicitement\n", " }\n", "\n", " Persone personne = new Personne();\n", " ```\n", "\n", "### Le constructeur paramétré\n", "\n", "* **Définition explicite:**\n", " * Vous pouvez définir un ou plusieurs constructeurs avec des paramètres.\n", " * Permet d'initialiser les attributs avec des valeurs spécifiques lors de la création de l'objet.\n", " * Si vous définissez un constructeur, le constructeur par défaut n'est plus créé automatiquement.\n", " * Vous pouvez toujours définir un constructeur sans paramètres si nécessaire.\n", " * Vous pouvez également définir plusieurs constructeurs avec des paramètres différents (surcharge).\n", "\n", "```java\n", "public class Personne {\n", " private String nom;\n", " private int age;\n", "\n", " // Constructeur paramétré\n", " public Personne(String nom, int age) {\n", " this.nom = nom;\n", " this.age = age;\n", " }\n", "\n", " // Constructeur surchargé\n", " public Personne(String nom) {\n", " this(nom, -1); // Appelle le constructeur principal avec age = -1\n", " }\n", "}\n", "```\n", "\n", "## Les références en Java : un lien vers l'objet\n", "\n", "* **Qu'est-ce qu'une référence ?**\n", " * C'est une variable qui pointe vers un objet en mémoire.\n", " * Elle ne contient pas l'objet lui-même, mais son adresse.\n", "* **Allocation en mémoire (heap):**\n", " * Lors de l'instanciation avec `new`, la mémoire est allouée dans le heap.\n", " * La référence obtenue pointe vers cette zone.\n", "* **Destruction des objets (Garbage Collector):**\n", " * Pas de destructeur explicite en Java.\n", " * Les objets sont détruits automatiquement lorsqu'ils ne sont plus référencés.\n", "* **Passage de références en paramètre:**\n", " * Une copie de la référence est passée.\n", " * Les deux références pointent vers le **même objet**.\n", "* **Modifications de l'objet:**\n", " * Toute modification via une référence est visible par les autres.\n", "* **Durée de vie d'un objet:**\n", " * Tant qu'au moins une référence pointe vers lui.\n", " * Le garbage collector libère la mémoire lorsqu'il n'y a plus de références.\n", "\n", "### Exemple\n", "\n", "```Java\n", "class RamasseMiette {\n", " public static void main(String[] args) {\n", " { // Bloc pour limiter la portée de chien1\n", " Chien chien1 = new Chien(\"X1\", \"Rex\");\n", " // chien1 sera collecté à la fin de ce bloc\n", " }\n", "\n", " // Création d'un grand tableau pour consommer de la mémoire\n", " int[] grandTableau = new int[1000000]; // Simule une grosse consommation mémoire\n", "\n", " // Boucle infinie (pour observer le comportement du GC)\n", " while (true) {\n", " // Rien à faire ici, juste attendre que le GC s'exécute\n", " }\n", " }\n", "}\n", "```\n", "\n", "## Le ramasse-miettes en Java : un gestionnaire de mémoire automatique\n", "\n", "* **Qu'est-ce que c'est ?**\n", " * Mécanisme automatique de libération de la mémoire.\n", " * Identifie les objets inutilisés et les détruit.\n", "* **Pourquoi l'utiliser ?**\n", " * **Sécurité:** Évite les fuites mémoire.\n", " * **Simplicité:** Délégation de la gestion mémoire à la JVM.\n", "* **Comment ça marche ?**\n", " * **Algorithmes:** Mark and Sweep, Copying, Generational.\n", " * **Déclenchement:**\n", " * Lorsqu'il y a un manque de mémoire.\n", " * À intervalles réguliers.\n", "* **La méthode `finalize()`**\n", " * **Invocation:** Juste avant la destruction d'un objet.\n", " * **Utilité:** Pour effectuer des opérations de nettoyage.\n", " * **Limitations:**\n", " * Ne garantit pas la destruction.\n", " * Appelée une seule fois.\n", " * À utiliser avec précaution.\n", "* **Forcer le ramasse-miettes (mauvaise idée)**\n", " ```java\n", " Runtime.getRuntime().gc();\n", " ```\n", "\n", "## Les tableaux en Java : un aperçu\n", "\n", "* **Un tableau est un objet**\n", " * Instancié avec `new`\n", " * Possède des propriétés (comme `length`)\n", "* **Taille dynamique**\n", " * Déclarée sans taille précise\n", " * Taille définie à la création avec `new`\n", "* **Indexation à partir de 0**\n", " * Premier élément : `tableau[0]`\n", "* **Initialisation**\n", " * **Avec des valeurs par défaut:** Toutes les valeurs sont initialisées à zéro (pour les types numériques), à `null` (pour les références).\n", " * **Avec des valeurs explicites:** Lors de la déclaration.\n", "* **Accès à la taille**\n", " * Propriété `length` : donne le nombre d'éléments du tableau.\n", "* **Instanciation des éléments**\n", " * **Tableau de primitives:** Les éléments sont des valeurs primitives.\n", " * **Tableau de références:** Le tableau contient des références vers des objets. Instancier le tableau ne crée pas les objets eux-mêmes.\n", "\n", "### Exemple:\n", "```java\n", "int[] mesEntiers = new int[3]; // Tableau de 3 entiers\n", "String[] mesChaines = {\"Bonjour\", \"monde\"}; // Tableau de 2 chaînes\n", "Voiture[] mesVoitures = new Voiture[3]; // Tableau de 3 références vers des objets Voiture\n", "```\n", "\n", "## Les chaînes de caractères en Java : un aperçu\n", "\n", "* **Les chaînes sont des objets**\n", " * Instance de la classe `String`\n", " * Immuables : une fois créée, une chaîne ne peut pas être modifiée\n", "* **Littéraux**\n", " * Écrits entre guillemets doubles (`\"`)\n", " * Deux littéraux identiques référencent le même objet\n", "* **Opérations de base**\n", " * **Concaténation:** Opérateur `+`\n", " * **Comparaison:** Méthodes `equals()` et `compareTo()`\n", "* **Immuabilité**\n", " * Une chaîne ne peut pas être modifiée après sa création\n", " * Toute opération de modification crée une nouvelle chaîne\n", "* **Chaînes modifiables**\n", " * **StringBuffer:** Synchronisée, adaptée à un environnement multi-thread\n", " * **StringBuilder:** Non synchronisée, plus performante en mono-thread\n", "\n", "### Exemple\n", "```java\n", "String message = \"Hello\"; // Création d'une chaîne\n", "message = message + \" world\"; // Création d'une nouvelle chaîne\n", "StringBuilder sb = new StringBuilder(\"Hello\");\n", "sb.append(\" world\"); // Modification du StringBuilder\n", "```\n", "\n", "## Enveloppement des types primitifs en Java\n", "\n", "* **Pourquoi des classes d'enveloppement ?**\n", " * **Traiter les types primitifs comme des objets:** Permet d'utiliser des méthodes, de les placer dans des collections, etc.\n", " * **Utiliser des constantes prédéfinies:** Par exemple, `Integer.MAX_VALUE`.\n", " * **Effectuer des conversions de types:** Entre types primitifs et leurs équivalents objet.\n", "* **Les classes d'enveloppement**\n", " * **Byte, Short, Integer, Long:** Pour les nombres entiers\n", " * **Float, Double:** Pour les nombres à virgule flottante\n", " * **Boolean:** Pour les booléens\n", " * **Character:** Pour les caractères\n", "* **Utilisations courantes**\n", " * **Autoboxing et unboxing:** Conversion automatique entre types primitifs et leurs classes d'enveloppement.\n", " * **Méthodes statiques:** Pour accéder à des constantes ou effectuer des conversions.\n", " * **Collections:** Les collections en Java ne peuvent contenir que des objets.\n", "\n", "### Exemple\n", "\n", "```java\n", "int age = 30;\n", "Integer ageObj = age; // Autoboxing\n", "int agePrimitive = ageObj; // Unboxing\n", "System.out.println(Integer.MAX_VALUE); // Utilisation d'une constante\n", "```\n", "\n", "## Expressions, Instructions et Blocs en Java\n", "\n", "* **Expression**\n", " * Combinaison de variables, opérateurs et appels de méthode\n", " * Évalue à une valeur unique\n", " * Exemples : `x + 5`, `Math.sqrt(9)`, `a == b`\n", "* **Instruction**\n", " * Unité exécutable\n", " * Types :\n", " * Affectation : `x = 5;`\n", " * Appel de méthode : `System.out.println(\"Hello\");`\n", " * Déclaration : `int age = 30;`\n", " * Structure de contrôle : `if`, `for`, `while`, etc.\n", " * Créée à partir d'une expression en ajoutant un `;`\n", "\n", "### Blocs\n", "\n", "* **Bloc**\n", " * Groupe d'instructions délimité par `{}`\n", " * Utilisations :\n", " * Corps de méthodes\n", " * Corps de structures de contrôle\n", " * Délimiter la portée des variables\n", "\n", "### Exemple\n", "\n", "```java\n", "int x = 10; // Déclaration et affectation\n", "if (x > 5) { // Bloc if\n", " System.out.println(\"x est supérieur à 5\"); // Instruction dans le bloc\n", "}\n", "```\n", "\n", "## Branchements : Instruction `switch`\n", "\n", "* **Fonctionnalité:** Exécute différents blocs de code en fonction de la valeur d'une expression.\n", "* **Types de valeurs:** Entiers, chaînes de caractères, énumérations\n", "* Java 14: Le switch a été amélioré en Java 14, permettant une syntaxe plus concise et des fonctionnalités supplémentaires.\n", "\n", "```java\n", "switch (expression) {\n", " case valeur1:\n", " // Instructions à exécuter si expression == valeur1\n", " break;\n", " case valeur2:\n", " // Instructions à exécuter si expression == valeur2\n", " break;\n", " default:\n", " // Instructions à exécuter si aucune correspondance\n", "}\n", "```\n", "\n", "### Exemple\n", "\n", "```java\n", "// Utilisation avec une énumération\n", "public enum Jour { LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE }\n", "Jour j = Jour.SAMEDI;\n", "switch (j) {\n", " case LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI:\n", " System.out.println(\"Jour de semaine.\");\n", " break;\n", " case SAMEDI, DIMANCHE:\n", " System.out.println(\"Jour de fin de semaine.\");\n", " break;\n", " default:\n", " System.out.println(\"Un nouveau jour ?\");\n", " }\n", "```\n", "\n", "```java\n", "// Utilisation avec une chaîne de caractères\n", " String j = \"Samedi\";\n", " switch (j) {\n", " case \"Lundi\", \"Mardi\", \"Mercredi\", \"Jeudi\", \"Vendredi\":\n", " System.out.println(\"Jour de semaine.\");\n", " break;\n", " case \"Samedi\", \"Dimanche\":\n", " System.out.println(\"Jour de fin de semaine.\");\n", " break;\n", " default:\n", " System.out.println(\"Un nouveau jour ?\");\n", " }\n", "```\n", "\n", "## Boucles While, Do-While et For en Java\n", "\n", "```java\n", "Chien[] mesChiens = {new Chien(\"C1\", \"Rex\"), new Chien(\"C2\", \"Medor\"), new Chien(\"C3\", \"Pluto\")};\n", "int chienCourant = 0;\n", "\n", "while (chienCourant < mesChiens.length) {\n", " System.out.println(mesChiens[chienCourant++]);\n", "}\n", "```\n", "\n", "```java\n", "for (int i = 0; i < args.length; i++) {\n", " System.out.print(i == args.length - 1 ? args[i] + \"\\n\" : args[i] + \", \");\n", "}\n", "```\n", "* Le premier exemple (Listing 13) utilise une boucle While pour parcourir un tableau d'objets Chien et en afficher les informations.\n", "* Le second exemple (Listing 14) utilise une boucle For pour itérer sur un tableau d'arguments de la ligne de commande et les afficher.\n", "\n", "## Boucles ForEach en Java\n", "\n", "```java\n", "Chien[] mesChiens = {new Chien(\"C1\", \"Rex\"), new Chien(\"C2\", \"Medor\"), new Chien(\"C3\", \"Pluto\")};\n", "\n", "for (Chien c : mesChiens) {\n", " System.out.print(c + \" \");\n", "}\n", "```\n", "\n", "* La syntaxe `for (Chien c : mesChiens)` permet d'itérer sur chaque élément du tableau et de l'assigner à la variable temporaire `c`.\n", "* Plus concise et lisible que les boucles for traditionnelles pour parcourir des tableaux.\n", "* Améliore la maintenabilité du code.\n", "\n", "\n", "## Les paquetages en Java\n", "\n", "* **Organisation hiérarchique:**\n", " * Les classes Java sont regroupées dans des **paquetages** (packages).\n", " * Cette organisation crée une structure arborescente similaire à un système de fichiers.\n", "\n", "* **Déclaration d'un paquetage:**\n", " * Le mot-clé `package` suivi du nom du paquetage est placé en début de fichier.\n", " * **Exemple:**\n", " ```java\n", " package mon.paquet;\n", " ```\n", "\n", "* **Nom complet d'une classe:**\n", " * Composé du nom du paquetage suivi du nom de la classe, séparés par des points.\n", " * **Exemple:** `mon.paquet.MaClasse`\n", "\n", "* **Utilisation des classes:**\n", " * **Dans le même paquetage:** On utilise simplement le nom de la classe.\n", " * **Dans un autre paquetage:**\n", " * **Import complet:** `import mon.paquet.MaClasse;`\n", " * **Import de toutes les classes:** `import mon.paquet.*;` (par défaut, `java.lang.*` est importé)\n", "\n", "* **Pourquoi utiliser des paquetages ?**\n", " * **Organisation du code:** Facilite la gestion de projets de grande taille.\n", " * **Évitement des conflits de noms:** Permet d'avoir des classes avec le même nom dans différents paquetages.\n", " * **Modularité:** Favorise la réutilisation de code et la création de bibliothèques.\n", "\n", "\n", "## La structuration d'un programme : Les paquetages (2/3) - Exemple concret\n", "\n", "* **Paquetage `fr.univtln.bruno.java.animaux`:** Contient les classes représentant les différents types d'animaux.\n", "* **Paquetage `fr.univtln.bruno.java.cages`:** Contient les classes représentant les différents types de cages.\n", "\n", "### Exemple\n", "\n", "```java\n", "package fr.univtln.bruno.java.animaux;\n", "\n", "public class Chat {\n", " // ... (constructeurs, méthodes)\n", " public void miauler() {\n", " System.out.println(\"Miaou\");\n", " }\n", "}\n", "```\n", "\n", "```java\n", "package fr.univtln.bruno.java.cages;\n", "import fr.univtln.bruno.java.animaux.Chat;\n", "public class BoiteAChat {\n", " private Chat pensionnaire;\n", "\n", " public void enfermer(Chat c) {\n", " pensionnaire = c;\n", " }\n", "}\n", "```\n", "\n", "### La structuration d’un programme les paquetages (3/3)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "frunivtlnbrunojavaanimauxcagesChatmiauler()BoiteAChatpensionnaire: Chatenfermer(Chat)" ], "text/plain": [ "frunivtlnbrunojavaanimauxcagesChatmiauler()BoiteAChatpensionnaire: Chatenfermer(Chat)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "//| output: true\n", "//| echo: false\n", "//| label: fig-uml-packages\n", "//| fig-cap: \"Les packages en UML\"\n", "//| fig-format: svg\n", "// PRINT SCHEMA\n", "String script=\"\"\"\n", "@startuml\n", "package fr.univtln.bruno.java.animaux {\n", " class Chat {\n", " - miauler()\n", " }\n", "}\n", "\n", "package fr.univtln.bruno.java.cages {\n", " class BoiteAChat {\n", " - pensionnaire: Chat\n", " + enfermer(Chat)\n", " }\n", "}\n", "\n", "BoiteAChat *-- Chat\n", "@enduml\n", "\"\"\"; \n", "\n", "IJava.getKernelInstance().getMagics().applyCellMagic(\"plantUML\",List.of(),script); \n", "return null; " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Les paquetages standards en Java\n", "\n", "* **Nommage des paquetages:**\n", " * Les noms de paquetages sont généralement des noms de domaine inversés pour éviter les conflits de noms.\n", " * **Exemple:** `fr.univtln.bruno.samples.Voiture`\n", " * **Note:** Les tirets (-) ne sont pas autorisés dans les noms d'identificateurs.\n", "\n", "* **Paquetages standards de Java:**\n", " * **java.lang:** Contient les classes de base du langage (String, Integer, etc.).\n", " * **java.util:** Fournit des utilitaires variés (collections, dates, etc.).\n", " * **java.io:** Permet de gérer les entrées/sorties (fichiers, flux, etc.).\n", " * **java.awt** et **javax.swing:** Utilisés pour créer des interfaces graphiques.\n", " * **java.applet:** Pour développer des applets (moins utilisé aujourd'hui).\n", " * **java.net:** Pour les opérations réseau (sockets, URL, etc.).\n", "\n", "## Les notations\n", "\n", "* **Capitalisation des noms:**\n", " * **Classes:** Commencent par une majuscule (CamelCase). Exemple : `Chien`, `Voiture`.\n", " * **Constantes:** Entièrement en majuscules, mots séparés par des underscores. Exemple : `Chien.NB_REFUGES`.\n", " * **Autres identificateurs:** Commencent par une minuscule, chaque nouveau mot commençant par une majuscule (CamelCase). Exemples : `nbChiens`, `monChien`.\n", "\n", "* **Pourquoi ces conventions ?**\n", " * **Lisibilité:** Facilite la lecture et la compréhension du code.\n", " * **Cohérence:** Rend le code plus uniforme et professionnel.\n", " * **Conformité:** Respecte les standards de l'industrie Java.\n", "\n", "---\n", "\n", "```java\n", " public class Chien {\n", " public static final int NB_REFUGES = 10; // Constante\n", " private String nom;\n", " public void aboyer() {\n", " System.out.println(\"Ouaf !\");\n", " }\n", " }\n", "```\n", "\n", "## La Documentation\n", "\n", "* **L'importance de la documentation:**\n", " * **Pourquoi documenter ?** Pour faciliter la compréhension et la maintenance du code.\n", " * **Comment ?** En utilisant des commentaires spécifiques (Javadoc) placés juste avant les éléments à documenter (classes, méthodes, attributs).\n", "* **Javadoc : l'outil de documentation standard de Java:**\n", " * **Fonctionnement:** Javadoc analyse le code source et les commentaires spécifiques pour générer une documentation HTML.\n", " * **Utilisation:** Il est largement utilisé dans l'industrie, notamment par Oracle pour documenter le JDK.\n", " * **Lien vers la documentation officielle:** http://www.oracle.com/technetwork/java/javase/documentation/javadoc-137458.html\n", "* **Commentaires Javadoc:**\n", " * **Syntaxe:** Ils commencent par `/**` et se terminent par `*/`.\n", " * **Placement:** Ils sont placés juste avant la déclaration de la classe, de la méthode ou de l'attribut à documenter.\n", " * **Tags:** Des tags spécifiques permettent de structurer la documentation (par exemple, `@author`, `@param`, `@return`).\n", "\n", "### Exemple\n", "\n", "```java\n", "/**\n", " * Représente un livre.\n", " *\n", " * @author VotreNom\n", " */\n", "public class Livre {\n", " /**\n", " * Titre du livre.\n", " */\n", " private String titre;\n", "\n", " /**\n", " * Constructeur de la classe Livre.\n", " *\n", " * @param titre Le titre du livre.\n", " */\n", " public Livre(String titre) {\n", " this.titre = titre;\n", " }\n", "\n", " /**\n", " * Retourne le titre du livre.\n", " *\n", " * @return Le titre du livre.\n", " */\n", " public String getTitre() {\n", " return titre;\n", " }\n", "}\n", "```\n", "\n", "## L'organisation (3/3)\n", "\n", "* Proposition de structure typique (sans Maven) :\n", "\n", "```\n", "monProjet/\n", "├── src/\n", "│ ├── java/\n", "│ │ ├── monPackage/\n", "│ │ │ └── MaClasse.java\n", "│ └── resources/\n", "│ ├── config.properties\n", "│ └── messages_fr.properties\n", "├── bin/\n", "├── lib/\n", "│ ├── externalLib.jar\n", "└── README.md\n", "```\n", "\n", "* L'organisation avec Maven : une structure standardisée\n", "\n", "* **Avantages:**\n", " * Structure standardisée et reconnue\n", " * Gestion automatisée des dépendances\n", " * Cycle de vie du projet défini (compilation, tests, packaging)\n", " * Facilité de partage et de collaboration\n", "\n", "```\n", "monProjet/\n", "├── pom.xml\n", "├── src/\n", "│ ├── main/\n", "│ │ ├── java/\n", "│ │ └── resources/\n", "│ └── test/\n", "│ ├── java/\n", "│ └── resources/\n", "└── target/\n", "```\n", "\n", "\n", "## Les fichiers JAR : Packaging d'applications Java\n", "\n", "* **Un programme Java : un ensemble de classes**\n", " * Organisées en paquetages pour une meilleure modularité.\n", "* **Le format JAR : une archive**\n", " * Contient les classes compilées, les ressources (images, etc.) et un manifeste.\n", " * **Avantages:**\n", " * Facilite la distribution.\n", " * Améliore l'organisation.\n", " * Permet l'exécution directe.\n", "* **Structure d'un JAR**\n", " * **Classes:** Le code compilé de l'application.\n", " * **Ressources:** Fichiers non-code utilisés par l'application.\n", " * **Manifeste (META-INF/MANIFEST.MF):** Contient des métadonnées, notamment le point d'entrée de l'application.\n", "* **Utilisation d'un JAR**\n", " * **Ajout au classpath:** Indique au JVM où trouver les classes.\n", " * **Exécution directe:** Si un point d'entrée est spécifié dans le manifeste.\n", "* **Pour aller plus loin:**\n", " * **Tutoriel officiel:** https://docs.oracle.com/javase/tutorial/deployment/jar/" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 7, "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.5+11-LTS" } }, "nbformat": 4, "nbformat_minor": 4 }