Glossaire

Quelques définitions dans ce glossaire sont marquées “terminologie non standard” car il n’y a pas un large accord sur la pratique terminologique en Français. Le terme décrit a toutefois été choisi pour être utilisé dans ce document.

accesseur
(accessor) méthode permettant d’interroger une instance sur la valeur d’une variable membre "encapsulée" (rendue locale à la classe par ex. modificateur private) . Par convention les accesseurs sont de la forme : type getXXX() où XXX est le nom du champ. Voir “mutateur” et la convention correspondante. Dans les forums francophones on trouve l’anglicisme (laxiste) getter.
agrégation
En terme d’analyse : relation “qui possède” ou “ensemble/élément”. Relation de longue durée entre deux objets, mais relation non exclusive; le cycle de vie des deux objets n’est pas nécessairement lié.
allocation
Réservation d’un emplacement en mémoire. (par exemple pour contenir les données liées à un objet). par ex. en java opération new
analyse
Phase de définition de ce qui doit être fait en terme de “métier”.
API
(Application Programming Interface) la liste des accès programmatiques à un module ou à objet d’une classe donnée. En pratique on a tendance à restreindre cette description aux membres et constructeurs qui constituent le “contrat” de type défini par la classe vis à vis des utilisateurs externes à l’équipe de développement.
architecture à trois parties
(three tier architecture) Application(s) éclatée en trois parties distinctes (chaque partie étant éventuellement accessible au travers du réseau). Une partie est chargée de l’interaction utilisateur (avec parfois un peu de logique déportée), une partie centrale est chargée de régler la logique applicative et une autre est constituée du fond de données de l’entreprise. (note: le terme "architecture trois tiers" est un barbarisme à proscrire! Quand il y a quatre parties il n’y a pas quatre "tiers"!)

trois parties: présentation/interactions ; logique "métier"; persistance

association
En terme d’analyse : relation “qui utilise” . Relation entre deux objets liés par la réalisation d’un service.
attribut
Variable membre vue d’un point de vue conceptuel. On a ici une vue plus large puisqu’un attribut peut, par exemple, être en réalité dérivé par calcul (exemple “surface” sera calculé à partir d’autres informations gérées par l’objet)
automatique
Variables propres à un bloc de code -comme une méthode-(paramètres, variables locales). Ces variables (scalaires, références vers des objets) sont allouées sur la pile et ont une “durée de vie” qui ne dépasse pas le temps d’exécution du bloc de code.
champ
voir “variable d’instance”, "variable membre"
classe
Unité de regroupement de données et de codes (agissant éventuellement sur ces données). Certaines classes servent de matrices pour la fabrication d’instances sur ce modèle (de regroupement de données et de code ) d’autres sont un simple regroupement de services (classe n’ayant que des méthodes dites "de classe").
classe abstraite
Une classe qui est utilisée pour représenter un concept abstrait, et à partir de laquelle on ne peut pas créer d’objets. Les méthodes qui sont déclarées sans fournir de définition sont appelées méthodes abstraites . Ces classes sont souvent le résultat d’une décision de mutualisation de services entre des classes analogues : les méthodes concrètes sont partagées et les services génériques sont décrits par des méthodes abstraites.
compilation conditionnelle
Dans certains langages le code source peut contenir des directives permettant de ne compiler certaines parties que sous condition (par exemple paramètre passé au compilateur). Ceci permet de fabriquer différentes version d’un logiciel: par exemple une avec des informations de trace et l’autre , plus performante, sans ces traces. Le code source de Java évite les systèmes de macro-commandes (pour des raisons de lisibilité) mais on peut réaliser des blocs de code qui ne sont pas compilés.
composition
En termes d’analyse : relation “est composé de”.Relation de longue durée entre deux objets, relation exclusive; le cycle de vie des deux objets est lié au sens où si on supprime l’objet contenant on supprime l’objet contenu. Ex. La description du Client “contient” son Adresse.
conception
Phase permettant de définir, à partir de l’analyse, une architecture, des objets techniques qui conduiront au programme réel.
constante

