Glossaire du langage Java
Le sigle API signifie Application Programmeur Interface. Une API
fournit un ensemble de fonctionnalités qui facilitent la
programmation. Il existe différentes API Java. La
principale, qui constitue le cœur de l'ensemble
des API, est disponible
api
Le sigle API signifie Application
Programmeur Interface. Une API fournit un ensemble de
fonctionnalités qui facilitent la programmation. Il existe
différentes API Java. La principale, qui constitue le
c&oelg;ur de l'ensemble des API, est disponible sur toute
plate-forme Java ; elle est très large ; ses paquetages les
plus fréquemment utilisés sont : java.lang,
java.util, java.io, java.net,
java.awt, java.awt.event, javax.swing,
javax.swing.event, java.applet.
À côté de cette API centrale se sont
développées de nombreuses API
spécialisées (Java AdvancedImaging API, Java 3D
API, JavaMail API, etc.) ; elles ne sont pas abordées dans
ce livre.
applet
Une applet est une application dont
un navigateur Web peut télécharger le bytecode
à travers le réseau pour l'exécuter
localement. C'est aux applets que Java doit son succès
initial. Des difficultés sont rapidement apparues,
essentiellement dues au décalage entre la rapide
évolution du langage Java et la lenteur de
l'évolution des navigateurs. Les restrictions pour des
considérations de sécurité ont aussi
restreint fortement la portée des applets qui servent
essentiellement à animer des pages Web ; le «
gestionnaire de sécurité « lance une
exception, instance de la classe SecurityException,
si une applet essaie de violer une règle de
sécurité. En particulier, avec le
système de sécurité « par
défaut », une applet ne peut ni lire ni
écrire dans les fichiers locaux et ne peut pas communiquer
avec une machine autre que son serveur d'origine. On peut
éventuellement demander au navigateur d'accorder des droits
supplémentaires à l'utilisateur, mais cela peut
être dangereux, sauf si on a totalement confiance en les
applets qui sont proposées ; certaines applets peuvent
être munies d'un « certificat
sécurisé », donnant l'origine de
l'applet, auquel on peut se fier pour alléger les
règles de sécurité. Une applet n'est
pas lancée avec une méthode main
; il faut utiliser la classe JApplet pour la
définir.
Voir aussi la section
sur les applets.
argument
On appelle en
général argument une valeur transmise
à une méthode au moment de son appel. Si on a
l'en-tête de méthode
void
faire(int a) ...,
a est un paramètre de la
méthode faire ; si on invoque faire(3),
on dit que 3 est l'argument reçu par la méthode faire.
arguments d'un programme
On peut envoyer des arguments
à un programme, autrement dit à une
méthode main. Considérons
le schéma de programme suivant :
public class Essai {
public static void main(String[] arg) {
...
}
et supposons qu'on exécute le programme avec la
commande :
java Essai bonjour 14
alors, lorsque la méthode main
commence à s'exécuter, arg
est est tableau de deux chaînes de caractères ; la
première chaîne de caractères est
"bonjour" et la seconde est la chaîne de
caractères constituée d'un 1 et d'un 4,
c'est-à-dire la chaîne de caractères
"14". En conséqence, arg[0] est la
chaîne de caractères (objet de type String)
"bonjour" et arg[1] est la chaîne de
caractères "14".
Si on travaille avec Eclipse, il faut donner les arguments avant
d'exécuter le programme (en utilisant, si votre version
d'Eclipse est en anglais), "Run Configurations", puis en choisissant
l'onglet Arguments pour préciser les arguments dans "Program
arg".
attribut
On appelle ainsi une
donnée définie dans une classe, une variable non
locale à une méthode. Un attribut peut
être :
AWT
Le sigle de
l'abréviation AWT signifie Abstract Window Toolkit.
C'est le nom de l'ensemble des classes initialement conçues
par Java concernant les interfaces graphiques ; un ensemble de
composants graphiques dits swing se sont ajoutés. Les
classes de l'AWT forment les paquetages java.awt
et java.awt.event.
bloc
On appelle bloc une portion de code
commençant par une accolade ouvrante et se terminant par une
accolade fermante, les deux accolades devant se correspondre.
boucle
En Java, il y a trois sortes de boucle : la boucle while, la boucle for, la boucle do-while
champ
Un champ d'une classe est un
attribut, une méthode ou, de manière beaucoup
moins fréquente, une classe interne.
champ d'instance
Un champ d'une classe est dit
d'instance dès que le modificateur static
n'est pas appliqué lors de sa déclaration.
Un attribut d'instance correspond
à une caractéristique de chaque instance de la
classe et n'existe, par rapport à une allocation
mémoire, que dans une instance de cette classe. Avant qu'une
instanciation de la classe ne soit effectuée, l'attribut n'a
aucune existence physique. Si plusieurs instances de la même
classe coexistent, il y a un exemplaire de chaque attribut d'instance
de la classe par instance créée.
Une méthode doit
être d'instance lorsqu'elle manipule, en lecture ou en
écriture, des attributs d'instance de sa classe ; autrement
dit, une méthode doit être d'instance
dès qu'elle utilise (généralement
implicitement) la référence this ; elle sert
à manipuler une instance de la classe en travaillant, en
lecture ou en écriture, avec ses attributs d'instance.
À l'envers, il sera plus correct de déclarer
statique une méthode n'utilisant aucun attribut ou
méthode d'instance de sa classe.
On invoque toujours un champ
d'instance en le faisant précéder de la
référence de l'objet concerné, avec la
syntaxe :
instanceConcernée.nomDAttributOuMethodeDInstance
où instanceConcernée
est en fait une référence de l'instance
concernée. Si l'instance concernée est celle que
modélise la classe (c'est-à-dire l'instance qui
est référencée par this),
on peut omettre de la préciser en indiquant uniquement le
nom du champ.
champ statique, ou de
classe
Un champ d'une classe est dit
statique si le modificateur static
est appliqué lors de sa déclaration. On dit aussi
qu'il s'agit d'un champ de classe. Les deux qualificatifs sont
équivalents.
Un attribut déclaré static
existe dès que sa classe est chargée en
mémoire. Quel que soit le nombre d'instanciations de la
classe (0, 1 ou plus), un attribut de classe, i.e. statique, existe en
un et un seul exemplaire. Un tel attribut joue un peu le rôle
d'une variable globale d'un programme non-objet ; sa classe lui sert de
« boîte de rangement ».
Une méthode statique est une méthode
globale, mais que l'on a « rangée » dans
une classe puisque aucune méthode ne peut être
définie en dehors d'une classe ; pour l'utiliser de
l'extérieur de la classe où elle est
définie, il faut simplement préciser la classe
où elle est « rangée », comme
indiqué plus bas.
Une méthode de classe ne peut pas manipuler,
directement ou indirectement, des attributs non statiques de sa classe.
En conséquence, une méthode statique ne peut pas
utiliser la référence this,
de façon implicite ou explicite ; une erreur serait
détectée à la compilation. De
même, une classe interne statique ne peut pas faire
référence aux champs d'instance de la classe
englobante.
De l'extérieur d'une classe ou d'une classe
héritée, un champ de classe peut être
utilisé précédé du nom de
sa classe :
nomDUneClasse.nomDUnAttributDeClasse
ou
nomDUneClasse.nomDUneMethodeDeClasse
Par exemple, pour utiliser la méthode statique sin
de la classe java.lang.Math avec un argument x,
on écrira Math.sin(x). On peut aussi
faire précéder le nom de la méthode
d'une instance de la classe, mais cela n'a pas
d'intérêt.
De l'intérieur de la classe où elle est
définie, on peut utiliser une méthode statique
sans la faire précéder du nom de la classe.
classe
Une classe modélise un
type d'entité ; elle donne la description d'un ensemble
d'attributs et de méthodes chargées de
gérer ces attributs.
Une classe comporte :
Une classe peut être
qualifiée de :
classe abstraite
Dès qu'une classe
contient une méthode
abstraite, elle doit elle aussi être
déclarée abstraite.
Une classe abstraite ne peut pas être
instanciée. Il faudra l'étendre et
définir toutes les méthodes abstraites qu'elle
contient pour pouvoir l'utiliser.
classe enveloppe
À chaque type primitif
est associée une classe qui permet de disposer de
méthodes pour gérer ce type ; au type int est
associée la classe Integer etc.
classe
générique
Il s'agit d'une classe dont la
définition dépend d'un (ou plusieurs) «
paramètre de type » représentant un nom
de classe qui devra être précisé au
moment de l'utilisation de la classe. La possibilité des
classes génériques date du JDK 5.0.
classe interne
Une classe peut être
définie comme champ d'une classe ou bien à
l'intérieur d'un bloc d'une méthode. Dans les
deux cas, on dira qu'il s'agit d'une classe interne.
On peut attribuer à une
classe qui figure comme champ d'une autre classe les mêmes
modificateurs de visibilité que pour des attributs ou des
méthodes, ainsi que les modificateurs abstract
et final.
Ces mots gardent le même sens que pour une classe non
interne.
Une classe B interne à une
classe A (mais non à une
méthode) se nomme A.B. Pour instancier
B de l'extérieur de A,
on peut invoquer le constructeur de la classe B
à partir d'une instance de la classe A.
Par exemple, si A et B ont
des constructeurs sans paramètre, on pourrait
écrire :
A.B b = (new
A()).(new B());
De l'intérieur de A, on peut écrire :
A b = new
B();
On peut aussi qualifier de static
une classe interne à une autre classe ; on ne peut alors pas
y référencer une instance englobante. Si B est
une classe statique interne à une classe A, on peut
l'instancier par :
A.B b = new
A.B();
Une classe locale, définie à
l'intérieur d'une méthode, n'est visible
qu'à l'intérieur de celle-ci. On ne peut
l'instancier que de l'intérieur de cette méthode.
commentaire
Un commentaire est une partie de
code source ignorée par le compilateur. Il y a deux types de
commentaires.
composant léger
On appelle ainsi les composants
Java qui sont uniquement écrits en Java et qui n'utilisent
pas de fenêtre native dans leur construction. Ces composants
appartiennent au kit de développement d'interfaces
graphiques appelé swing.
concaténation
Si dans un programme Java, l'un
des opérandes du signe + se trouve être une
chaîne de caractères (de type String),
alors ce signe + est l'opérateur de
concaténation. Si les deux opérandes sont des
chaînes de caractères, le résultat est
la concaténation des chaînes de
caractères. Si l'un des opérandes n'est pas une
chaîne de caractères, la langage java a
prévu une traduction de l'opérande qui n'est pas
une chaîne de caractères en une chaîne
de caractères représentant celui-ci. Les
variables d'un type numérique sont traduites de
façon naturelle, le mécanisme de traduction des
objets est plus complexe et demande d'étudier la
méthode toString de la classe Object,
qui est redéfinie par certaines classes.
constructeur
Toute classe contient une
méthode appelée constructeur. Cette
méthode porte le même nom que la classe qui la
contient et ne doit pas indiquer de valeur de retour ; un constructeur
renvoie implicitement la référence de l'instance
construite.
Un constructeur sert en particulier à initialiser les
attributs de la classe. La première ligne d'un constructeur
est :
Lorsqu'un constructeur d'une classe ne fait
pas appel à un autre constructeur, le compilateur ajoute
automatiquement l'instruction :
super();
en première ligne du constructeur. Si la superclasse n'a pas
de constructeur sans paramètre, une erreur est
détectée à la compilation.
Lorsqu'une classe ne contient pas
de constructeur, le compilateur en ajoute automatiquement un qui ne
comporte qu'un appel au constructeur sans paramètre de la
superclasse.
Voici un exemple d'une classe
possédant deux constructeurs.
class Essai
{
private int milieu;
private int largeur;
Essai(int i) {
milieu = i;
}
Essai(int a, int b)
{
this(a); //effectuera : milieu = a;
largeur=b;
}
}
déclarer
Déclarer une variable,
c'est indiquer son type. Déclarer une méthode,
c'est indiquer son prototype, son en-tête.
définir
Définir une variable, un
tableau ou un objet, c'est lui réserver une place en
mémoire. La définition d'un tableau ou d'un objet
se fait à l'aide du mot réservé new.
Une déclaration telle
que :
int
i;
déclare et définit simultanément la
variable i.
Une déclaration telle
que :
int[]
tableau;
(resp. Integer entier;)
déclare et définit la variable tableau (resp.
entier), en tant que référence, mais ne
définit pas de tableau pouvant contenir des entiers (resp.
d'objet de type Integer).
L'instruction :
tableau = new
int[4];
(resp. entier = new
Integer(1);)
définit un tableau pouvant contenir quatre variables
entières (resp. un objet de type Integer).
On ce qui concerne un objet, sa définition s'accompagne
d'une construction (effectuée par le constructeur) ; nous
dirons plutôt qu'on construit un objet ou qu'on instancie une
classe.
Définir une
méthode, c'est indiquer, après son
en-tête, un bloc contenant des définitions de
variables locales et la suite des instructions à
exécuter pour mettre en Å“uvre cette
méthode.
encapsulation
L'encapsulation de
données constitue un principe fondamental d'un langage objet
: il s'agit de la possibilité de « cacher
» des données à l'intérieur
d'une classe en ne permettant de les manipuler qu'au travers des
méthodes de la classe. L'intérêt
essentiel d'une telle opération est d'interdire que les
données soient modifiées de façon
contraire à l'usage attendu dans sa classe, et ainsi de
maintenir l'ensemble des données de la classe dans un
état cohérent. Un exemple simple est le cas d'une
donnée numérique qui devrait rester positive pour
garder sa signification : il est indispensable qu'un utilisateur ne
puisse pas, par mégarde ou ignorance, lui attribuer une
valeur négative. Pour encapsuler un attribut, il suffit de
le déclarer privé, c'est-à-dire de lui
attribuer le modificateur de visibilité private.
On peut aussi encapsuler des méthodes qui ne servent
qu'à un usage interne à la classe.
étendre
Dire qu'une classe B
étend une classe A, c'est dire que B
hérite de A.
exception
Une exception correspond
à un événement anormal ou inattendu.
Les exceptions sont des instances de sous-classes de la classe java.lang.Exception
qui elle-même étend la classe java.lang.Throwable,
pour des objets qui peuvent être «
lancés ». Un grand nombre d'exceptions sont
définies dans l'API et beaucoup de méthodes de
l'API lancent des exceptions.
Un mécanisme, utilisant
le mot réservé throw,
permet de lancer une exception selon la syntaxe illustrée
ci-dessous :
if
(il y a un probleme) throw new MonException();
où MonException est ici une
sous-classe de Exception définie par
ailleurs.
Quand une exception est
lancée, toutes les instructions suivantes sont
ignorées et la pile des appels des méthodes est
remontée : on dit que l'exception se propage et que les
appels de méthodes lancent à leur tour
l'exception. Si l'instruction (ou un appel de méthode de la
pile des appels) qui a lancé l'exception est
située dans un bloc try
suivi d'un bloc catch
attrapant les exceptions de la classe de l'exception qui se propage,
les instructions du bloc catch
sont exécutées puis l'exécution
reprend son cours normal avec l'instruction qui suit le bloc catch.
Remarquons qu'une
méthode qui peut lancer une exception sans l'attraper durant
son exécution doit le signaler dans son en-tête en
utilisant le mot réservé throws.
Par exemple :
void
maMethode() throws MonException
signale qu'au cours de l'exécution de la méthode maMethode,
une exception de type MonException est
susceptible d'être lancée sans être
attrapée.
On est néanmoins
dispensé de signaler le lancement éventuel des
exceptions les plus classiques (comme ArrayIndexOutOfBoundsException)
dans les en-têtes des méthodes ; plus
précisément, les exceptions qu'on peut ne pas
signaler sont celles qui héritent de la classe java.lang.RuntimeException.
Voir aussi la
section sur les exceptions.
finaliseur
On appelle ainsi une
méthode qui s'exécute au moment où un
objet est détruit, c'est-à-dire quand l'espace
mémoire réservé à l'objet
est libéré. La méthode finalize
de la classe Object peut être
redéfinie pour servir de finaliseur.
gestionnaire de
répartition
Un gestionnaire de
répartition est une classe qui permet de gérer la
répartition des sous-composants graphiques dans un composant
graphique. La méthode setLayout, que l'on trouve dans la
classe java.awt.Container dont hérite tout composant
graphique qui peut en contenir d'autres, permet de choisir un
gestionnaire de répartition. On peut utiliser :
Si on n'utilise pas de
gestionnaire de répartition, il faut
préciser directement les positions et les tailles des
différents sous-composants graphiques. Des
méthodes sont prévues à cet effet dans
la classe java.awt.Component.
GUI
Cet acronyme signifie Graphical
User Interface. Il désigne l'ensemble des moyens
dont dispose un utilisateur pour interagir avec un programme
grâce à une interface graphique.
L'utilisateur peut se servir de la souris et du clavier et peut
intervenir en utilisant les différents composants graphiques
de l'interface (boutons, zones de texte, menus, etc.).
héritage
En Java, toute classe
hérite d'une et une seule classe, sauf la classe Object,
qui n'hérite d'aucune classe ; il n'y a pas
d'héritage multiple. L'héritage s'exprime
grâce au mot réservé extends.
Une classe B qui hérite d'une classe A
est dite sous-classe de A ; elle dispose de tous
les attributs et méthodes de A,
moyennant néanmoins quelques nuances liées aux
modificateurs de visibilité, à la
possibilité de masquage
des attributs et au principe de la redéfinition
des méthodes. Toute instance de la classe B
est aussi considérée comme étant une
instance de la classe A.
Une interface peut hériter d'une ou plusieurs
autres interfaces ; elle hérite de leurs constantes et de
leurs prototypes de méthodes.
Voir aussi la
section sur l'héritage.
implémenter
Une classe peut
implémenter une ou plusieurs interfaces,
ce qui s'exprime à l'aide du mot
réservé implements.
Si une classe A implémente une
interface I, cela implique que :
Les attributs et les
méthodes d'une interface sont automatiquement publics, ce
qui entraîne qu'une classe qui
implémente l'interface devra déclarer publiques
(avec le modificateur public)
les méthodes de l'interface qu'elle définira.
initialiseur
Dans une classe, un initialiseur
est l'initialisation d'un attribut simultanément
à sa définition ou, plus rarement, la
définition d'un bloc d'instructions extérieur aux
méthodes de cette classe. S'il n'est pas statique, un
initialiseur est exécuté au moment de la
construction d'une instance, avant l'exécution des
constructeurs ; s'il y a plusieurs initialiseurs d'instance, ils sont
exécutés dans l'ordre de leurs
déclarations. On pourrait définir et initialiser
deux attributs taille et entier d'une classe par :
int
taille = 5;
Integer entier = new
Integer(1);
Un initialiseur est statique s'il
est précédé du mot static
; le rôle d'un initialiseur statique est en
général d'initialiser des attributs statiques de
la classe. Un initialiseur statique est exécuté
au moment du chargement de la classe. Il peut arriver qu'on ait besoin
d'un initialiseur statique sous forme d'un bloc d'instructions
précédé du modificateur static,
par exemple pour initialiser un tableau statique.
instance
Une classe A
est un modèle décrivant un type d'objets. Une
instance de la classe A est un objet construit
selon le modèle fourni par la classe A.
Les expressions « un objet de type A
» et « une instance de la classe A
» sont synonymes.
instruction
conditionnelle
L'instruction conditionnelle utilise les mots
réservés if
et else. Elle se construit sur
le schémas suivants :
if (condition) {
suite1 d'instructions
}
else {
suite2 d'instructions
}
Les parenthèses autour de la condition sont obligatoires.
Les accolades autour des suites d'instructions sont facultatives s'il
n'y a qu'une seule instruction dans la suite concernée.
Si la condition vaut vrai (true),
alors c'est la suite1 d'instructions qui est
exécutée, et sinon c'est la suite2.
Si aucune instruction ne doit figurer dans la suite2, il convient de ne
pas mettre la partie concernant le else,
on a alors :
if (condition) {
suite d'instructions
}
On peut, sur le même schéma, avoir (par exemple) :
if (condition1) {
suite1 d'instructions
}
else if (condition2) {
suite2 d'instructions
}
else {
suite3 d'instructions
}
instance
concernée
Voir
objet concerné.
interface
Une interface définit un
contrat que certaines classes pourront s'engager à
respecter.
Une interface comporte un
en-tête (qui peut posséder le modificateur public)
suivi du nom de l'interface, puis, entre accolades, une liste de
constantes et de prototypes de méthodes. Le modificateur abstract
peut figurer ou non devant son nom ; c'est indifférent car
une interface est par nature abstraite. Une interface ne peut pas
être instanciée et ne contient pas de
constructeur. Une interface peut être implémentée
par une classe.
L'existence des interfaces permet de compenser l'absence
d'héritage multiple. Une interface :
- sert à regrouper des constantes ;
- mais surtout sert chaque fois que, d'une part, on veut
traiter un ensemble d'objets qui ne sont pas tous
nécessairement de la même classe mais qui ont en
commun une partie « interface » et que, d'autre
part, seule cette partie « interface » intervient
dans le traitement que l'on veut définir ; les classes de
ces objets pourront alors implémenter une même
interface.
Voir aussi la
section sur les interfaces.
liaison dynamique
Lorsqu'une méthode
d'instance est invoquée, l'adresse en mémoire du
bytecode de cette méthode est
déterminée dynamiquement, c'est-à-dire
à l'exécution, à partir de l'objet
concerné ; celui-ci dispose en effet de liens vers les
adresses de ses différentes méthodes. Ce principe
permet le polymorphisme.
Si entre-temps, l'instruction est :
a = new C();
lorsque la machine virtuelle rencontre l'instruction :
a.faire();
c'est encore la méthode faire de la
classe B qui est exécutée.
La machine virtuelle cherche la methode invoquée
à partir de la classe de l'instance concernée, en
retenant la première définition
rencontrée correspondant à la liste des
paramètres d'appel, en remontant de classe en superclasse.
liaison statique
On appelle ainsi un adressage pour
du code interprétable qui est
déterminé à la compilation. C'est le
cas pour une méthode statique, une méthode
finale, une méthode d'une classe finale ou une
méthode privée. Une liaison statique est plus
efficace en temps qu'une liaison dynamique.
masquer un attribut
On dit qu'un attribut d'une classe
B masque un attribut de sa superclasse A s'il a même nom que
ce dernier ; l'attribut de la classe A se trouve alors caché
par l'attribut de même nom, comme le laisse entendre la
terminologie. Il y a encore moyen d'accéder à un
attribut masqué en utilisant la conversion de classe ou
bien, dans la définition d'une méthode de la
classe B, à l'aide du mot super.
méthode
On désigne ainsi ce
qu'on appellerait fonction ou procédure dans d'autres
langages. Toute méthode fait partie d'une classe.
Une méthode peut être :
méthode
abstraite
Une méthode abstraite
n'a que son prototype, c'est-à-dire son type de retour
suivi, de son nom, suivi de la liste de ses paramètres entre
des parenthèses, suivi d'un point-virgule. Une
méthode abstraite ne peut pas être
déclarée static
ou private
ou final.
Une classe qui contient une méthode abstraite est une classe abstraite.
méthode
générique
Il s'agit d'une méthode
dont la définition dépend d'un (ou plusieurs)
« paramètre de type »
représentant un nom de classe qui devra être
précisé au moment de l'utilisation de la
méthode. La possibilité des méthodes
génériques date du JDK 5.0.
modulo
Si n et p sont
deux entiers positifs, on peut écrire : n % p,
qui se lit "n modulo p" ; si n vaut 15 et si p
vaut 4, le résultat vaut 3.
niveaux de
visibilité
Il est possible d'indiquer un
certain niveau de visibilité pour une classe ou un champ
d'une classe. Cela se fait avec les mots public,
private
ou protected
situés au début de l'en-tête de la
classe ou du champ en question. Ces mots sont les modificateurs de
visibilité. Quand aucun modificateur de
visibilité ne figure, le niveau de visibilité est
le niveau de visibilité dit paquetage ou
par défaut.
Une classe possède deux niveaux de
visibilité : le niveau paquetage et le niveau public
indiqué par le mot réservé public.
Une classe est toujours visible de tout son paquetage ; une classe
n'est visible d'un autre paquetage que si elle est publique.
Un attribut ou une méthode possèdent
quatre niveaux de visibilité : les modes indiqués
par les mots public, private
ou protected auxquels s'ajoute
le mode paquetage (par défaut) ; dans ce dernier cas,
l'attribut ou la méthode en question sont visibles de
partout à l'intérieur de leur paquetage et de
nulle part à l'extérieur de celui-ci.
Voir aussi la
section sur les niveaux de visibilité.
nombre à
virgule flottante
Ces nombres servent à
coder des réels ; l'ordinateur ne permettant pas de traiter
tous les nombres réels, ce sont en fait des nombres
exprimés avec une partie décimale.
objet
On appelle ainsi une instance d'une
classe.
objet concerné
Considérons l'appel
d'une méthode meth sur un objet
(référencé par) obj :
obj.meth();
Nous dirons que l'objet (référencé
par) obj est l'objet concerné, ou
l'instance concernée, par l'exécution de la
méthode meth via cette instruction.
opérations sur
les entiers
Les opérateurs pour les entiers sont :
+ : pour l'addition
- : pour la soustraction
* : pour la multiplication
/ : pour la division ; attention, il s'agit de la
division entière, le résultat est entier ; Si n
et p sont deux entiers, si n
vaut 14 et si p vaut 3, le résultat
vaut vaut 2. Si vous voulez obtenir la division non entière,
et récupérer le résultat dans une
variable x de type float, il
faut écrire x = (float)n / p
% : pour le modulo
paquetage
On peut partitionner l'ensemble des
classes écrites en Java en sous-ensembles appelés
paquetages grâce à l'utilisation de l'instruction package
située en première ligne d'un fichier source. Si
une classe A appartient au paquetage repertoire1.repertoire2
par exemple, elle ne pourra être invoquée dans une
autre classe que si le chemin d'accès au fichier A.class
se termine par repertoire1/repertoire2. La visibilité; d'une classe A
et de ses champs depuis une autre classe B varie
selon l'appartenance ou non de A et B
au même paquetage.
On appelle aussi paquetage le niveau de visibilité
d'une classe ou d'un champ de classe qui ne possède pas de
modificateur de visibilité ; ce niveau de
visibilité s'appelle également le niveau de
visibilité par défaut ; si une classe ou un champ
de classe a le niveau de visibilité paquetage, il est
visible dans tout son paquetage et nulle part ailleurs.
Voir aussi la
section consacrée aux paquetages.
paramètre de
type
Il s'agit d'un identificateur qui
désigne un type référence non
précisé ; on trouve de tels identificateurs dans
la définition de classes ou de méthodes
génériques.
paramètre
d'une méthode
On appelle ainsi les variables qui
apparaissent dans l'en-tête d'une méthode. On peut
voir la distinction avec le mot argument qui figure aussi dans ce
glossaire.
pliage
On appelle pliage la transformation
des paramètres d'appel ou de la valeur de retour d'une
méthode en un flux binaire transmissible par un
réseau et destiné à la communication
d'objets distants. L'opération inverse, permettant de
récupérer les données à
partir du flux, est le dépliage. Pour qu'un objet puisse
subir le pliage, il faut qu'il soit sérialisable.
polymorphisme
Supposons que deux classes B et C
héritent d'une même classe A. Supposons que la
classe A définisse une méthode d'instance meth
redéfinie par les classes B et C (la méthode meth
peut avoir ou non des paramètres ; nous la supposons
ci-dessous sans paramètre). Supposons enfin que l'on ait les
déclarations et instructions suivantes :
A a = new A();
a.meth(); //1
a = new B();
a.meth(); //2
a = new C();
a.meth(); //3
Alors, au moment de l'instruction 1, c'est
la méthode meth de la classe A
qui est exécutée ; au moment de l'instruction 2,
c'est la méthode meth de la classe B
qui est exécutée ; au moment de l'instruction 3,
c'est la méthode meth de la classe C
qui est exécutée. On appelle cette
propriété le polymorphisme. Une même
référence peut désigner des objets
ayant des comportements différents.
prototype d'une
méthode
On appelle ainsi la
déclaration d'une méthode, qui est en Java de la
forme :
typeDeRetour
nom(liste des paramètres);
Il n'y a pas de corps, mais
à la place un ";". Cette déclaration peut
être précédée de certains
modificateurs.
redéfinir une
méthode d'instance
On peut redéfinir une
méthode d'instance définie dans une classe
à l'intérieur d'une sous-classe de celle-ci. Pour
cela, il faut que la méthode redéfinie ait
même nom, mêmes nombre et types de
paramètres (dans le même ordre) et même
type de retour que la méthode d'origine ; il y a un certain
assouplissement depuis le JDK 5.0 ; si on redéfinit une
méthode retournant un type A,
où A est une classe ou une interface,
le type de la valeur de retour de la nouvelle méthode peut
être un sous-type de A. La
méthode à exécuter est
déterminée au moment de l'exécution,
en fonction du type de l'objet
référencé, c'est-à-dire par
une liaison dynamique.
Si une classe B étend une
classe A et redéfinit une
méthode meth de la classe A,
il n'y a pas moyen d'invoquer la méthode meth
de la classe A sur un objet de type B,
sauf de l'intérieur d'une définition de
méthode de la classe B : dans ce
dernier cas, super.meth() est
la méthode meth de la classe A.
Une classe peut interdire qu'une sous-classe
redéfinisse une certaine méthode en appliquant le
modificateur final
à cette méthode.
La redéfinition des méthodes d'instances
obéit aux règles suivantes :
li>il n'est pas possible de redéfinir une
méthode en diminuant son niveau de visibilité ;
li>si une méthode est définie dans une
classe A et redéfinie dans une classe B,
la méthode redéfinie dans B
ne peut lancer que des exceptions qui sont de la classe ou d'une
sous-classe d'une exception lancée par la méthode
définie dans A.
référence
Une référence
d'un objet ou d'un tableau est une adresse en mémoire ou,
autrement dit, un pointeur. On ne peut avoir accès aux
objets ou aux tableaux que par leur référence. En
Java, le passage de paramètres se fait toujours par valeur ;
quand un objet ou un tableau est passé en argument
à une méthode, c'est de la
référence qu'il s'agit, en conséquence
il se peut que la méthode change le contenu de l'objet ou du
tableau.
renvoyer une valeur
On appelle valeur
renvoyée par une méthode une valeur
indiquée derrière le mot return
dans une instruction terminant l'exécution d'une
méthode. Si l'exécution d'une méthode
meth s'est terminée par l'instruction :
return
1;
on dit que meth a renvoyé la valeur 1,
ou que la valeur de retour de meth est 1 ; si
cette méthode a été
invoquée par :
n = xxx.meth();
n est valué
par la valeur renvoyée par meth.
revaluer
Dire que l'on revalue une variable
signifie qu'on lui réaffecte une valeur.
sérialisation
Les objets doivent quelquefois
être sauvegardés dans un fichier afin
d'être récupérés
ultérieurement ou transmis d'un programme à un
autre à travers un flux de données ; on appelle
sérialisation d'un objet la transformation d'un objet en un
flux binaire ; le mécanisme inverse s'appelle la
désérialisation. Java a
élaboré un format de codage permettant la
sérialisation d'objets ; en Java, pour qu'un objet soit
sérialisable, il est nécessaire que sa classe
implémente l'interface java.io.Serializable.
superclasse
Si une classe B
hérite d'une classe A, A
est la superclasse de B. Toute classe autre que
la classe java.lang.Object a une unique
superclasse dont elle hérite directement. Cette superclasse
peut être indiquée par le mot
réservé extends
dans l'en-tête de la définition de la classe ; si
cette indication ne figure pas, la classe définie
hérite directement de la classe Object,
qui est donc alors sa superclasse.
surcharge
Une classe peut définir plusieurs méthodes ayant
un même nom du moment que les types des paramètres
de ces méthodes diffèrent (globalement, ou par
leur ordre) ; on dit alors qu'il y a surcharge. Une
différence uniquement sur le type de la valeur
renvoyée est interdite. Lorsqu'une méthode
surchargée est invoquée, la différence
sur les paramètres permet de déterminer la
méthode dont il s'agit.
test
d'égalité
Pour tester l'égalité entre deux
nombres, on utilise le double symbole == . Le
signe = est réservé à l'affectation
d'une valeur à une variable. Pour tester
l'égalité entre deux objets, le double symbole ==
ne convient pas, il faut utiliser la méthode equals
de la classe Object, à condition que
cette méthode soit redéfinie dans la classe des
objets qu'on veut comparer.
swing
Il s'agit du nom du kit de
développement de composants graphiques qui est venu
compléter l'AWT
qui existait dès la création du langage Java. Ce
kit est essentiellement consacré à des composants
dits légers, composants uniquement écrits en Java
qui ne nécessitent pas la création d'une
fenêtre native de la plate-forme utilisée. Les
classes de ce kit se trouvent essentiellement dans le paquetage javax.swing.
Voir aussi la
section consacrée aux interfaces graphiques.
thread
On dit qu'une application est
multithread si plusieurs tâches s'y exécutent en
parallèle ; chacune de ces tâches est
appelée un thread. Sur une machine mono-processeur, le
processeur partage son temps entre les différents threads,
accordant plus de temps à des threads qui ont
été définis comme prioritaires.
Voir aussi la
section consacrée aux threads.
type
énuméré
Un tel type permet essentiellement
de définir une énumération de
constantes puis des variables pouvant prendre comme valeur une des
valeurs énumérées. La
possibilité des types
énumérés date du JDK 5.0. Un type
énuméré est défini
à l'aide d'une classe qui étend la classe java.lang.enum.
Voir aussi la
section consacrée aux paquetages.
type primitif
Les types primitifs sont :
type
référence
Toute variable qui n'est pas d'un
type primitif est d'un type référence. Les
variables d'un type référence sont
destinées à référencer des
objets ou des tableaux.
On confond souvent, pour plus de
facilité d'expression, une référence
et l'objet référencé. Par exemple, si
on a :
JButton tracer = new
JButton("tracer");
on dira généralement « le JButton
tracer » (ou « le bouton tracer
») plutôt que « l'instance de la classe JButton
référencée par la variable tracer
» ; la dernière expression est pourtant plus
exacte.
valuer
Dire que l'on value une variable
signifie qu'on lui affecte une valeur.
©
Irène Charon, Télécom
ParisTech 2012