Programmation Java/Les classes en Java
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 :
Il faut au moins connaitre les plus basiques, telles que codice_1 pour les chaines de caractères.
Créer une classe.
En Java, les classes sont déclarées à l'aide du mot-clef codice_2, 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 mot clé codice_3 précise que la classe est publique, donc utilisable par toute autre classe quel que soit le paquetage où elle est définie.
Le fichier contenant cette déclaration doit avoir pour extension ".java".
Ce fichier doit avoir le même nom que la classe publique déclarée.
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 codice_2 est précédé de codice_3, 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 codice_6 (ou codice_7 sous Windows) et que notre classe se trouve dans le sous-répertoire codice_8 (soit, respectivement codice_9 et codice_10) 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 :
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 codice_15" plutôt que de "l'objet référencé par codice_15" ou "l'objet pointé par codice_15". 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 codice_18 ; 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 codice_19", où codice_19 est le nom d'une classe, est susceptible de pointer vers n'importe quelle instance de codice_19. 
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