Une valeur qu’on ne peut pas modifier. En Java la notion est relativement complexe, en effet on distingue :

  • les constantes de compile-time (des primitifs scalaires essentiellement)
  • les constantes évaluées au run-time (soit au moment du chargement de la classe, soit au moment de la création de l’instance) Il n’est pas garanti que les champs d’une constante objet soient eux-mêmes constants.
constructeur
Code d’initialisation qui accompagne l’allocation d’une instance.
CallerSensitive
codes dont l’exécution dépend du contexte de définition dans lequel il sont invoqués. Dans un contexte d’héritage le code ne tient pas compte du contexte d’invocation effective mais du contexte dans lequel est défini l’appel (exemple: Class.getResourceAsStream dans une super-classe sera exécuté dans le contexte de cette super-classe et non dans le contexte de la sous-classe qui provoque l’invocation).
conversion
(cast) Transformation effective d’une valeur scalaire d’un type donné dans un autre type . Conversions implicites — nommées également promotions — (par exemple short→int), conversions explicites (par exemple int→ short). En Java le terme anglais cast est également employé pour une opération complètement différente qui est le forçage de type: on demande au compilateur de considérer une donnée comme étant d’un certain type (et cela échoue si cet aspect n’est pas présent dans la donnée considérée). Les forums francophones qui utilisent le barbarisme "caster" aggravent cette ambiguité.
délégation
En termes d’analyse : agrégation permettant à un objet contenant de rendre un service en déléguant sa réalisation à l’objet contenu.
directive
Mot réservé servant à donner des indications de comportement au compilateur. Par exemple package, import. Les directives ne sont pas des instructions exécutables.
dynamicité
Capacité de Java de choisir du code exécutable au run-time : par polymorphisme, par chargement dynamique de classe.
effet de bord

En principe une fonction reçoit des paramètres en entrée et produit un résultat en sortie. La modification de données en dehors de l’espace interne à la fonction constitue un "effet de bord". Sont considérés comme a priori néfastes:

  • Des effets qui modifieraient des paramètres (sauf si ceux-ci n’ont pas de rôle dans la logique métier de l’application et sont des "dispositifs" comme un système d’entrée/sortie).
  • Des effets sur des variables dont l’accès n’est pas limité à un étroit contexte local.
encapsulation
Rendre inaccessible à du code des données ou des services situés dans un autre code.
espace de nom
(terminologie non-standard : décalque de namespace) En général un dictionnaire qui associe un symbole, un “nom” à une entité du langage.
événement
Un objet qui rend compte du fait que “quelque chose s’est produit” au niveau d’un autre objet. Un autre aspect est lié aux conditions de propagation : idéalement l’événement n’est généré que s’il y a quelqu’un qui s’est inscrit pour le récupérer, implicitement le code de traitement ne doit pas bloquer le code qui l’a déclenché. On trouve souvent cette notion dans la programmation des interfaces graphiques (un code veut savoir si on a saisi quelque chose par ex.).
exception
Un objet qui rend compte d’une condition erronée. La propagation de ces objets a un mode particulier: l’émetteur ne connait pas le récepteur. Il doit y avoir en amont dans la pile courante un bloc de code chargé de filtrer les exceptions qui “remontent” la pile. On a ainsi une indépendance entre le code chargé de signaler l’exception et le code chargé de réagir. Un des aspects intéressant de Java est que les exceptions peuvent faire partie du “contrat” d’une méthode ou d’un constructeur et que ce contrat oblige les codes utilisateurs à récupérer les exceptions potentielles (cette qualité est contestée par certains théoriciens -à tort à notre avis-).

la pile d’exécution montre qu’un code C peut renvoyer directement un diagnostic au code A qu’il ne connait pas. Le code A met en place un bloc de récupération de ces diagnostics; si ce bloc n’existe pas l’exception remonte jusqu'à une procédure par défaut de rapport et le Thread meurt

