Programmation Java/Les classes en Java

Un livre de Wikilivres.
Aller à : navigation, rechercher


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

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.

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
}
Nuvola apps bookcase.svg
Important

Le package java.lang est automatiquement importé dans tous les programmes, il permet d'utiliser les types primitifs.

Instanciation d'une classe[modifier | modifier le wikitexte]

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