précédent | suivant | table des matières

Classe

Sommaire

Définition
Création d'instance
Attribut et méthode d'instance
1. Attribut
2. Méthode
Constructeurs, finalize
Attribut et méthode de classe
1. Bloc statique
classe Object

Une classe est la description de données appelées attributs, et d’opérations appelées méthodes.

Une classe est un modèle de définition pour des objets ayant le même ensemble d’attributs, et le même ensemble d’opérations.

A partir d’une classe on peut créer un ou plusieurs objets par instanciation ; chaque objet est une instance d’une seule classe.

Les caractéristiques de la programmation objet sont :

Encapsulation des données (attributs) et des comportements( méthodes) : les attributs et les méthodes sont définies dans le même environnement (capsule).
Masquage de l’information : l’utilisateur de la classe peut ne pas avoir accès directement aux attributs.
Héritage : on peut définir une classe à partir d’une autre classe.
Polymorphisme : une même méthode peut avoir un comportement différent en fonction de l’instance à la quelle est appliquée.

1 Définition d’une classe :

class X extends Y{
   // liste des attributs
   // liste des méthodes
}

Si Y est la classe de base de la hiérarchie des objets Java Object , alors la partie extends est facultative.

exemple :

class A extends  Object{
   int a ;
   void f(){ 
      ... 
   }
}

est équivalent à

class A {
   int a ;
   void f(){ 
      ... 
   }
}

Une classe a une visibilité :

public le mot class est alors précédé de public, tout utilisateur qui importe le paquetage peut utiliser la classe. Dans ce cas elle doit être définie dans un fichier qui a pour nom le nom de la classe.
privé le mot class est alors précédé de private, seules des classes définies dans le même fichier peuvent utiliser cette classe.
paquetage le mot class n’est pas précédé de mot particulier, toutes les classes du paquetage peuvent utiliser la classe.

2 Création d’instances

Pour créer une instance de la classe A, on écrira :

A a ;         // définition de la variable référence
a = new A() ; // création de l’instance

La création d’une instance par l’opérateur new se déroule en trois temps :

Réservation de l’espace mémoire suffisamment grand pour représenter l’objet.
Appel du constructeur de l’objet. Initialisation des attributs, et d’une référence à l’objet représentant la classe de l’instance en train d’être créée.
Renvoi d’une référence sur l’objet nouvellement créé

class Point{
   int x ;
   int y ;
      . . . 
}

Point a,  b ;
a = new Point(…) ;
b = a;

La destruction des instances se fait automatiquement par un « thread » le garbage collector qui cherche tous les objets qui ne sont plus référencés et les supprime. Le garbage collector peut être appelé directement par System.gc().

3 Attributs et méthodes

3.1 Attribut :

Un attribut se définit en donnant son type, puis son nom, ( [] pour un tableau ), et éventuellement une partie initialisation.

Un attribut a une visibilité :

public sa définition est précédée de public, et il peut être utilisé par tout utilisateur de la classe.
privé sa définition est précédée de private, et il ne peut être utilisé qu’à l’intérieur de la classe
protégé sa définition est précédée de protected, et il ne peut être utilisé qu’à l’intérieur de la classe, ou des classes dérivées.
paquetage l’attribut peut être utilisé dans toute classe du même paquetage.

A l’intérieur de la définition d’une méthode, l’accès à un attribut se fait soit directement, soit en préfixant l'attribut par this qui est une référence à l’objet pour lequel est appelé la méthode.

A l’extérieur de la définition de la classe, l’accès se fait en écrivant le nom de l’instance, un point le nom de l’attribut ou de la méthode.

class Point{
   private int x ;                
   public int y ;
   void f(){
      x = 0;
      this.y = 1;
   }     
}

En dehors de la définition de la classe :

Point p = new Point();
p.x = 0; // Erreur de compilation : la visibilité de x est privée !
p.y = 1;

3.2 Méthode :

Une méthode est définie par :

Son type de retour : type de la valeur retournée par la méthode. Si la méthode ne retourne pas de valeur le type spécifié est alors void. Le type retourné peut être tableau.
Son nom
Ses paramètres : les paramètres sont spécifiés par leur type et leur nom ( éventuellement [] ) et sont séparés par des virgules. Tous les paramètres sont des paramètres transmis par valeur. La plupart des paramètres ( sauf ceux de type primitif ) étant des références, la transmission de paramètre est en fait une transmission par référence : la valeur référencée peut être modifié, mais pas la référence elle même. On peut avoir un paramètre ellipse, et dans ce cas ce paramètre doit être le dernier de la liste des paramètres. Ce paramètre est en fait un tableau. L'appel de la méthode peut alors se faire avec un nombre variable de paramètres effectifs.
Exemple :
```
void m(X ... e){
       e est un tableau à une dimension d'éléments de type X
}
```
Un appel de la méthode m se fait alors de la façon suivante :
```
   m(null);
   m();
   m(x1);
   m(x1, x2);
   m(x1, x2, x3)
   ...
   ce dernier appel est équivalent à :
   X[] t={x1, x2, x3};
   m(t);
   ou
   m(new X[]{x1, x2, x3});
}
```