expression
Partie d’une instruction qui s’évalue à l’exécution (opération, appel de méthode, …). L’évaluation d’une expression peut avoir des effets de bord (tel qu’une affectation à une variable), un résultat qui peut être utilisé à son tour comme opérande ou comme argument dans une autre expression, ou même avoir un effet sur l’enchainement des instructions. En C/C++ et en Java l’affectation (opérateur =) est une expression qui rend un résultat (d’où les notations : y =x =z; ou o.m(x=y) )
fabrique
(programmation objet) méthode permettant de fabriquer des objets. Le choix des caractéristiques de l’objet produit peut dépendre de circonstances a priori hors de portée du code appelant (mais connues du code réalisant).
fermeture
(Closure) Forme fonctionnelle qui permet de définir un code "à la volée" dans un autre code. Ce code pourra être affecté à une variable ou à un paramètre pour être plus tard exécuté. C’est une "fermeture" car ce code à la possibilité d’accéder à des variables connues dans le contexte du code de définition. (voir également le terme lambda-expression et voir article wikipedia: anonymous function )
filtre
Dans un flot de donnée un code qui ne remet dans le flot en sortie que des données satisfaisant une condition (par ex. lit des comptes en banque et ne produit que les comptes ayant un solde supérieur à 10000).
fonction
Idéalement code qui lit des paramètres en entrée et rend un résultat. Certaines fonctions ont des "effets de bord" (modifient des données du contexte extérieur). Java ne dispose pas de fonctions (ni de procédures) mais ses méthodes suivent un modèle fonctionnel c’est à dire elles définissent une expression de la forme: res f(listeargs). Java adhère à un modèle avancé qui déclare également les résultats erronés potentiels (clauses throws).
forçage de type
(terminologie non-standard: rend un des sens de l’opérateur cast) En Java opération par laquelle on demande de considérer une référence d’un type donné comme une référence vers un type compatible.
garbage collector
Tâche de fond (thread) de basse priorité qui recherche dans le tas des objets qui ne sont plus référencés (même indirectement) par les piles d’exécution. La mémoire est alors récupérée et, éventuellement “tassée”.
glaneur de mémoire
(terminologie non-standard: extension du “glaneur de cellules” de Lisp. Autre terme: “ramasse-miettes”) voir “garbage collector"
héritage

Deux aspects : conceptuel ou opérationnel.

Aspect conceptuel : relation “est un” ou “est une sorte de”. Peut découler d’une démarche de spécialisation (réutilisation par extension) ou de généralisation (on tente de capturer les points communs entre plusieurs classes)

Aspect opérationnel : les mécanismes d’héritage permettent de mettre en place des définitions différentielles (telle classe est définie par ses différences avec une autre classe, une partie est commune). Une nouvelle classe “hérite” des caractéristiques de sa classe “mère” (même si elle n’a pas toujours accès à tous les éléments -ceux qui sont privés par ex.-), elle peut redéfinir certains comportements ou en rajouter.

héritage multiple

Aspect conceptuel : une classe hérite de plusieurs autres classes distinctes.

Aspect opérationnel : n’existe pas dans certains langages comme Java (permet ainsi de ne pas avoir de règles implicites complexes sur des comportements hérités: tout doit être codé explicitement).

