Introduction

Cette notion constitue la pierre angulaire de JAVA et de manière générale celle de la programmation par objets.

Rien, que ce soit une constante,une variable ou une méthode (c'est-à-dire une fonction) ne peut être défini en dehors d'une classe.

La notion de classe étend celle de type. Une classe constitue un modèle ou patron sur lequel seront construit des objets (des instances de la classe), un peu comme une couturière fabriquerait par exemple une chemise à partir d'un patron trouvé dans un magazine spécialisé (par exemple «Modes et Travaux»).

La définition d'une classe spécifiera un certain nombre de caractéristiques des objets l'instanciant. Pour reprendre l'exemple de la couturière, quelques-unes de ces caractéristiques pourrait être la nature du tissu, la couleur, le nombre de boutons, le côté du boutonnage, la longueur des manches, etc.
En plus de ces attributs correspondants à des «grandeurs» de natures variées, s'ajoutent, et c'est ce qui fait l'originalité de l'approche objets, la définition d'un comportement constitué d'un ensemble de méthodes permettant de «dialoguer avec» ou «interroger» unobjet instance de la classe. Il est certes difficile d'imaginer un dialogue avec une chemise, mais pourquoi ne pas lui demander de réaliser un essayage sur une personne particulière ou de raccourcir la longueur de ses manches!

La constitution d'une classe

Les membres d'une classe

La définition d'une classe comporte celle d'un certain nombre d'éléments appelés membres de la classe :  :

• la déclaration de variables. Ces variables peuvent être initialisées explicitement et si elles ne le sont pas, elle reçoivent une valeur par défaut (null pour les variables de référence, (false pour les variables du type boolean et 0 pour les variables des autres types primitifs).
  Parmi ces variables, on peut distinguer :
  • les variables de classe : elles portent la qualification static dans leur définition. De telles varaibles seront caractéristiques de la classe, pas des objets l'instanciant. Toutes les instances de la classe partageront une telle variable. Vue comme une classe, un patron donné utilisé par une couturière, possèderait des variables de classe telles que le concepteur du patron, la date de conception ou le journal dans lequel il a été diffusé ;
  • les variables d'instances (ou d'objets) : ne portant pas le qualificatif précédent, chaque exemplaire construit sur le modèle fourni par la classe, possédera un exemplaire personnel de chacune d'elles (nombre de boutons, longueur des manches, encolure, tissu ou couleur). L'ensemble des valeurs de ces différentes variables pour un objet donné en constitueront l' état ;
• la définition (ou la déclaration dans le cas de classes abstraites ou d'interfaces) de fonctions appelées méthodes  permettant d'interroger un objet instanciant la classe. On parle d'invocation de méthode sur un objet.
  De même qu'on distingue des variables de classes et d'instances, on distingue les méthodes de classe (qualifiées static) et les méthodes d'objets : les premières interrogent la classe indépendamment en tant que telle et les secondes s'adressent à un objet particulier instanciant la classe et leur ensemble définit le variables de classe de l'objet ;
• la déclaration d'autres classes.

Les attributs des membres

Les membres d'une classe, en plus de pourvoir être ou non static, peuvent posséder d'autres attributs (la classe elle-même peut porter ces attributs) :

• des attributs de visibilté : ils définissent qui peut les accéder. Ces attributs sont public, protected et private ;
• l'attribut final interdit la modification du membre (pour une variable, cela signifie qu'elle est une constante, pour une méthode qu'elle n'est pas redéfinissable lors de la définition d'une sous-classe de la classe et pour une classe qu'on ne peut pas en définir de sous-classes).

En guise de conclusion

En résumé, la définition d'une classe peut être regardée sous différents aspects:

• elle définit un nouveau type ;
• elle réalise une implantation en définissant à la fois la structure d'un objet et son comportement, c'est-à-dire ce qu'on peut lui demander ;
• elle définit un modèle permettant de créer de nouveaux objets qui en constituent des instances.

Exemples

Dans cette exemple, correspondant à une ébauche d'implantation (d'où la présence de points de suspension) pour l'analogie avec les patrons de chemise, nous supposons que sont définies par ailleurs des classes Tissu, Personne, Couleur et Retouches. Dans cet exemple, nous utilisons des variables correspondant à des types non primitifs.

   --> cat PatronChemiseMT1952 {
          final static String="Modes et Travaux - 1952";
          final static int lgManchesMin = 200;
          private Tissu tissu;     // le tissu utilisé
          private Couleur couleur  // la couleur
          private int nbBoutons;   // le nombre de boutons
          private int lgManches;   // longueur des manches en mm
             .........    // d'autres variables
          public int getBoutons ( ) { return nbBoutons;}
          public int getManches ( ) { return lgManches;}
          public boolean raccourcir(int lg){
             // raccourcir les manches de lg mm 
             if (lgManches - lg < lgManchesMin)
                  return false; // impossible de raccourcir
             else {
                 lgManches -= lg;
                 return true;  // les manches ont été raccourcies   
             }
          }
          public Retouches essayerSur(Personne personne){
              Retouches retouches;
              // déterminer les retouches à faire sur une chemise
              // lors d'un essayage de la chemise et donc
              // construire un objet de la classe Retouches
                  .........
              return retouches;
              }
              ......  // d'autres méthodes
          }

