Introduction

La notion de classe constitue le fondement de la programmation orientée objet. Une classe est la déclaration d'un type d'objet.

JSE offre un certain nombre de classes natives dans différents packages^[1] :

Il faut au moins connaitre les plus basiques, telles que String pour les chaines de caractères.

Créer une classe

En Java, les classes sont déclarées à l'aide du mot-clef class, suivi du nom de la classe déclarée, suivi du corps de la classe entre accolades. Par convention, un nom de classe commence par une majuscule.

public class MaClasse
{
    // corps de la classe
}

Le fichier contenant cette déclaration doit avoir pour extension .java. Un fichier peut contenir plusieurs déclarations de classes (ce n'est pas recommandé, il faut partir du principe 1 classe = 1 fichier, pour des problèmes évidents de relecture du code, devoir modifier du code où plusieurs classes sont écrites dans un seul fichier est le meilleur moyen de faire n'importe quoi), mais il ne peut contenir qu'au plus une classe dite publique (dont le mot-clef class est précédé de public, comme dans l'exemple ci-dessus). Le fichier doit obligatoirement porter le même nom que cette classe publique : dans l'exemple ci-dessus, il faudrait donc sauver notre classe dans un fichier nommé MaClasse.java.

Importer une classe

Un fichier .java peut commencer par une ou plusieurs déclarations d'import. Ces imports ne sont pas indispensables, mais autorisent en particulier l'accès aux classes prédéfinies sans avoir à spécifier leur chemin d'accès complet dans les collections de classes prédéfinies (organisées en packages). Dans le code ci-dessous, on souhaite par exemple utiliser la classe prédéfinie Vector (un type de données comparable à des tableaux dont la taille peut varier dynamiquement). Dans la sous-collection de classes prédéfinies "java", cette classe se trouve dans la sous-collection "util" (ou encore : cette classe est dans le package "java.util").

Sans import, il faut spécifier le nom complet de la classe (packages inclus) :

public class MaClasse
{
    // ... 
    public static void main(String[] args)
    {
        // sans l'import :
        java.util.Vector v = new java.util.Vector();
        // ...
    }
}

Avec import, seul le nom de la classe (sans packages) utilisée est nécessaire :

import java.util.Vector;

public class MaClasse
{
    // ... 
    public static void main(String[] args)
    {
        // avec l'import :
        Vector v = new Vector();
        // ...
    }
}

Quand plusieurs classes du même package sont utilisées, l'import peut utiliser le caractère étoile. Une classe peut donc avoir une longue liste d'import :

import java.util.Vector;
import java.util.ArrayList;
import java.util.HashMap;

public class MaClasse
{
    // ... 
    public static void main(String[] args)
    {
        Vector    v = new Vector();
        ArrayList a = new ArrayList();
        HashMap   m = new HashMap();
    }
}

ou une liste plus courte :

import java.util.*;

public class MaClasse
{
    // ... 
    public static void main(String[] args)
    {
        Vector    v = new Vector();
        ArrayList a = new ArrayList();
        HashMap   m = new HashMap();
    }
}

Enfin, la définition d'une classe peut aussi être précédée d'une (et une seule) déclaration de package, qui indique à quel emplacement se trouve le fichier dans l'arborescence des répertoires d'un projet Java. Par exemple, si la racine de notre projet Java est le répertoire /home/user/monProjet/ (ou C:\Mes documents\monProjet\ sous Windows) et que notre classe se trouve dans le sous-répertoire org/classes/ (soit, respectivement /home/user/monProjet/org/classes/ et c:\Mes documents\monProjet\org\classes\) nous aurons une déclaration du package de la forme :

package org.classes;

public class MaClasse
{
    // contenu de la classe
}

Il est fortement recommandé d'utiliser la déclaration de packages afin d'organiser le code :

• Sans package il est difficile de retrouver une classe au milieu d'un grand nombre de fichiers tous dans le même répertoire. Il faut regrouper les classes en petit nombre dans des packages différents.
• Un package rassemble les classes relatives à un même type de traitement (Exemple : java.io pour les classes traitant des entrées-sorties) ;
• Afin d'éviter les conflits, le nom du package doit suivre les recommandations de nommage suivantes :
  • Le nom du package doit commencer par un nom de domaine inversé (en général, celui du propriétaire du code) ;

    Exemple : org.wikibooks.fr

  • Les noms de package commençant par java et javax sont réservés.

Instancier une classe

Un objet peut être vu comme un ensemble de données regroupées à la manière des structures de C ou des enregistrements de Pascal. Une classe définit un modèle d'objet. Chaque objet créé à partir d'une classe est appelé instance de cette classe. L'ensemble de données internes d'un objet - les champs de cet objet - est spécifié par sa classe. Une classe peut en outre contenir : d'une part, des constructeurs - du code destiné à l'initialisation de ses instances au moment de leur création ; d'autre part des méthodes - du code destiné à la gestion des données internes de chacune de ses instances. On dit que ces méthodes sont invocables sur les objets.

Les objets se manipulent à l'aide de variables appelées références. Une référence vers un objet est l'analogue d'un pointeur vers celui-ci, au sens usuel de la notion de pointeur dans les langages impératifs tels que C - on dit que cette référence pointe sur l'objet, ou encore qu'elle référence cet objet. Notez que par abus de langage, mais par abus de langage seulement, on confond en pratique une référence vers un objet et l'objet lui-même. On parlera ainsi de "l'objet r" plutôt que de "l'objet référencé par r" ou "l'objet pointé par r". Pour autant, une référence vers un objet n'est pas l'objet lui-même : une référence peut ne pointer vers aucun objet - en particulier si elle est déclarée sans être initialisée, ou si on lui affecte la valeur de référence nulle, notée null ; elle peut pointer successivement vers des objets différents au cours du temps ; d'autre part, deux références distinctes peuvent pointer vers le même objet - les champs de l'objet sont alors accessibles, et les méthodes de sa classe deviennent invocables via l'une ou l'autre de ces deux références, avec le même effet.

Le type d'une référence spécifie la (ou même les) classe(s) des objets sur lesquels elle est susceptible de pointer. Une référence déclarée de type "référence vers MaClasse", où MaClasse est le nom d'une classe, est susceptible de pointer vers n'importe quelle instance de MaClasse.

MaClasse r; // déclaration d'une référence de type "référence vers MaClasse"

/* instructions diverses */

r = new MaClasse(); // création d'une instance de MaClasse, puis référencement par r de l'objet crée.

On peut déclarer une référence et lui faire immédiatement référencer une nouvelle instance, créée dans cette déclaration :

MaClasse r = new MaClasse(); // on crée une instance de MaClasse, que l'on référence par r

Références