Ieee754
(IEEE = Institute of Electrical and Electronics Engineers) Standard de représentation et de fonctionnement pour les processeurs de calcul en virgule flottante.
implémenter
(terminologie non-standard: le mot n’existe pas en français mais il est retenu ici dans le sens très étroit de la déclaration du mot-clef implements en Java et groovy) Dispositif par lequel une classe déclare connaître la sémantique d’une interface et s’engage à réaliser le contrat de type ainsi défini.
instance
Un objet: entité autonome créée sur le modèle de la classe auquel il appartient. L’objet est responsable de la réalisation de services qu’il rend en gérant son état interne de manière cohérente, éventuellement en collaboration avec d’autres objets.
interface
Le terme a de très nombreux sens en informatique (partout où se trouve une frontière conventionnelle sur laquelle se situent des échanges). Dans les langages à objets modernes le terme à un sens particulier lorsqu’il désigne un type abstrait “pur” c’est à dire un type qui est défini par ce qu’il fait (une liste d’en-têtes de méthodes d’instance abstraites ou de codes faisant uniquement appel à ce méthodes abstraites).
interface homme/machine
(I.H.M. ou en anglais GUI -Graphic User Interface- prononcer gouwï)Tout ce qui permet la communication utilisateur-ordinateur: plus particulièrement la présentation graphique et ses modes d’interaction.
introspection
voir “réflexion/introspection”
javadoc
outil de génération de la documentation directement inscrite dans un code java.
JVM
“Java Virtual Machine”: norme décrivant le comportement d’un exécuteur du pseudo-code Java (et par extension tout exécuteur conforme à cette norme). Il s’agit en fait d’un ”processeur” virtuel qui exécute un code binaire spécifique (le “pseudo-code”), la présence d’un tel émulateur sur une machine permet d’assurer la portabilité du code binaire Java.
liaison dynamique
(équivalent de “virtual method invocation” en argot C\++) Mécanisme qui permet à l’exécution (au runtime) de choisir le “bon” code d’une méthode en fonction du type effectif de l’objet. En Java le type effectif d’une référence (ou d’une variable qui désigne un objet) peut être différent du type déclaré : soit l’objet est d’une sous-classe de la classe demandée soit il est d’une classe qui “implémente” le type d’interface déclaré.
liaison statique
Le compilateur sait établir au compile-time quel est le code ou la donnée qui va être consulté (voir “liaison dynamique”). La redéfinition dans une sous-classe d’un membre qui est en liaison statique (“rupture du lien statique” ou hiding) rend parfois le code obscur.
linéarisation
voir “serialization
littéral

Notation qui permet de décrire une valeur. Pour les primitifs scalaires et les chaînes de caractères une notation qui décrit une constante : 12 12.3 ‘c’ “chaine” sont des littéraux. Déclaration d’un tableau littéral en Java:

int[] tb = {-1, 666} ;
logging
dispositif permettant d'émettre puis de traiter des messages de trace, journalisation, rapport d’erreur. L'émetteur ne connait pas le destinataire qui, seul, sait ce qu’il y a à faire avec ces messages.
membre
Ce qui est directement joignable en passant par une référence de structure, d’instance ou une désignation de classe (cet “accès” se faisant par l’opérateur “.”). Les champs, les méthodes, les classes définies au niveau des déclarations sont des membres : soit des membres de classe (static) soit des membres d’instance (il en va de même pour les membres hérités des super-classes). Les constructeurs et les blocs de premier niveau ne sont pas des membres.
message

Le terme sert à exprimer le “découplage” entre une demande de service et sa réalisation: c’est à dire que celui qui demande un service ne sait pas a priori comment il va être rendu. Cela permet à la fois du contrôle de type (celui à qui on demande le service sait effectivement le rendre) et abstraction, dynamicité et maintenabilité (le code réalisant peut évoluer, le code réalisant peut ne pas être connu au compile-time).

Historiquement le terme vient du caractère interprétatif de certains langages à Objet: la requête était interprété et dans ces langages le polymorphisme recouvrait à la fois possibilité de redéfinition et de surcharge; en Java les deux concepts sont distincts et le polymorphisme n’implique que la redéfinition

