|
Glossaire
API
Cela signifie Application Programming Interface.
Une API contient un ensemble de fonctions qui facilitent la
programmation.
L'API
de java contient entre autres les paquetages java.applet,
java.awt (awt pour Abstract Window Toolkit), java.awt.image, java.io,
java.lang, java.net et java.util.
awt
Cela signifie Abstract Window Toolkit. C'est le nom du paquetage
de java traitant de ce qui est nécessaire pour gérer des fenêtres,
des interfaces graphiques, des opérations de dessin.
champ
Un champ d'une classe est un attribut ou une méthode de cette
classe.
classe
Une classe est 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 :
- publique, si elle a le modificateur de visibilité public
: elle est alors visible de partout.
- avoir avoir la visibilité par défaut : elle n'est alors
visible que de son propre paquetage.
Une classe peut posséder le modificateur final
: elle ne peut alors pas être étendue.
Une classe peut posséder le modificateur abstract
: elle est alors abstraite. Dès qu'une classe contient une méthode
abstraite, elle doit elle aussi être déclarée abstraite.
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 ; l'objet retourné est implicitement
une instance de la classe.
Le constructeur sert à initialiser les attributs de la classe. La
première ligne d'un constructeur est un appel au constructeur de la
super-classe. Lorsque le programmeur n'a pas défini de
constructeur, le compilateur en ajoute automatiquement un qui ne
comporte qu'une seule instruction : super();
Cette instruction est un appel à un constructeur sans paramètre de
la super-classe.
Si la super-classe n'a pas de constructeur sans paramètre, il y
aura une erreur détectée à la compilation.
Voici un exeple d'une classe possédant deux constructeurs.
class Essai
{
int milieu;
int largeur;
Essai(int i)
{
milieu=i;
}
Essai(int a, int b)
{
this(a); //effectuera : milieu=a;
largeur=b;
}
}
attributs et méthodes de classe
Un attribut ou une méthode d'une classe sont dits de classe
lorsque le modificateur static est appliqué lors de
leur déclaration. On dira aussi qu'il s'agit d'un attribut ou d'une
méthode statiques.
Un attribut déclaré static existe dès que sa
classe est évoquée, en dehors et indépendamment de toute
instanciation. 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 sera utilisé un peu comme
une variable globale d'un programme non objet.
Une méthode, pour être de classe ne doit pas manipuler,
directement ou indirectement, des attributs non statiques de sa
classe. En conséquence, une méthode de classe ne peut utiliser
directement aucun attribut ni aucune méthode non statiques de sa
classe ; une erreur serait détectée à la compilation.
De l'extérieur d'une classe ou d'une classe héritée, un attribut
ou une méthode de classe pourront être utilisés précédés du
nom de leur classe (nom_d'une_classe.nom_de_l_attribut_ou_méthode_de_classe).
Par exemple, pour utiliser la méthode de classe sin de la
classe java.lang.Math avec un argument x, on écrira
Math.sin(x).
attributs et méthodes d'instance
Un attribut ou une méthode d'une classe sont dits d'instance dès
que le modificateur static n'est pas appliqué lors
de leur déclaration.
Un attribut d'instance 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
aura un exemplaire d'un certain 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. À l'envers,
il sera plus correct de déclarer en static une méthode
n'utilisant aucun attribut ou méthode non statiques de sa classe.
Lorsqu'une méthode d'instance est invoquée, la référence (qui
sera appelée this durant son déroulement) de
l'instance traitée lui est passée implicitement.
Un attribut ou une méthode d'instance ne pourront être invoqués,
à l'extérieur de la définition de leur classe ou d'une classe héritée,
qu'à partir d'une instance de classe (nom_d'une_instance.nom_de_l_attribut_ou_méthode_d'instance).
attributs et méthodes privés
Un attribut ou un méthode sont dits privés si on leur applique
le "modificateur de visibilite" private.
Exemples :
private int donnee;
private boolean realisable(Graphe graphe)
{
instructions....
}
Un attribut ou une méthode privés ne sont pas visibles en-dehors
de la définition de leur classe.
Un attribut privé ne pourra donc pas être modifié par des
instances de la classe qu'à travers des méthodes de la classe prévues
à cet effet ; le programmeur de la classe peut ainsi contrôler le
comportement des attributs privés (imaginer par exemple un attribut
entier qui doit toujours être strictement positif pour qu'une
instance de la classe se comporte correctement ; il serait dangereux
qu'un tel attribut puisse être modifié par un utilisateur de la
classe).
attributs et méthodes protégés
On dit qu'un champ
d'une classe est protégé si on lui a affecté le modificateur de
visibilité protected. Un champ protégé d'une
classe A est toujours visible à l'intérieur de son
paquetage. A l'extérieur du paquetage de A, considérons
une classe B qui hérite de A ; un champ protégé
de A est hérité par B et visible directement
dans B (au travers de la référence implicite this)
et visibles également au travers d'instances de B ou de
sous-classes de B définies dans B ; il n'est pas
visible dans d'autres conditions.
encapsulation
On parlera de l'encapsulation de données. Il s'agit d'un
principe fondamental d'un langage objet : 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 une donnée, il suffit de la déclarer privée,
c'est-à-dire de lui attribuier le modificateur de visibilité
"private".
Les modificateurs de visibilité "par défaut " ou "protected"
correspondent aussi à une certaine encapsulation.
exception
Une exception correspond à un événement anormal ou inatendu.
Les exceptions sont des instances de sous-classes des classes java.lang.Error
(pour des erreurs graves, qui devront généralement conduire à
l'arrêt du programme) et java.lang.Exception (pour des événements
inattendus, qui seront souvent traités sans que cela provoque l'arrêt
du programme).
Un grand nombre d'exceptions sont définis dans l'API.
Un mécanisme, utilisant le mot réservé throw,
permet de "lancer une exception" :
- if (il_y_a_un_probleme) throw new MyException)();
où MyException serait ici une sous classe de java.lang.Exception
définie par ailleurs
Quand une exception est lancée, toutes les instructions
suivantes sont ignorées et on remonte la pile des appels des méthodes
: on dit que l'exception se propage. Si, soit l'instruction qui
a lancé l'exception, soit une méthode de la pile des appels,
est situé dans un "bloc try":
- suivi d'un "bloc finally",
les instructions du "bloc finally"
sont exécutées et la propagation se poursuit ;
- 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 maFonction() throws MyException
signale qu'au cours de l'exécution de la méthode maFonction()
une exception de type MyException peut être lancée
sans être attrapée.
On n'est néanmoins dispensé de signaler dans les en-têtes des
méthodes le lancement éventuel des exceptions les plus
classiques, comme une ArrayIndexOutOfBoundsException
par exemple. Vous pouvez compter sur le compilateur pour vous
dire si vous avez oublié de signaler qu'une méthode peut
lancer une certaine exception.
Beaucoup de méthode de l'API
lancent des exceptions que l'on peut tenter d'attraper.
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.lang .Container dont hérite
tout composant graphique qui peut en contenir d'autres, permet
de choisir un gestionnaire de répartition. Vous pouvez utiliser
:
- java.awt.BorderLayout : pour répartir les
sous-composants au nord, au sud, à l'est, à l'ouest ou au
centre du composant.
- java.awt.CardLayout : pour répartir un ensemble
de sous-composants de telle sorte qu'un seul soit visible à
la fois, comme s'il s'agissait d'un jeu de cartes.
- java.awt.FlowLayout : pour arranger les
sous-composants en ligne, de la gauche vers la droite et du
haut vers le bas au fur et à mesure de leurs insertions.
- java.awt.GridLayout : pour arranger les
sous-composants dans une grille dont on peut éventuellement
préciser le nombre de lignes et de colonnes.
- java.awt.GridBagLayout : pour arranger les
sous-composants dans une grille, mais un sous-composant peut
utiliser plusieurs lignes ou colonnes et on peut donner
diverses informations sur la disposition des
sous-composants.
- javax.swing.BoxLayout qui permet de répartir les
composants soit les uns en-dessous des autres, soit les uns
à côté des autres.
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.
héritage
C'est un principe fondamental de la programmation objet.
Les sous-classes d'une classe disposent de tous les attributs et
méthodes de sa super-classe, moyennant néanmoins quelques
nuances liées aux modificateurs
de visibilité et au principe de la redéfinition
des méthodes.
En Java, une classe peut hériter d'une seule autre classe :
Java ne permet pas l'héritage multiple.
interface
Une interface comporte un en-tête (qui pourrait se voir
attribuer le modificateur de visibilité public)
suivi du mot réservé interface
suivi du nom de l'interface, puis, entre accolades, une liste de
constantes et de prototypes de méthodes.
Une interface I peut être implémentée par une
classe A, ce qui signifie que :
- la classe A déclare implémenter I,
avec le mot "implements"
- toutes les méthodes prototypées dans la classe I
doivent être définies dans la classe A.
Une interface sert essentiellement à
- regrouper des constantes
- permettre qu'un ensemble de classes, étendant éventuellement
d'autres classes, puissent implémenter une même interface.
Les interfaces ne seraient pas indispensables si Java
permettait l'héritage multiple (possibilité d'étendre
plusieurs classes à la fois).
Un nom d'interface peut être utilisé comme un nom de classe.
On pourra donc mettre dans une variable dont le type est une
interface n'importe quel objet implémentant l'interface en
question. Quelque soit l'objet référencé par la variable, on
pourra lui appliquer une méthode déclarée dans l'interface.
instance
Une classe
est une description abstraite d'un ensemble d'objets. Une
instance de classe est un objet construit selon le modèle
fourni par la classe.
Un objet et une instance de classe peuvent être considérés
comme synonyme.
méthode
On appelle 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 soit d'instance,
soit de
classe.
modificateurs de visibilite
Il est possible d'indiquer pour une classe ou un champ
(attribut ou méthode) d'une classe un certain degré
d'accessibilité. 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 visibilite.
- Une classe possède deux degrés de visibilité :le degré
par défaut et le degré publique 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 degrés de
visibilité : les modes indiqués par les mots public,
private
ou protected
auquels s'ajoute le mode par défaut ; dans ce dernier cas,
l'attribut ou la méthode en question sont visibles de
partout à l'intérieur de son paquetage et de nulle part à
l'extérieur de celui-ci.
objet
On appelle ainsi une instance d'une classe.
polymorphisme
Supposons qu'une classe B hérite d'une classe A.
Supposons que la classe A définisse une méthode
d'instance m redéfinie par la classe B (la méthode
m peut avoir ou non des paramètres). Supposons enfin
que l'on ait les déclarations et instructions suivantes :
B b = new B();
C c = new C();
A a;
a = b;
a.m(); //1
a = c;
a.m(); //2
a = new A();
a.m(); //3
Alors, au moment de l'instruction 1, c'est la méthode m
de la classe B qui est exécutée ; au moment de
l'instruction 2, c'est la méthode m de la classe C
qui est exécutée ; au moment de l'instruction 3, c'est la méthode
m de la classe A qui est exécutée. C'est
cette propriété que l'on appelle polymorphisme.
prototype d'une méthode
On appelle ainsi la face externe d'une méthode, c'est-à-dire:
- type_de_retour nom(liste d'arguments);
redéfinir
On peut redéfinir une méthode 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 types et nombre
d'arguments et même type de retour que la méthode d'origine.
L'interpréteur cherche la définition d'une 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 super-classe.
types primitifs
Les types primitifs sont :
- le type booléen boolean, qui
n'est pas un type entier, et qui peut prendre les valeurs false
et true
- le type caractère char
- les types entiers byte, short,
int et long
- les types nombres flottants float
et double
type référence
Toute variable qui n'est pas d'un type primitif est d'un type
référence. Une référence est en fait une adresse en mémoire
d'un objet.
super-classe
On appelle ainsi une classe qui est étendue par d'autres
classes.
Considérons une classe C. La super-classe de C est la classe
dont hérite directement C. Cette super-classe peut être indiquée
par le mot réservé extends au moment de la définition
de la classe. Si ce n'est pas le cas, la classe C hérite
directement de la classe java.lang.Object, qui est donc
sa super-classe.
surcharge
Une classe peut définir plusieurs méthodes ayant un même
nom du moment que les suites des types de paramètres de ces méthodes
diffèrent (globalement, ou par leurs ordres). Une différence
uniquement sur le type de la valeur retourné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 à exécuter.
|
