Ce glossaire réunit des définitions succinctes de termes importants sur ce site. ## Abstraction (en programmation orientée-objet) Dans le contexte [[#Paradigme de programmation orientée objet|orienté objet]], l'abstraction est **un mécanisme**, ou une pratique, servant à **réduire le code d'un niveau de détail**. Autrement dit, l'abstraction permet de **regrouper** un certain nombre de **classes** selon des **caractéristiques communes**. `Forme.java` ```java public abstract class Forme{ protected int origine; //en pixel protected int hauteur; //en pixel protected int largeur; //en pixel public abstract double Aire(); public abstract double Perimetre(); // ... } ``` `Rectangle.java` ```java public class Rectangle extends Forme{ // ... } ``` `Cercle.java` ```java public class Cercle extends Forme { //.. } ``` ## Abstraire Abstraire consiste à preserver **les informations qui sont pertinentes** dans un contexte donné et **d'oublier les informations qui ne sont pas pertinentes** dans ce contexte. ## 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; } } ``` ## Android Android est un [[#SDK]] et un système d'exploitation pour le développement d'applications mobiles. La plupart des applications pour Android fonctionnent sur [[#JVM|la JVM]] et sont codées en [[#Kotlin]] ou en [[#Java]]. ## 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` ## Base de données relationnelle #todo ## 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 [[3.3 - Encapsulation en Java#Portée lexicale (blocs)]] ## Bytecode Le résultat de compilation de code Java. On trouve le bytecode dans les fichiers `.class` Il est interprété par la [[#JVM]] et traduit en instructions à destination les plateformes cibles (macOS , Windows, Linux, ...). ## Charge cognitive (théorie en psychologie 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 #todo ## Classpath Le **classpath** est un ou plusieurs dossiers ou la commande java s'attend à trouver des fichiers .java, des classes, des ressources ou des bibliothèques externes. On doit le définir quand on exécute la commande `java`. Ex. Si le code est présent dans un sous-dossier (souvent `src` ou `src/main/java`), il faut l'indiquer à la commande `java` avec l'argument `-classpath` Compilation d'un fichier java ```sh javac src/Main.java ``` Le fichier .class correspondant se retrouve dans le dossier `src` ```text . └── src ├── Main.class ├── Main.java ``` On doit spécifier que `src` fait partie du classpath pour que la commande java trouve le code : ```sh java -classpath src Main ``` ## Clojure Un [[#Paradigme de programmation fonctionnelle|langage de programmation fonctionnelle]] s'appuyant sur la [[#JVM]]. ![[clojure-logo.png|60x60]] Le logo de Clojure Voir : https://clojure.org/ ## Compatibilité de type #todo ## Compilation #todo ## Complexité en espace > En algorithmique, la complexité en espace est une mesure de l'espace utilisé par un algorithme, en fonction de propriétés de ses entrées. L'espace compte le nombre maximum de cases mémoire utilisées simultanément pendant un calcul. Par exemple le nombre de symboles qu'il faut conserver pour pouvoir continuer le calcul Source : Wikipedia : https://fr.wikipedia.org/wiki/Complexit%C3%A9_en_espace ## 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]]. ## 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 #todo ## 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 La composition consiste à utiliser des [[#Objet]] comme [[#Attribut (d’une classe)]] d'autres objets. C'est une façon de réutiliser du code. Ex. ```java class Ligne { Point origine; Point fin; } ``` ## 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 Un contrat qui définit un ensemble de méthodes et données publiques qu'une abstraction expose pour qu'on l'utilise. Il définit également le comportement attendu par le code d'implémentation de l'abstraction. Ex. La [[#Signature de méthode]] définit le contrat d'interface pour l'appeler. Ex. Une [[#Interface (mot-clé Java)]] définit les signatures des méthodes pour l'utiliser ainsi que les comportements attendus des classes qui l'implémentent. ## Convention de nommage Une convention de nommage est une règle qu'on se fixe pour s'assurer que des personnes différentes écrivent du code de la même façon. Exemple de quelques conventions de code courantes en Java: - les noms de [[#Variable|variables]], [[#Méthode|méthodes]] sont écrites en style [[#camelCase]] - les noms de [[#Type référence (Java)|types référence]] sont écrits en [[#PascalCase]] - les noms de[[#Constante[[#Constante|constantes]] sont écrits en [[#SCREAMING_SNAKE_CASE]] Voir : https://www.jmdoudoux.fr/java/dej/chap-normes-dev.htm ## Couche d’abstraction - **Couche d'abstraction logicielle** : --- - **Couche d'abstraction matérielle** : un logiciel intermédiaire entre le système d'exploitation et le matériel informatique. Il offre des fonctions standardisées de manipulation du matériel informatique tout en **cachant les détails techniques** de la mise en œuvre. ## Couplage #todo ## Debugger #todo ## Délégation #todo https://en.wikipedia.org/wiki/Delegation_pattern ## Dépendance Les dépendances (ou paquets) sont une archive qui peut contenir des sources, exécutables et ressource pouvant être assemblées depuis un autre logiciel. https://fr.wikipedia.org/wiki/Paquet_(logiciel) ## 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) Eclipse est un [[#Environnement de développement intégré]] pour Java libre et gratuit. ## Écoconception numérique #todo ## Éditeur de code Un éditeur de code est un outil qui permet de lire, écrire et modifier du code. Il dispose de fonctionnalités de manipulation de texte avancées et de coloration syntaxique de code. Il est plus simple qu'un [[#Environnement de développement intégré]] qui ajoute des fonctionnalités avancées. ## 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 : [[3.3 - Encapsulation en Java]] ## Énumération Une énumération (ou type énuméré) est un type dont l'ensemble des valeurs edt prédéterminé à l'avance. Ex. ```java public enum Couleur { ROUGE, VERT, BLEU } ``` Utilisation ```java Couleur c = Couleur.VERT; ``` Peut être utilisé dans un [[#Switch]] ```java switch (c){ case ROUGE : { IO.println("Rouge"); break; } case VERT : { IO.println("Vert"); break; } case BLEU : { IO.println("Bleu"); break; } } ``` 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 Le Garbage Collector (ou GC) est le mécanisme qui permet de libérer la memoire qui est allouée dynamiquement en Java. 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 Groovy est un langage de programmation fonctionnant sur la [[#JVM]]. Voir https://fr.wikipedia.org/wiki/Groovy_(langage) ## GUI > En informatique, une **interface graphique** (en anglais **GUI** pour graphical user interface) ou un environnement graphique est un **dispositif de dialogue homme-machine**, dans lequel les objets à manipuler sont dessinés sous forme de pictogrammes à l'écran, de sorte que l'usager peut les utiliser en imitant la manipulation physique de ces objets avec un dispositif de pointage, le plus souvent une souris. https://fr.wikipedia.org/wiki/Interface_graphique ## 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 (théorie en psychologie 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é : [[3.4 - 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` ## Impacts environnementaux du numérique #todo ## Inférence de type - mot-clé `var` L'inférence de type consiste à déduire le [[#Type|type]] d'une [[Glossaire#Variable|variable]] depuis sa valeur. En java, le **mot-clé** `var` permet **d'inférer** le type d'une variable sans avoir à l'écrire de façon explicite. ```java // Les écritures suivantes sont équivalentes String texte = "Hello World!"; var texte = "Hello World!"; ``` ```java // Les écritures suivantes sont équivalentes int entier = 1; var entier = 1; ``` ```java // Les écritures suivantes sont équivalentes double decimal = 3.7; var decimal = 3.7; ``` ## Ingénieurie logicielle "The application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software." — IEEE Standard Glossary of Software Engineering Terminology ## 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]] ## Interface graphique Voir [[#GUI]] ## 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 (en programmation orientée-objet)|abstraction]] par du code. Ex. - Un [[#Objet|objet]] est la concrétisation d'une [[#Classe|classe]] - OpenJdk est une implémentation du JDK - SQLite une base de donnée qui implémente la spécification SQL ## 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 ## Javadoc #todo ## Java Flight Recorder #todo ## JavaFx #todo ## JCP - Java Community Process Program #todo ## JCK - Java Compatibility Kit #todo ## JDK Le **Java Development Kit** (JDK) désigne le [[#Sdk]] permettant de développer en [[#Java]]. Autrement dit, l'ensemble de **bibliothèques logicielles de base** du langage de programmation Java, ainsi que **les outils** avec lesquels le code Java peut être **compilé**, transformé en **bytecode** destiné à la **machine virtuelle Java**. https://fr.wikipedia.org/wiki/Java_Development_Kit ## JDBC #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 ## Langage compilé #todo ## Langage interprété #todo ## Machine virtuelle #todo ## Maintenabilité #todo ## Maven Gradle est un [gestionnaire de dépendances](app://obsidian.md/index.html#Gestionnaire%20de%20d%C3%A9pendances) pour java et d'autres langages. Il est beaucoup utilisé dans le cadre de développement en entreprise et en open-source. ## 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#Structure de données|structures de données]]** qui *[[Glossaire#Encapsuler (programmation)|encapsulent]]* des **données ([[Glossaire#Attribut (d’une classe)|attributs]])** et des **routines ([[Glossaire#Méthode|méthodes]])** définissant leur comportement. Les valeurs que prennent l’ensemble des attributs d’un objet est [[Glossaire#É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]] ## OpenRewrite #todo https://docs.openrewrite.org/ ## Open-source #todo ## Package (Java) #todo ## Paradigme de programmation Un **style de programmation** avec des principes spécifiques, chaque paradigme générant des codes logiciels de **structure différente**. ## 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é : [[3.5 - Polymorphismes en Java]] ## POO Abbréviation [[#Paradigme de programmation orientée objet]] ## Portabilité #todo ## Portée lexicale #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 ## Réutilisation de code #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 ## SceneBuilder #todo ## SDK Software Development Kit (ou SDK). Fait référence à un ensemble d'outils permettant de developper pour une plateforme ou un langage de programmation donné. En [[#Java]], le SDK s'appelle le [[#JDK]]. ## 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 (en programmation orientée-objet)|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#Méthode|méthodes]] de surcharge doivent porter le même [[Glossaire#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 Les génériques permettent aux [[#Type|types]] ([[#Classe|classes]] et [[#Interface (mot-clé Java)|interfaces]]) d'être des **paramètres** lors de la définition de classes, d'interfaces et de méthodes. Les paramètres de type vous offrent un moyen de [[#Réutilisation de code|réutiliser le même code]] avec des entrées différentes. En Java, les types générique sont la façon de faire du [[Glossaire#Polymorphisme|polymorphisme]] paramétrique. Exemple d'utilisation d'un type générique ```java List<String> strings = new ArrayList<String>(); List<Integer> integers = new ArrayList<Integer>(); ``` Voir tutoriel Java : [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` Le mot-clé `final` Permet d'indiquer qu'une variable ou un attribut ne peut plus être affecté une deuxième fois. Ex. ```java ``` ## Variable globale Une [[Glossaire#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 [[Optimisation prématurée|l'optimisation prématurée]] ## Variable locale #todo ## Verbosité On dit qu'un langage est verbeux lorsqu'il nécessite d'écrire beaucoup de texte ou de code pour faire quelque-chose. Certains [[#Sucre syntaxique|sucres syntaxique]] permettent de réduire la verbosité.