Définition de sous-classe

Il est possible de définir une nouvelle classe comme sous-classe d'une autre, si tant est que celle-ci l'autorise, c'est-à-dire ne soit pas qualifiée final.

D'un point de vue pratique, cela est réalisé en Java sous la forme :

Nous reviendrons plus loin sur les phénomènes liés à la possibilité de définir des sous-classes : hiérarchie des types, redéfinition et masquage, surcharge et autres phénomènes connexes (typage statique et surcharge).

Interfaces et classes les implantant

Une classe peut de plus implanter une ou plusieurs (par exemple 2 comme dans la définition suivante) interfaces :

class   nomDeLaClasse   implements   interface1, interface2

Les classes abstraites

Enfin, une classe peut être abstraite. Dans ce cas on ne peut pas en créer d'instances (c'est-à-dire d'objet l'ayant comme type). La spécification abstract lui est appliquée.
Certaines méthodes de la classe peuvent ne pas être définies : elles doivent porter elles-mêmes la spécification abstract.

La classe Class

Les instances de cette classe (qui n'est pas sous-classable, c'est-à-dire dont une spécification est final) sont utilisées dans une application en cours d'exécution dans une JVM pour représenter les différentes classes ou interfaces utilisées par l'application. Il en va de même des tableaux et des types primitifs du langage. Cette classe n'a pas de constructeurs: les instances sont construites automatiquement par la JVM lors du chargement des classes.

Si on se réfère par exemple à la classe Object la méthode getClass permet d'accéder à la classe (référence sur Class) associée et à partir d'une telle référence des informations relatives à cette classe peuvent être obtenues par l'intermédiaire des méthodes de cette classe.

• Class[ ] getClasses( ) : renvoie un tableau contenant toutes les classes publiques et interfaces  ;
• String getName( ) : renvoie sous forme de chaîne le nom de l'entité (classe, interface, tableau ou type primitif) correspondante ;
• Class getSuperclass( ) : renvoie une référence sur la sur-classe ;
• boolean isInstance(Object obj) : renvoie true si la référence est compatible avec la classe courante.

   --> cat Class1.java
   class AAAA { int a; }
   class BBBB { }
   class CCCC extends AAAA{ }
   class Class1{
      public static void main(String[ ] arg){
      AAAA a = new AAAA( );
      CCCC c = new CCCC( );
      int[ ] t = new int[10];
      Object[ ] tabObj = new Objet[5];
      BBBB[ ] tabB = new BBBB[33];
      System.out.println("classe de a : " + a.getClass( ).getName( ));
      System.out.println("classe de c : " + c.getClass( ).getName( ));
      System.out.println("classe de t : " + t.getClass( ).getName( ));
      System.out.println("classe de tabObj : " + tabObj.getClass( ).getName( ));   
      System.out.println("classe de tabB : " + tabB.getClass( ).getName( ));  
      }
   }   
   --> java Class1
   classe de a : AAAA
   classe de c : CCCC
   classe de t : [I
   classe de tabObj : [Ljava.lang.Object;
   classe de tabB : [LBBBB;
   -->