méthode d’instance
Méthode appelée comme membre d’une instance (c.a.d objet.methode() ou this.methode()) et qui sert à modifier ou à tirer partie de l’état de l’instance et/ou à permettre d’avoir un comportement polymorphique.
méthode de classe
Méthode membre d’une classe (à appeler de préférence par Classe.methode()) qui est un service général lié à la classe mais qui n’a pas de raison d’être une méthode d’instance (pas de liaison logique avec une instance particulière, pas de recherche de polymorphisme).
modèle structurel
(terminologie non-standard pour rendre pattern) Dispositif abstrait décrivant un modèle d’assemblage de classes permettant d’obtenir une mécanique comportementale particulière. Exemple: le modèle Observer/Observable de Java décrit un classe “observée” pour laquelle des modifications seront signalées aux “observateurs”. (note: le terme trame, comme dans la trame d’une histoire, nous semble aussi possible).
modèle/vue/contrôleur
Un “modèle structurel” qui propose de gérer en parallèle des données applicatives susceptibles d’être modifiées et leur(s) représentation (en général graphique). Imaginons, par exemple, un tableau de données qui sont à la fois modifiées par un processus externe (par ex. d’autres interfaces graphiques qui “partagent” les mêmes données à distance) et modifiées par une interface graphique locale: le modèle sera le tableau de données, la vue l’interface graphique et le controleur assurera les échanges et la cohérence entre les deux,
module
En Java regroupement de packages permettant un niveau supplémentaire d’encapsulation. Les relations entre modules définies par le descriptif (module-info.java) permettent de définir des règles de portée et d'échanges entre parties de code.
mutateur
(terminologie non-standard : décalque de mutator) Méthode permettant de modifier globalement sur une instance la valeur d’un champ dont l’accès est protégé. Par convention les mutateurs sont de la forme : void setXXX(Type)XXX est le nom du champ et et Type le type du champ. Voir “accesseur” et la convention correspondante. (sur les forums francophones on peut trouver l’anglicisme setter).
NaN
(Not A Number) Dans les processeurs de calcul en virgule flottante des configurations de bits spéciales qui permettent de gérer des compte-rendus ou des résultats d’opérations particulières comme 0/0. Un NaN est absorbant pour toutes les opérations et toute comparaison (y compris avec lui même) rend faux. En Java voir les constantes Double.NaN et Float.NaN et méthodes isNaN.
objet
voir “instance”
obsolescence
(deprecation) Entre deux versions d’un langage une partie d’une A.P.I. peut être abandonnée (il apparaît, par ex., qu’à l’usage les spécifications sont fautives).
package

En Java regroupement de classes agissant dans un domaine particulier (les classes d’entrée/sortie, les classes graphiques, etc.). Les codes ainsi regroupés ont entre eux des responsabilités que n’ont pas les codes extérieurs au package. En dehors de tout petits codes de démonstration il est exclu d’avoir des codes hors-package.

Pour éviter des conflits potentiels de nom il est d’usage de préfixer les packages avec le nom internet des organisations (“com.sun”, “org.omg”, etc.)

passage par référence
Dans certains langages de programmation on a la possibilité de passer un paramètre (par ex. à une fonction) qui reste dans l’espace du code appelant. Le code de la fonction peut alors éventuellement modifier la valeur et cette valeur est donc modifiée pour le code appelant. Ce type “d’effet de bord” n’est pas recommandé d’un point de vue théorique mais reste possible.
passage par valeur
Le fait que les paramètres d’une méthode sont copiées sur la pile (à partir de valeurs connues dans le code appelant) et que toute modification de ces valeurs survenue dans le code de la méthode est sans effet sur le code appelant (en principe : voir “passage par référence”).
pattern
voir “modèle structurel”
persistance
Capacité de conserver l’état interne d’un objet y compris entre différentes instances de processus JVM. Un programme pourra par exemple “s’arrêter” et retrouver l’état d’un objet persistant au redémarrage de l’application.
petit-boutien
(référence aux voyages de Gulliver: voir “poids fort/poids faible”, utilisé également pour les formats de date jj/mm/aa)
pile
Partie(s) de la mémoire dans laquelle sont stockées les données nécessaires à l’exécution des méthodes (paramètres, variables locales). Ces données sont temporaires et sont gérées en “pile” c’est à dire qu’on les alloue au moment où l’on rentre dans l’exécution et qu’elles perdent toute signification au moment où l’on sort de l’exécution de la méthode courante.
poids fort/poids faible
Organisation de blocs de bits dans un processeur (par ex. pour la représentation d’un nombre entier). Dans de nombreuses architecture le “mot” mémoire est organisé de droite à gauche régulièrement (le bit le plus à droite a le “poids” le moins fort, et plus on va vers la gauche plus on représente des “poids” fort - hormis le bit de signe). Une telle architecture (processeurs Motorola, Sparc, entiers portables Java) est dite en ordre poids-fort/poids-faible (ou “gros-boutienne”). D’autres architectures (processeurs VAX, Intel) ont des blocs de bits qui sont regroupés de manière non homogène (de droite à gauche à l’intérieur du bloc mais de gauche à droite entre blocs): elles sont poids-faible/poids-fort (ou “petit-boutienne”).
pointeur
Dans certains langages type permettant de représenter une adresse en mémoire. Il n’y a pas de pointeurs en Java mais des références.
polymorphisme

