Ce glossaire réunit des définitions succinctes de termes importants de ce cours. ## Abstraction #todo ## Abstraire #todo ## Accesseur [[#Encapsulation (programmation orientée objet)|L'encapsulation]] d'une [[#Classe|classe]] interdit d'accéder à ses attributs depuis l'extérieur, mais elle autorise d'y accéder indirectement via des [[#Méthode|méthodes]]. Les méthodes jouant ce rôle sont appelées des **accesseurs**. On distingue les **accesseurs en lecture** des **accesseurs en écriture**. Dans la convention [[#Javabean]], - les accesseurs en lecture sont les "getters" - les accesseurs en écriture sont les "setters" ```java class Point{ private int x; private int y; public int getX() { return x; } public void setX(int x) { this.x = x; } } ``` > [!warning] Code smell potentiel : [[Data Class]] 👃 ## Android Android est un SDK et un système d'exploitation pour le développement d'applications mobiles. ## Antipattern Une **erreur courante** de conception de logiciels. Peut aussi être une [[#Heuristique|heuristique]] ou un [[#Design Pattern|patron de conception]] qui n'est **pas/plus considéré** comme étant généralement recommandé. https://fr.wikipedia.org/wiki/Antipattern Voir aussi [[#Code smell]] ## API > En informatique, une interface de programmation d’application ou [[#Interface (programmation)|interface]] de programmation applicative, souvent désignée par le terme API pour « Application Programming Interface » en anglais, est un ensemble **normalisé** de [[#Classe|classes]], de [[#Méthode|méthodes]], de [[#Fonction|fonctions]] et de [[#Constante|constantes]] qui sert de façade par laquelle un logiciel offre des services à d'autres logiciels. > > — https://fr.wikipedia.org/wiki/Interface_de_programmation ## Attribut (d’une classe) Les **attributs** d’un objet ou d’une classe sont des données **encapsulées** à l'intérieur. On parle aussi de **variables d’instance** ou parfois de **propriétés** d’un objet. ```java class Canard { String couleur="vert"; } ``` Ex. la classe `Canard` contient un [[#Attribut (d’une classe)|attribut]] `couleur` ## Bibliothèque > En informatique, une bibliothèque logicielle est une collection de routines, qui peuvent être déjà compilées et prêtes à être utilisées par des programmes[1],[ > > — https://fr.wikipedia.org/wiki/Biblioth%C3%A8que_logicielle ## Bloc Un groupe de zéro, une ou plusieurs instructions entourées d'une paire d'accolades {...} ```java if( ... ){ // Bloc if } else { // bloc else } ``` Pour plus de détails, voir [[Encapsulation en Java#Portée lexicale (blocs)]] ## Bytecode #todo ## Charge cognitive https://fr.wikipedia.org/wiki/Charge_cognitive ## Classe Une classe est : - L’implémentation complète ou partielle d’un [[#Type|type]] composé - Un mécanisme pour construire des objets si [[#Implémentation|l’implémentation]] est complète. - Une unité d’organisation du code. ```java class Canard { String couleur="vert"; String crier(){ return "Coin coin!"; } } ``` Ex. la classe `Canard` contient un [[#Attribut (d’une classe)|attribut]] `couleur` et une [[#Méthode|méthode]] `crier()`. ## Classe abstraite ## Compatibilité de type #todo ## Constructeur Un constructeur est une [[#Méthode|méthode]] particulière d'une [[#Classe|classe]] permettant de [[#Instance / instancier|l'instancier]]. C'est à dire de créer une concrétisation (une [[#Instance / instancier|instance]]) de celle-ci sous la forme d'un [[#Objet|objet]]. ## Clojure Un [[#Paradigme de programmation fonctionnelle|langage de programmation fonctionnelle]] s'appuyant sur la [[#JVM]]. ## Code smell Les code smells sont des [[#Heuristique|heuristiques]] permettant à partir de **symptômes** reconnus de **détecter des problèmes potentiels** dans du code. Les code smells sont souvent associées à des techniques de [[#Refactoring|refactoring]] permettant d'en supprimer ou mitiger les effets néfastes. https://fr.wikipedia.org/wiki/Code_smell https://www.martinfowler.com/bliki/CodeSmell.html https://www.sammancoaching.org/reference/code_smells/index.html Voir aussi [[#Antipattern]] ## Cohésion ## Commentaire de code Les commentaires sont du texte ignorés par le compilateur à destination des humains. Les commentaires en Java commencent par // ou /* > Thus, programs must be written for people to read, and only incidentally for machines to execute. > > — Harold Abelson and Gerald Jay Sussman with Julie Sussman — Structure and Interpretation of Computer Programs - [Code Tells You How, Comments Tell You Why](https://blog.codinghorror.com/code-tells-you-how-comments-tell-you-why/) Jeff Atwood - [When comments go bad](https://blog.codinghorror.com/when-good-comments-go-bad/) Jeff Atwood ## Composition #todo ## Constante Une **constante** est un [[#Identifiant (ou nom)|identificateur]] associé à une **valeur fixe**. Syntaxiquement, cet identificateur a tous les aspects d'une [[#Variable|variable]]. Cependant, il lui est affecté une valeur définitive, c'est-à-dire constante. En java, les constantes sont des variables `final static`. La [[#Convention de nommage|convention de nommage]] est le `SCREAMING_SNAKE_CASE`. ```java final static int AGE_DU_CAPITAINE = 40; ``` https://fr.wikipedia.org/wiki/Variable_(informatique) ## Contrat d'interface #todo ## Convention de nommage #todo ## Couche d’abstraction #todo ## Couplage #todo ## Délégation #todo ## Dépendance #todo ## Design Pattern > Les patrons de conception sont des **solutions classiques** à des **problèmes récurrents** de la **conception de logiciels**. Ce sont des sortes de plans ou de schémas que l’on peut **personnaliser** afin de résoudre un problème récurrent dans notre code. Pour plus de détails, voir [[_Design Patterns]]. ## Eclipse (IDE) #todo ## Éditeur de code #todo ## Encapsuler (programmation) En programmation, de façon générale, on parle d'encapsuler pour désigner le fait de grouper ensemble des instructions et/ou des données. Ex. - encapsuler des instructions dans une fonction - encapsuler des données et des méthodes dans un objet ## Encapsulation (programmation orientée objet) > En programmation (orientée objet), **l’encapsulation** désigne le **regroupement de données** avec un ensemble de [[#Routine|routines]] qui en permettent la lecture et la manipulation. > > Ce principe est souvent accompagné du **masquage** de ces données brutes afin de s’assurer que l’utilisateur ne contourne pas [[#Interface (programmation)|l’interface]] qui lui est destinée. L’ensemble se considère alors comme une **boîte noire** ayant un comportement et des propriétés spécifiés. > > — https://fr.wikipedia.org/wiki/Encapsulation_(programmation) Voir aussi : [[Encapsulation en Java]] ## Énumération #todo https://fr.wikipedia.org/wiki/Type_%C3%A9num%C3%A9r%C3%A9 ## Environnement de développement intégré En abbrégé : [[#IDE]] Exemples d'environnements de développement intégrés - [[#Eclipse (IDE)]] - [[#IntelliJ Idea]] ## Espaces blancs Tous les caractères qui ne sont pas visibles (espace, tabulation, saut de ligne, etc.) ## État d’un objet L'état d'un [[#Objet|objet]] correspond aux valeurs de l'ensemble de ses [[#Attribut (d’une classe)|attributs]] à un moment donné. ```java class Canard{ String humeur; String couleur; public Canard(){ this.humeur="content"; this.couleur="vert"; } public quandIlVoitUnAutreCanard(){ this.humeur = "fâché"; } } ``` ex. lors de son instanciation, l'état du `Canard` est `humeur="content"` et `couleur="vert"` Quand il voit un autre canard, l'état du `Canard` est `humeur="fâché"` et `couleur="vert"` ## Fonction Une routine qui permet de grouper des instructions exécutées de façon séquentielles. Elle peut prendre des paramètres et retourner une valeur. En Java le concept de fonction n'existe pas vraiment indépendamment des classes. Ce qui y ressemblerait le plus serait une [[#Méthode statique]]. ## Garbage collector https://dev.java/learn/classes-objects/creating-objects/#garbaging ## Gestionnaire de dépendances Outil permettant de télécharger et d'intégrer des [[#Dépendance|dépendances]] internes ou [[#Tierce-partie (dépendance)|tierce-parties]], d'en maintenir les versions et d'empaqueter un projet. Voir aussi : [[#Maven]], [[#Gradle]] ## Gradle Gradle est un [[#Gestionnaire de dépendances|gestionnaire de dépendances]] pour java et d'autres langages. Il est beaucoup utilisé dans le cadre de développement mobile avec [[#Android|Android]]. ## Groovy #todo ## Heap (memory space) Voir [[#Tas (zone de mémoire)]] ## Heuristique > Un principe qui **fonctionne dans plusieurs situations**, mais qui n'est **pas systématiquement vrai ou précis**. Je préfère parler d'heuristiques (au sens de ["Rule of thumb"](https://fr.wikipedia.org/wiki/Rule_of_thumb)) plutôt que de "~~bonnes pratiques~~" ou de "~~best practices~~". Il s'agit souvent de pratiques ou de raccourcis en réduisant la [[#Charge cognitive|charge cognitive]] pour **prendre des décisions** qui fonctionnent plutôt bien la plupart du temps... ...sauf quand ils ne fonctionnent pas. ## Héritage #todo ## Héritage de type Voir [[#Sous typage]] ## Héritage d’implémentation L'héritage définit des **relations hiérarchiques** entre les classes, de sorte que les **attributs** et **méthodes communs** peuvent être **réutilisés**. > [!example] Exemple de hiérarchie de classes : Listes > ![[ex-heritage-implementation-listes.png|319x221]] Voir l'article détaillé : [[Héritages en Java]] https://dev.java/learn/inheritance/polymorphism/ ## IDE Voir [[#Environnement de développement intégré]] ## Identifiant (ou nom) Un mot qui se réfère à quelque chose dans un programme (comme une [[#Variable|variable]] , un nom de [[#Fonction|fonction]]) ou de [[#Classe|classe]]. ```java var canard = "Coin coin"; ``` Ex. L'identifiant de la variable est `canard` ## Interface (mot-clé Java) En Java, une interface désigne une forme particulière de classe que l’on déclare à l’aide du mot clé `interface` et qui contient seulement la [[#Signature de méthode|signature]] de ses [[#Méthode|méthodes]], pas leur [[#Implémentation|implémentation]]. On peut donc dire qu’une interface en Java est une classe qui se réduit à la spécification d’un [[#Type|type]] (ce qui est conforme à l’acception d’[[#Interface (programmation)|interface en programmation orientée objet]]). ## Interface (programmation) Voir [[#API|API]] ## Instance / instancier Une **instance** d'une classe est un **objet** qui a été **instancié** par l'appel du **constructeur** de la classe à l'aide du mot-clé `new`. ```java Date aujourdhui = new Date(); ``` Ex. L'**objet** `aujourdhui` est une **instance** de la classe `Date` ## Instruction Une action unique, une étape d'un [[#Programme informatique|programme informatique]] (comme afficher du texte). ## Implémentation La concrétisation d'une [[#Abstraction|abstraction]] par du code. Ex. - Un [[#Objet|objet]] est la concrétisation d'une [[#Classe|classe]] ## IntelliJ Idea #todo ## Interopérabilité #todo ## Invoquer (méthode) #todo ## Jar Unité de déploiement (bibliothèque) pouvant être intégrée dans un autre programme Java ou servant de point d'entrée à la commande `java`. ## Java #todo ## javac #todo ## Java Flight Recorder #todo ## JCP - Java Community Process Program #todo ## JCK - Java Compatibility Kit #todo ## JDK #todo ## JEP - JDK Enhancement Proposals #todo ## JFR Voir [[#Java Flight Recorder]] ## JRE #todo ## JSR - Java Specification Requests #todo ## JVM #todo ## Kotlin #todo ## Long Term Support #todo ## Machine virtuelle #todo ## Maven #todo ## Méthode Une méthode est une [[#Routine|routine]] qui est attachée à une [[#Classe|classe]] ou un [[#Type|type]]. ```java class Canard{ String crier(){ return "Coin coin!"; } } ``` Ex. la **méthode** `crier()` de la **classe** `Canard`. ## Méthode d’instance #todo ## Méthode statique #todo ## Modélisation objet #todo ## Modificateur de visibilité Les modificateurs de visibilité permettent de déterminer si une donnée ou un comportement peut être accédée par une autre partie d'un programme. ## Module (java) #todo https://www.jmdoudoux.fr/java/dej/chap-modules.htm ## Mot‑clé Un mot qui a une signification spéciale dans le langage de programmation (`public`, `class`, et bien d’autres). Ces mots **ne peuvent pas être utilisés** comme noms de variables dans votre propre programme. Voir aussi [[#Mots-clés réservés de Java]] ## Multi-threading #todo ## Objet Les **objets** sont des **[[Glossaire général#Structure de données|structures de données]]** qui *[[Glossaire général#Encapsuler (programmation)|encapsulent]]* des **données ([[Glossaire général#Attribut (d’une classe)|attributs]])** et des **routines ([[Glossaire général#Méthode|méthodes]])** définissant leur comportement. Les valeurs que prennent l’ensemble des attributs d’un objet est [[Glossaire général#État d’un objet|l’état]] de cet objet. ![[dev.java_oop_schema.png|453x272]] ```java Date aujourdhui = new Date(); ``` Ex. L'**objet** `aujourdhui` est une **instance** de la classe `Date` Source : https://dev.java/learn/oop/ ## Objet immuable (immutable) Un objet dont l'état ne peuvent pas être modifiées après la création de l'objet.x Ex. ```java String s="Future"; s.concat(" World"); System.out.println(s); // > Future ``` Voir aussi : https://fr.wikipedia.org/wiki/Objet_immuable L'immuabilité est un concept courant dans le [[#Paradigme de programmation|paradigme]] de [[#Paradigme de programmation fonctionnelle|programmation fonctionnelle]] ## OOP Abbréviation de [[#Paradigme de programmation orientée objet]] ## Package (Java) #todo ## Paradigme de programmation ## Paradigme de programmation fonctionnelle #todo ## Paradigme de programmation orientée objet #todo ## Pile (structure de données) Un tableau rempli partiellement sur lequel on ne fait que des opérations empiler et dépiler est une **structure de données** fondamentale de l'informatique que l'on appelle une **pile** (**stack** en anglais). L'accès aux données contenues dans cette structure de données se fait dans l'ordre "Dernier arrivé, premier servi" (Last-In-First-Out (LIFO)). ## Pile (zone de mémoire) La **zone de mémoire de pile** en Java est utilisée pour **l'allocation de mémoire statique** et **l'exécution d'un thread**. Elle contient des **valeurs primitives** spécifiques à une **méthode** et les **références** vers les objets auxquels la méthode se réfère. à des objets référencés par la méthode qui se tiennent dans un tas. L'accès à cette mémoire se fait via une structure de données de type [[#Pile (structure de données)|pile]] (d'où son nom) dans l'ordre "Dernier arrivé, premier servi" (Last-In-First-Out (LIFO)). Chaque fois que nous appelons une nouvelle méthode, un nouveau bloc est créé au-dessus de la pile qui contient des valeurs spécifiques à cette méthode, comme des variables primitives et des références à des objets. Lorsque la méthode termine l'exécution, la zone de mémoire dans la pile correspondant est libérée, le flux d'exécution retourne à la méthode d'appel et l'espace devient disponible pour la méthode suivante. ## Zones de mémoire Pour exécuter une application de manière optimale, La [[#JVM]] divise la mémoire entre la zone de [[#Pile (zone de mémoire)|pile]] (stack) et la zone du [[#Tas (zone de mémoire)|tas]] (heap) en mémoire de pile. Chaque fois que nous déclarons de nouvelles variables et de nouveaux [[#Objet|objets]], appelons une nouvelle [[#Méthode|méthode]], déclarons une chaîne de caractères ou effectuons des opérations similaires, la JVM désigne [[#Zones de mémoire|la zone de mémoire]] où se situent ces opérations à partir de la mémoire de **pile** ou de **l'espace de tas**. ## Polymorphisme > En informatique et en théorie des [[#Type|types]], le polymorphisme, du grec ancien polús (plusieurs) et morphê (forme), est le concept consistant à fournir une [[#Interface (programmation)|interface]] unique à des entités pouvant avoir différents types. > > — https://fr.wikipedia.org/wiki/Polymorphisme_(informatique) Ex. Polymorphisme par sous-typage ```java String chaine = "Hello"; Integer entier = 1; Object c = chaine; Object e = entier; // String et Integer sont des sous-types de Object // Ils partagent la définition de ses méthodes // dont toString() c.toString(); e.toString(); ``` Ex. Polymorphisme ad hoc (Surcharge de méthode) ```java int add(int a, int b){ return a + b; } double add(double a, double b){ return a + b; } double sommeEntiers = add(1, 2); double sommeDecimaux = add(1.45, 2.54); ``` Ex. Polymorphisme paramétrique ```java List<Integer> entiers = new ArrayList<Integer>(); List<Double> decimaux = new ArrayList<Double>(); entiers.add(1); entiers.add(2); decimaux.add(1.5); decimaux.add(2.5); ``` Article détaillé : [[Polymorphismes en Java]] ## POO Abbréviation [[#Paradigme de programmation orientée objet]] ## Portabilité #todo ## Programmation concurrente #todo ## Programme informatique Une séquence **d’[[#Instruction|instructions]]**, qui sont exécutées les unes après les autres de manière prévisible.  **Le flux séquentiel** est la séquence d’instructions la plus courante et la plus simple, dans laquelle les instructions sont exécutées dans l’ordre où elles sont écrites de haut en bas de façon séquentielle ## Record (java) Un [[#Sucre syntaxique]] permettant de déclarer une classe ayant des propriétés d'[[Immuabilité et non-modifiable|immuabilité]]. ```java record Personne(Adresse adress, String name) { } ``` Voir aussi : [[Immuabilité et non-modifiable#Record]] ## Refactoring Modifier **la structure de code** sans en affecter le **comportement visible**. https://www.martinfowler.com/books/refactoring.html ## Ramasse-miettes Voir [[#Garbage collector]] ## Rétro-compatibilité #todo ## Routine > En informatique, une **routine** est une entité informatique qui [[#Encapsuler (programmation)|encapsule]] une portion de code (une séquence d'instructions) effectuant un traitement spécifique bien identifié (asservissement, tâche, calcul, etc.) relativement indépendant du reste du programme. > > — https://fr.wikipedia.org/wiki/Routine_(informatique) Voir aussi : [[#Fonction]], [[#Méthode]] ## Scala #todo ## Sdkman #todo ## Signature de méthode La **signature d'une [[#Méthode|méthode]]** est définie par : - Le **[[#Identifiant (ou nom)|nom]]** de la méthode - Le **[[#Type|type]] de retour** - La **liste des paramètres** (le type et l'ordre des paramètres, mais pas le nom des paramètres). ![[signature-methode.png|500]] ## Sous typage Aussi appelé polymorphisme d'inclusion. C'est le fait de créer des [[#Sous-type|sous-types]] à partir d'un ou plusieurs types. En Java, les mécanismes de sous-typage sont : - L'héritage simple (mot-clé `extends`) - L'héritage d'interface (mot-clé `implements`) ## Sous-type Pour un type `T`, un sous-type `ST` est un type pour lequel toutes les opérations de `T` sont définies. Autrement dit, ce qu'on sait faire sur un [[#Type|type]], on doit également savoir le faire sur un de ses [[#Sous-type|sous-types]]. ## Stack (memory space) Voir [[#Pile (zone de mémoire)]] ## Structure de données https://fr.wikipedia.org/wiki/Structure_de_donn%C3%A9es ## Sucre syntaxique Une [[#Syntaxe|syntaxe]] qui permet de simplifier l'écriture de code. C'est une forme d'[[#Abstraction]]. Ex1. la boucle for améliorée ```java for (String color : colors) { System.out.println(color); } ``` Est un sucre syntaxique de la boucle for classique. ```java for (int i = 0; i < colors.size(); i++) { String color = colors.get(i); System.out.println(color); } ``` ## Surcharge de méthode La **surcharge** permet de créer plusieurs version d’une même méthode. Les [[Glossaire général#Méthode|méthodes]] de surcharge doivent porter le même [[Glossaire général#Identifiant (ou nom)|nom]] de méthode mais peuvent avoir un type de retour et/ou des paramètres différents. ```java public String greet(){ return "Hello World"; } public String greet(String recipient){ return "Hello "+recipient; } ``` ## Syntaxe Un ensemble de **règles** qui définissent comment un code doit être écrit pour **être valide**; Java a sa propre syntaxe ## Tas (zone de mémoire) **L'espace de tas** est utilisé pour **l'allocation de mémoire dynamique** des **[[#Objet|objets]]** Java et des **[[#Classe|classes]]** JRE **au moment de l'exécution** (runtime). Les nouveaux objets sont toujours créés dans un espace de tas, et les [[#Type référence (Java)|références]] à ces objets sont stockées dans la mémoire de [[#Pile (zone de mémoire)|pile]]. Voir aussi : [[#Zones de mémoire]] ## Thread-safe #todo ## Tierce-partie (dépendance) #todo ## Typage Vérifie que les expressions appartiennent bien à leur domaine de définition. Ex. - `1` appartient au domaine des entiers positifs - `[1, 2, 3]` n'appartient pas au domaine des entiers positifs (c'est un tableau) ## Typage fort https://fr.wikipedia.org/wiki/Typage_fort ## Typage dynamique Typage réalisé pendant **l'exécution**. ## Typage statique Typage réalisé pendant **la compilation**. ## Type Le **type** d'une [[#Variable|variable]] définit la manière dont elle est représentée en mémoire et les opérations que l'on peut faire dessus. ```java String texte = "hello"; ``` Ici, le type de la variable `texte` est `String` https://fr.wikipedia.org/wiki/Type_(informatique) ## Type primitif (Java) #todo ## Type référence (Java) #todo ## Type énuméré Voir [[#Énumération]] ## Type générique [Generic Types](https://dev.java/learn/generics/) ## UML > Le Langage de Modélisation Unifié, de l'anglais **Unified Modeling Language** (UML), est un langage de **modélisation graphique** à base de pictogrammes conçu comme une méthode normalisée de visualisation dans les domaines du développement logiciel et en conception orientée objet. https://fr.wikipedia.org/wiki/UML_(informatique) ## Variable En informatique, les **variables** sont des **espaces mémoire** "élémentaires" qui associent un [[#Identifiant (ou nom)|nom (l'identifiant)]] à une **valeur**. ```java int entier = 1; ``` Dans la plupart des langages et notamment les plus courants, les variables peuvent changer de valeur au cours du temps (dynamique). Dans les langages de certains paradigmes, notamment la programmation fonctionnelle, leur valeur est au contraire figée dans le temps (statique). Les variables sont utilisées par un programme informatique pour mémoriser certaines données nécessaires au fonctionnement du programme. https://fr.wikipedia.org/wiki/Variable_(informatique) ## Variable `final` #todo ## Variable globale Une [[Glossaire général#Variable|variable]] est dite **globale** quand elle peut être accédée (voire même modifiée) partout dans un programme. C'est une pratique très souvent considérée comme un [[#Code smell]]. ```java public class UneClasse { public static String variableGlobale; } ``` > [!note] Parfois utilisé pour performance > C'est parfois utilisé malgré tout dans certains types de programmes et certains contextes particuliers pour des raisons de performance. > > Évitons [[Premature Optimization|l'optimisation prématurée]] ## Verbosité Certains [[#Sucre syntaxique|sucres syntaxique]] permettent de réduire la verbosité.