Glossaire

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....
}

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" :

• 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".

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.

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.

• 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

prototype d'une méthode

On appelle ainsi la face externe d'une méthode, c'est-à-dire:

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.

© Charon Irène Paris 1999