Le terme a eu plusieurs acceptations selon le contexte informatique: généralement il s’agit d’un comportement générique qui s’adapte automatiquement au type effectif des variables.

En Java cette généricité concerne le point vue de l’exécution d’une méthode d’instance: pour une API donnée définissant un type: l’appel sur une référence d’une méthode (repérée par sa signature) peut correspondre à des codes différents en fonction du type effectif de l’objet (qui peut être différent du type déclaré soit par héritage, soit par “implémentation” d’interface). Un tel découplage entre une demande de service et sa réalisation améliore la généricité, la maintenabilité et la dynamicité des programmes.

pool
Ensemble de ressources mises en commun. ex. pool de constantes mises en commun entre les classes.
portée
Capacité d’un code à accéder à une donnée référencée par un symbole. Dans la plupart des langages modernes la portée est "syntaxique": la disposition du code permet de savoir où le code est accessible. (il y a quelques cas particulier où on indique des modificateurs de portée comme public)
précision infinie
nombres dont la représentation n’est pas native du processeur. On peut ainsi dépasser des limitations (au détriment des performances). ex. BigInteger et BigDecimal en Java/groovy.
propriété
Une association nom-valeur. Peut avoir plusieurs interprétations selon les langages. En général il s’agit d’une association créé dynamiquement (par ex. en lisant une chaine dims=24x36; color=blue)
pseudocode
(bytecode) Code “binaire” destiné à la machine virtuelle (java ou C# par ex.) Comme cette machine est, précisément, virtuelle il s’agit d’un pseudo code binaire.
récursivité

Possibilité pour une fonction ou une méthode de se rappeler elle-même dans sa définition. Pour les amateurs :

// code java: remarquer que la méthode se rappelle elle-même!
public static long ackerman(long mx, long ny) {
  // parametres doivent etre positifs
  if( mx ==0L) {return ny+1; }
  if(ny==0L) { return ackerman(mx-1,1) ;}
  return ackerman(mx-1, ackerman(mx, ny-1)) ;
}
redéfinition
(overriding) Reprise dans une sous-classe de la définition d’une méthode héritée de la super-classe. Cette redéfinition peut éventuellement faire appel à l’exécution de la méthode redéfinie (appel de super.methode()). Avec la définition de méthodes abstraites (héritage de classes abstraites, réalisation de contrat d’interface) cette technique accompagne la liaison dynamique et le polymorphisme. Ne pas confondre avec “surcharge” (overloading) et avec “rupture du lien statique” (hiding).
référence
Dans certains langages comme Java on n’accède à un objet qu’indirectement au travers d’une référence: c’est à dire “quelque chose” qui permet de retrouver l’objet dans le tas. Contrairement aux apparences il y a peu de chances qu’une référence soit implantée comme un “pointeur” en mémoire (tel que ce type est utilisé dans certains langages comme Pascal ou C).
réflexion/introspection
Ensemble de mécanismes qui permettent d’inspecter une instance d’un type a priori inconnu et d’en connaître la classe, les membres et les constructeurs. On peut, par exemple, appeler dynamiquement une méthode inconnue au compile time.
rupture du lien statique
(terminologie non-standard pour rendre le terme hiding ) redéfinition dans une sous classe d’un membre qui n’est pas soumis à évaluation dynamique.Exemple: redéfinition d’un champ ou d’une méthode de classe.
scalaire
(terminologie non-standard empruntée à d’autres langages comme APL). Un type “non-objet” représentant une valeur atomique. (En toute rigueur les types long et double ne sont pas strictement atomiques au regard de certaines opérations)
serialization
“mise à plat” d’un objet pour envoi dans un flot d’Entrée/sortie spécial . Utilisé pour la persistance ou pour la communication d’objets au travers du réseau.
spécialisation
voir "redéfinition"
spécification
Définition du comportement d’une entité informatique (objet, opérateur, structure de contrôle, …). Pour prendre l’exemple des “interfaces” Java les spécifications sont rendues à la fois par des moyens formels analysables par informatique (les en-têtes de méthodes abstraites) et par la documentation javadoc qui décrit de manière informelle le “contrat” de comportement de ces méthodes.
statique
(dans beaucoup de langages à objets abus de terminologie venant de la reprise -malheureuse- du mot clef static de C/C\++) Qui appartient à une classe et non à une instance. Les membres de classes sont préfixés du modificateur static (il en est de même des blocs de classe). Aspect avancé: l’allocation mémoire correspondante n’est en rien l’allocation statique présente dans d’autres langages: en Java l’allocation est liée au chargeur de classe et donc il peut y avoir plusieurs fois la “même” classe en mémoire (et donc par exemple plusieurs versions d’une variable partagée “statique”).
strate
(en Anglais ModuleLayer) regroupement de modules.
structure de contrôle
Elément de langage permettant de modifier le déroulement successif des instructions et de les regrouper par blocs: aiguillages (if, switch), boucles (while, do-while, for), captures (try-catch-finally), sections sous contrôle de concurrence (synchronized).
surcharge
(overloading) capacité de définir plusieurs méthodes avec la même intention sémantique et des paramètres différents Ne pas confondre avec “redéfinition” (voir aussi “message”).
tableau
regroupement contigu de données d’un même type. Les éléments sont accédés à l’aide d’un index. Une fois créés les tableaux ne sont pas extensibles.
tableau associatif
sorte de dictionnaire. Les données (appelées "valeurs") sont accessibles au moyen d’une "clef". Une fois créés ces tableaux sont extensibles (voir les algorithmes de HashMap — table de hachage — pour comprendre leur fonctionnement).
tas
Partie de la mémoire d’un processus qui sert à l’allocation dynamique de données dont le nombre n’est pas a priori connu. En Java tout est pratiquement alloué dans le tas et le “glaneur de mémoire” gère la dés-allocation des objets qui ne sont plus référencés.
thread
(pas d’accord général sur la traduction du terme en français) Tâche élémentaire à l’intérieur d’un processus. Ces micro-processus peuvent être gérés par le système d’exploitation ou par l’exécuteur lui-même. Un ordonnanceur de tâches passe la main à une tâche particulière en fonction de priorités et aussi de stratégies qui ne sont pas spécifiées par le standard. La gestion cohérente de données qui sont accédées par plusieurs threads concurrents est un des aspects les plus difficile de la programmation .
transtypage
(terminologie non-standard: voir “conversion” et “forçage de type”.)
UML
Formalisme de représentation de modèles (en principe indépendant des langages et des méthodologies — en réalité on peut douter de cette indépendance quand on va dans les détails — ).
variable d’instance
Variable “membre” d’une instance. Déclarée au premier niveau de la classe elle est accessible essentiellement par les méthodes de l’instance courante (mais pas par les méthodes de classe), La combinaison des valeurs des variables d’instance constitue “l’état” de l’instance.
variable de classe
voir “variable partagée”.
variable partagée
Variable “membre” d’une classe. Déclarée au premier niveau de la classe (avec modificateur static) elle est accessible au travers de la désignation de la classe (et,mais c’est moins courant, au travers de référence à une instance de la classe).
variable type
variable qui représente non pas une donnée mais un type dans un type paramétré. Exemple Comparable<E> pour définir le fait qu’un objet sera comparable à un objet de type E: E pouvant prenant une valeur dans un code appelant (par ex. Comparable<BigDecimal>).
veilleur
(terminologie non-standard: idée de Listener) Objet qui s’abonne pour recevoir des événements et dont la classe implante des gestionnaires d’événements.
XML
Formalisme permettant de représenter des données sous forme textuelle. Il s’agit d’un langage “à balises” (les balises étant du texte spécial qui documente et structure le texte lui-même). Ces données sont ainsi portables et aussi bien lisibles par une application que par un être humain. Voir également JSON et YAML.