Une méthode est caractérisée par sa signature :

son nom.
la liste des types des paramètres, dans l'ordre.

Dans une classe deux méthodes différentes ne peuvent pas avoir la même signature. Deux méthodes ayant le même nom, mais des liste de types de paramètres différentes sont des surcharges l'une de l'autre.

Dans le corps d’une méthode, on peut utiliser la référence this, qui référence l’objet pour lequel la méthode est appelée, cet usage étant facultatif.
this ne peut pas être modifié.

Une méthode a une visibilité :

public sa définition est précédée de public, et elle peut être utilisée par tout utilisateur de la classe.
privé sa définition est précédée de private, et elle ne peut être utilisée qu’à l’intérieur de la classe
protégé sa définition est précédée de protected, et elle ne peut être utilisée qu’à l’intérieur de la classe, ou des classes dérivées.
paquetage la méthode peut être utilisée dans toute classe du même paquetage.

A l’extérieur de la définition de la classe, l’accès se fait en écrivant le nom de l’instance, un point le nom de l’attribut ou de la méthode.

4 Constructeurs, finalize

Certaines méthodes sont des constructeurs : ils ont pour nom le nom de la classe, ils ne retournent pas de valeur, et sont appelés au moment de la création d’une instance de la classe.

Si aucun constructeur n’est défini, Java fournit un constructeur sans paramètre appelé constructeur implicite ou par défaut, qui appelle le constructeur implicite de la super classe, les attributs ne sont pas initialisés.

Une classe peut être munie de la méthode finalize(). Cette méthode est appelée par le ramasse miettes ( garbage collector ) qui permet de récupérer l’espace occupé par les différents instances d’un programme qui ne sont plus utilisées.

5 Attributs et méthodes de classe.

Les attributs ou les méthodes d’une classe peuvent être static, et on parle de méthode ou d’attribut de classes, alors que pour les méthodes et attributs non statiques, on parle d’attribut et de méthode d’instances.

Pour les attributs, il n’y a qu’une seule représentation des attributs static et non pas une représentation par instance.

Un attribut, ou une méthode static peut être utilisé indépendamment de l’existence d’instances, en le préfixant par le nom de la classe. Une méthode static ne peut donc accéder qu’à des attributs ou méthodes static.

Exemples :

La classe Math ne contient que des attributs statiques ( PI, E ) et des méthodes statiques( sqrt, exp, sin, cos, log, …)
La classe BigInteger contient deux attributs static (ONE et ZERO) et une méthode statique BigInteger valueOf(long)
La classe Font contient plusieurs attributs static parmi lesquels BOLD, ITALIC, et PLAIN et des méthodes statiques parmi lesquelles Font decode(String str) qui fabrique une fonte à partie de son nom.
La classe Color contient des couleurs prédéfinies WHITE, RED, BLACK, BLUE, ...

5.1 Bloc Static.

Une classe ( non imbriquée ) peut être munie de un ou plusieurs blocs static qui sont exécutés au chargement de la classe.

Un bloc static est défini par :

static{
   . . .
}

Un bloc statique peut servir à l’initialisation des attributs static, ou au chargement de librairies.

6 La classe Object

La classe Object est la classe racine de toute la hiérarchie des objets Java, y compris les tableaux.

protected Object clone()	Création d’une copie de l’objet. Si l’objet n’implémente pas l’interface Cloneable, alors une exception CloneNotSupportedException est levée. Tous les tableaux implémentent l’interface Cloneable. Sinon la méthode crée une nouvelle instance de la classe et initialise tous ses attributs avec les valeur des attributs de l’objet : si l’attribut est une référence c’est la référence qui est copiée : il n’y a pas copie en profondeur.
public boolean equals(Object obj)	Retourne true si un objet est égal à un autre. La méthode doit être : Réflexive Transitive Symétrique
protected void finalize()	Appelée par le ramasse-miettes, quand il n’y a plus de référence à l’objet.
public Class getClass()	Retourne la classe de l’objet.
public int hashCode()	Retourne une valeur de hash-code pour l’objet.
public void notify()	Réveille un seul thread en attente sur le moniteur de l’objet.
public void notifyAll()	Réveille tous les threads en attente sur le moniteur de l’objet.
public String toString()	Retourne une représentation en chaîne de l’objet : la définition pour Object est getClass().getName() + '@' + Integer.toHexString(hashCode()).
public void wait()	Met le thread courant en attente jusqu’à ce qu’il soit réveillé par un notify() ou un notifyAll()
public void wait(long timeout)
public void wait(long timeout, int nanos)

haut de la page