L'Altruiste : Le guide des langages Web

Java est un langage de programmation créé en 1995 par Sun Microsystems suite aux recherches, débutées en 1990, sur un projet d'environnement indépendant du couple système d'exploitation et matériel.

Profitant de la rapide progression de l'Internet et du facteur inhibiteur que constituait l'hétérogénéité des plateformes dans le secteur, le langage Java s'imposa en acteur incontournable dans la mesure ou il permit d'harmoniser le développement sur le World Wide Web et tous ses dérivées comme les intranet ou les extranet.

De plus, la politique de Sun Microsystems a favorisé l'expansion fulgurante de Java, en fournissant gratuitement les environnements de développement, les fameux JDK (Java Development Kit) et SDK (Software Development Kit) et surtout en favorisant l'octroi de licences d'utilisation à la plupart des intervenants majeurs de l'Internet, tels que Netscape, Microsoft ou encore Opera.

Le but de ce nouveau langage de programmation étant de créer des applications fonctionnant sur des réseaux en architecture client/serveur, nécessite, néanmoins, l'installation préalable d'un environnement applicatif, le JDK , sur un serveur ou sur une station de travail.

La portabilité du langage Java résulte du fait que le code source d'un programme est compilé pour produire un pseudo-code (ou byte-code) contenu dans un fichier classe portant l'extension .class. Ensuite, lors de la phase d'interprétation par la Machine Virtuelle Java (JVM : Java Virtual Machine), ce fichier est soumis à l'éditeur de liaison (linker) afin d'assurer la compatiblité avec le système d'exploitation hôte et mis en relation avec la bibliothèque de classes Java pour finalement être exécuté par la machine cliente. La JVM, l'éditeur de liaison, et la bibliothèques de classes sont des composants de l'environnement d'exécution Java (JRE : Java Runtime Environment) devant être installée sur la plateforme cliente.
Cette faculté d'adaptation permet, donc, à un programme Java de pouvoir être implémenter sur toutes les plateformes comme les ordinateurs personnels équipés de Microsoft Windows ou de Linux, sur des stations de travail Unix ou encore sur des PDA (Personal Digital Assistant), ou encore sur la prochaîne génération de téléphones portables et à condition que le JRE ait été installé au préalable.

Java est un langage orienté objet, c'est-à-dire qu'il possède la faculté, à l'image du C++ ou du Visual Basic, de manipuler des objets ou plus précisément des instances de classes, définies dans les différents package accompagnant un SDK (Software Development Kit).

La fiabilité d'un programme Java tient au fait que certaines fonctionnalités ont été expurgées afin d'éviter certaines erreurs systèmes récurrentes dans la programmation à partir du C++ notamment.
Par exemple, l'allocation de mémoire par des pointeurs a été purement et simplement abandonnée, la gestion de la mémoire étant, désormais, assurée automatiquement par Java.
De cette manière, on évite également, toutes manipulations nuisibles de la mémoire.

D'ailleurs, l'interprétation d'un programme Java fait appel à plusieurs caractéristiques spécifiques et complexes de Java qui se complémentant, assurent aux utilisateurs, une sécurité quasi-absolue. Autrement dit, des programmeurs malveillants ne peuvent s'appuyer sur le langage Java pour concevoir et inoculer des virus sur des stations clientes ou des serveurs d'un réseau.

Non seulement, l'universalité de Java fait de ce langage un support efficace pour tous types d'applications à l'instar du C, mais en plus, dépassant sa mission initiale, le langage Java tend à devenir le fondement d'un nouveau modèle d'architecture des systèmes d'information.

De nombreux éditeurs spécialisés appelés Environnement de Développement Intégré (IDE : Integrated Development Environment), intégrant un compilateur, un débogueur, ainsi qu'une vaste panoplie d'assistants, permettent de créer de puissantes applications Java, en outre, il est également possible d'utiliser notepad ou n'importe quel éditeur de texte pour écrire ses propres programmes Java puis de les compiler (javac.exe) et de les exécuter (java.exe) avec le J2SDK de Sun Microsystems.

• JBuilder édité par Borland.
• Eclipse édité par la fondation Eclipse.
• WebSphere Application Server édité par IBM.
• JCreator édité par Xinox Software.
• NetBeans édité par Sun Microsystems et NetBeans.org.
• Java 2 Software Development Kit édité par Sun Microsystems.

La plateforme Java comprend un certain nombre d'outils dont en particulier le compilateur (javac.exe), la machine virtuelle (java.exe) et le générateur de documentation (javadoc.exe).

Avant de commencer à écrire une seule ligne de code Java, il est nécessaire de connaître certains éléments fondamentaux.

Pour une quelconque opération sur un fichier source Java (NomFichier.java) ou un fichier classe (NomFichier.class), il est nécessaire d'indiquer au système d'exploitation et à fortiori aux applications d'environnement de développement intégré (EDI) où se trouve les différents outils Java.

Le lancement de n'importe lequel des outils nécessite l'apport d'au moins, un élément relativement important. Il s'agît de la variable d'environnement PATH déclarant la localisation des fichiers binaires exécutables du Java 2 SDK.

Sous DOS (cmd.exe)
C:\>path /?
Affiche ou définit un chemin de recherche des fichiers exécutables.

PATH [[lecteur:]chemin[;...][;%PATH%]
PATH ;

Entrez PATH ; pour effacer les chemins de recherche et indiquer à cmd.exe
de ne chercher que dans le répertoire en cours.
Entrez PATH sans paramètres pour afficher le chemin de recherche en cours.
L'ajout de %PATH% dans le paramètre du nouveau chemin permet d'ajouter
celui-ci à l'ancien chemin de recherche.

C:\>path Validez

PATH=C:\j2sdk1.4.1\bin;C:\WINNT\system32;C:\WINNT

Si le répertoire d'installation des fichiers binaires du kit logiciel de développement Java 2 (Java 2 SDK) n'existe pas, alors dans le but d'éviter certains désagréments, il faudra ajouter ce chemin au PATH.

Ajout du chemin
Sous DOS
C:\>path=C:\j2sdk1.4.1\bin;%PATH% Validez

Sous Linux
setenv PATH chemin/j2sdk1.4.1 Validez
ou
PATH = chemin/j2sdk1.4.1
export PATH

De cette manière, chaque fichier exécutable sera directement accessible de n'importe quel répertoire dans la session DOS en cours. Pour conserver ce paramétrage, il suffit de modifier la variable système Path à partir des variables d'environnement des propriétés systèmes (Clic droit sur le Poste de travail -> Propriétés).

Le compilateur et la machine virtuelle ont besoin d'un argument fondamental, pour respectivement, construire un fichier classe à partir du source et des éventuelles autres classes importées et lancer une application Java à partir du répertoire contenant les classes appelées.

C:\>javac /? Validez
javac: invalid flag: /~
Usage: javac <options> <source files>
where possible options include:
  -g                        Generate all debugging info
  -g:none                   Generate no debugging info
  -g:{lines,vars,source}    Generate only some debugging info
  -nowarn                   Generate no warnings
  -verbose                  Output messages about what the compiler is doing
  -deprecation              Output source locations where deprecated APIs are us
ed
  -classpath <path>         Specify where to find user class files
  -sourcepath <path>        Specify where to find input source files
  -bootclasspath <path>     Override location of bootstrap class files
  -extdirs <dirs>           Override location of installed extensions
  -d <directory>            Specify where to place generated class files
  -encoding <encoding>      Specify character encoding used by source files
  -source <release>         Provide source compatibility with specified release
  -target <release>         Generate class files for specific VM version
  -help                     Print a synopsis of standard options
  

C:\>java -help Validez
Usage: java [-options] class [args...]
           (to execute a class)
   or  java -jar [-options] jarfile [args...]
           (to execute a jar file)

where options include:
    -client       to select the "client" VM
    -server       to select the "server" VM
    -hotspot      is a synonym for the "client" VM  [deprecated]
                  The default VM is client.

    -cp -classpath <directories and zip/jar files separated by ;>
                  set search path for application classes and resources
    -D<name>=<value>
                  set a system property
    -verbose[:class|gc|jni]
                  enable verbose output
    -version      print product version and exit
    -showversion  print product version and continue
    -? -help      print this help message
    -X            print help on non-standard options
    -ea[:<packagename>...|:<classname>]
    -enableassertions[:<packagename>...|:<classname>]
                  enable assertions
    -da[:<packagename>...|:<classname>]
    -disableassertions[:<packagename>...|:<classname>]
                  disable assertions
    -esa | -enablesystemassertions
                  enable system assertions
    -dsa | -disablesystemassertions
                  disable system assertions

Les commandes javac et java possèdent tous les deux, un argument appelé -classpath <chemin vers les classes> permettant de diriger le compilateur ou la machine virtuelle vers le répertoire de classes adéquat.

Compilation du source FichierClasse.java
javac -classpath c:\travail\classes -d c:\travail\classes FichierClasse.java

Dans ce premier cas, le compilateur recherche dans le répertoire spécifiée par -classpath les classes à importer dans le fichier source Java. D'autre part, l'argument -d fournit une destination vers un répertoire, pour le fichier classe généré à partir de cette instruction.

Exécution du fichier classe FichierClasse.class
java -classpath c:\travail\classes FichierClasse

Dans ce second cas, la machine virtuelle tente de lancer un fichier classe à partir de son identificateur (FichierClasse) et de son chemin (c:\travail\classes).

La variable ClassPath indique donc à ces outils la localisation des classes à utiliser. Si cette variable n'est pas renseignée, des classes importées risquent de ne pas être trouvées par les outils Java, et partant, le traitement échouera.

Sous Linux, il faudra créer une variable d'environnement CLASSPATH à l'aide de la commande setenv ou export.

% setenv CLASSPATH chemin/classe:...:chemin/classeN Validez


CLASSPATH = chemin/classe:...:chemin/classeN
export CLASSPATH

La plupart des EDI Java proposent dans leur configuration, différents moyens permettant de régler correctement les variables PATH et CLASSPATH.

En ce qui concerne, le générateur de documentation (javadoc.exe), à l'image du compilateur, peut recevoir un argument de destination (-d <répertoire>) pour les fichiers HTML générés.

javadoc -d c:\travail\docs FichierSource.java

L'installation de cet outil s'effectue assez simplement dans un EDI, en passant en général par les options de configuration. Ces dernières permettent l'intégration d'utilitaires Java avec leurs arguments et leur chemin.

D'autres notions sont nécessaires afin de parvenir à tirer pleinement parti de son environnement de développement. L'espace de travail (workspace) est un conteneur de projets, lesquels contiennent les fichiers sources Java.

Développer avec un EDI contraint à s'imposer une certaine organisation en l'occurrence, de toujours travailler au sein d'un projet lequel peut être englobé dans un espace de travail.

La syntaxe définit des règles d'écritures sans lesquelles un programme Java ne pourrait fonctionner correctement.

La syntaxe du langage Java s'appuie sur le modèle du C ou du C++.

Les programmes Java sont écrits dans le jeu de caractères Unicode.

Néanmoins, les traductions lexicales sont fournies pour que les échappements Unicode soient utiisés pour inclure n'importe quel caractère utilisant seulement les caractères ASCII. Les fins de ligne sont définies afin de supporter une compatibilité avec les différentes normes des systèmes hôtes existants.

Les caractères Unicode résultant d'une traduction lexicale sont réduits à une séquence d'éléments d'entrées, lesquels sont des espaces blancs, des commentaires et des symboles tels que des identificateurs, des mots clés, des littéraux, des séparateurs et des opérateurs de la syntaxe Java.

Le caractère d'échappement antislash '' permet de traduire le code hexadécimal d'un caractère Unicode.

u{Code hexadécimal}

uXXXX

u0061 // correspond à 'a'

u0035 // correspond à '5'

Les espaces blancs sont les caractères ASCII SP (SPace), HT (Horizontal Tabulation), FF (Form Feed) et les caractères de fin de ligne, permettent lors d'une traduction lexicale de décomposer la séquence en plusieurs symboles.

public int x=0, y=0;

public{SP}int{SP}x=0,{SP}y=0;{CRLF}

/* mot clé : 'public'
  identificateurs : 'int', 'x' et 'y'
  opérateurs : '='
  littéraux : '0'
  séparateurs : ',' et ';' */

Les lignes sont terminées par une séquence de deux caractères ASCII, CR (Carriage Return) et LF (Line Feed).

Les identificateurs Java sont des séquences de lettres et de chiffres représentant des variables, des constantes, des méthodes, des classes, des interfaces ainsi que des labels.

Toutefois, un identificateur ne peut commencer que par une lettre Java, un caractère de soulignement _ ou un signe dollar $ et contenir des caractères alphanumériques ainsi que des symboles monétaires.

CONSTANTE

_erreur

W_800
H_600

$monnaie

Evidemment, l'identificateur ne doit pas contenir d'espaces blancs (espace, tabulation, saut de ligne etc.), de caractères de ponctuation (point, deux-points, point-virgule, virgule, etc.) ou de tout autres caractères symboliques.

Les identificateurs ne peuvent avoir la même orthographe que les mots clés, les littéraux prédéfinis, c'est-àdire les valeurs booléennes true et false et la valeur null.

Les littéraux représentent les valeurs des variables ou des constantes, soit des séquences de caractères digitaux pour les nombres ou n'importe quel caractères alphabétiques, numériques ou de ponctuation pour les chaînes de caractères.

nom_variable = {valeur_littérale};

temp = null;

hauteur_ecran = 600;

prix_produit_x_100 = 159.95;

reussite_operation = true;

designation_produit = 'Cartouche d'encre noire pour imprimante';

Les littéraux textuels doivent être encadrés par des guillemets doubles ou simples, tandis que les valeurs numériques, booléennes ou nulles, n'en ont guère besoin.

Les littéraux entiers peuvent être exprimés en base décimale (0-9), octale (0-7) ou hexadécimale (0-9A-F). Les valeurs octales doivent commencer par un zéro et les valeurs hexadécimales par 0X ou 0x. Les littéraux entiers longs doivent se terminer par un caractère L ou l, le premier étant préféré pour une meilleure lisibilité.

145 //littéral entier décimal
0777 //littéral entier octal
0xFF00FF //littéral entier hexadécimal

16359489123696L

Les littéraux à virgule flottante se caractérisent par deux parties distinctes séparées par un point. La composante décimale se situe à gauche du point, tandis que la composante fractionnaire est à droite. Les valeurs doubles et flottantes (float) se distinguent respectivement par les caractères D ou d et F ou f placés à la fin du nombre. Un caractère E ou e indique un exposant signé représentant la puissance 10 à appliquer au nombre situé à sa gauche.

11.58 //littéral à virgule flottante

648.965148F // littéral flottant 

0.06598E+16 // littéral double avec exposant positif 0.06598*1016

.485e-28F // littéral flottant avec exposant négatif 0.485*10-28

0D // littéral double

Les littéraux booléens représentent les valeurs de bit 0 ou 1 symbolisées par les séquences de caractères true et false.

debut = true;

fin = false;

Les littéraux caractères sont des valeurs ne contenant qu'un unique caractère exprimé normalement, sous sa forme Unicode ou au moyen du caractère d'échappement .

'z' // littéral caractère

'\u0051' // littéral avec valeur Unicode

'\t' // littéral avec valeur d'échappement

Le littéral Unicode doit toujours possèder un caractère u minuscule.

'\uXXXX'

Les séquences d'échappement permettent d'inclure des caractères spéciaux dans des littéraux caractères et chaînes.

Les littéraux chaînes de caractères sont des combinaisons de zéro à plusieurs caractères compatibles à Unicode. Les séquences d'échappement sont également permises dans de tels littéraux. Les chaînes de caractères peuvent être fractionnées sur plusieurs lignes en ajoutant un signe plus (+) au début de chacune des parties.

"Une chaîne" // littéral chaîne

"" // chaîne vide

// littéral chaîne sur deux lignes
"\tS'il\u0020avait\u0020pu\u0020l'obtenir,\u0020nous"
+ "\u0020aurions\u0020été\u0020siu0020heureux\u0020!"

'

Le littéral null représente un type spécial symbolisé par une séquence de caractères null.

nb_achat = null;

nom_variable = {valeur_littérale};

temp = null;

hauteur_ecran = 600;

prix_produit_x_100 = 159.95;

reussite_operation = true;

designation_produit = 'Cartouche d'encre noire pour imprimante';

Les littéraux textuels doivent être encadrés par des guillemets doubles ou simples, tandis que les valeurs numériques, booléennes ou nulles, n'en ont guère besoin.

Les littéraux entiers peuvent être exprimés en base décimale (0-9), octale (0-7) ou hexadécimale (0-9A-F). Les valeurs octales doivent commencer par un zéro et les valeurs hexadécimales par 0X ou 0x. Les littéraux entiers longs doivent se terminer par un caractère L ou l, le premier étant préféré pour une meilleure lisibilité.

145 //littéral entier décimal
0777 //littéral entier octal
0xFF00FF //littéral entier hexadécimal

16359489123696L

Les littéraux à virgule flottante se caractérisent par deux parties distinctes séparées par un point. La composante décimale se situe à gauche du point, tandis que la composante fractionnaire est à droite. Les valeurs doubles et flottantes (float) se distinguent respectivement par les caractères D ou d et F ou f placés à la fin du nombre. Un caractère E ou e indique un exposant signé représentant la puissance 10 à appliquer au nombre situé à sa gauche.

11.58 //littéral à virgule flottante

648.965148F // littéral flottant 

0.06598E+16 // littéral double avec exposant positif 0.06598*1016

.485e-28F // littéral flottant avec exposant négatif 0.485*1028

0D // littéral double

Les littéraux booléens représentent les valeurs de bit 0 ou 1 symbolisées par les séquences de caractères true et false.

debut = true;

fin = false;

Les littéraux caractères sont des valeurs ne contenant qu'un unique caractère exprimé normalement, sous sa forme Unicode ou au moyen du caractère d'échappement .

'z' // littéral caractère

"\u0051" // littéral avec valeur Unicode

"\t" // littéral avec valeur d'échappement

Le littéral Unicode doit toujours possèder un caractère u minuscule.

'\uXXXX'

Les séquences d'échappement permettent d'inclure des caractères spéciaux dans des littéraux caractères et chaînes.

Les littéraux chaînes de caractères sont des combinaisons de zéro à plusieurs caractères compatibles à Unicode. Les séquences d'échappement sont également permises dans de tels littéraux. Les chaînes de caractères peuvent être fractionnées sur plusieurs lignes en ajoutant un signe plus (+) au début de chacune des parties.

"Un chaîne" // littéral chaîne

"" // chaîne vide

// littéral chaîne sur deux lignes
"S'il\u0020avait\u0020pu\u0020l'obtenir,\u0020nous"
+ "\u0020aurions\u0020été\u0020si\u0020heureux\u0020!"

Le littéral null représente un type spécial symbolisé par une séquence de caractères null.

nb_achat = null;

Plusieurs caractères spéciaux sont utilisés comme séparateur conformément aux spécifications grammaticales du langage Java.

Une expression peut être n'importe quel ensemble valide de littéraux, de variables, d'opérateurs, d'instructions Java et d'autres expressions, qui correspond à une valeur simple.

int i = 0;

i += 5;

String texte = "L'agneau sortit de l'étable alors 
                            que le loup embusqué l'attendait.";

double valeur3 = Math.max(valeur2, Math.pow(valeur1, 10));

String resultat = texte.toLowerCase();

Cette valeur peut être un nombre (42), une chaîne de caractères (olivier), ou encore une valeur logique (true ou false).

Conceptuellement, il y a deux types d'expressions : celles qui assignent une valeur à une variable, et celles qui ont simplement une valeur.

Par exemple, l'expression i = 0 est une expression qui affecte à i la valeur zéro. Cette expression elle-même correspond à zéro.

La plupart des expressions font appel à divers opérateurs pour effectuer des affectations, des calculs arithmétiques ou encore des concaténations.

Ainsi, à partir d'expressions basiques, il est possible de construire des expressions extrêmenent complexes retournant toujours une valeur.

if(x == 1 && y == 0)
    // instructions...

if(x > y || x < 100)
    //instructions...

String ch = x < y ? "x < y" : "x > y";

Une expression est toujours typée, c'est-à-dire, que la valeur résultante possède un certain type primitif, à l'image des valeurs numériques ou un type composite pour notamment les chaînes de caractères.

Les expressions sont la plupart du temps évaluées de la gauche vers la droite et parfois certains membres ne sont pas évalués du tout, dans le cas des opérations logiques avec un OU (||), un ET (&&) ou l'opérateur ternaire (?:).

En outre, une expression suivie du séparateur point-virgule (;) devient une instruction.

Les instructions sont des suites de composants Java (les identificateurs, les mots-clefs, les constantes, les opérateurs) terminées par un point-virgule.

System.out.println("Un texte...");

int une_variable = 10, une_autre_variable = 15;

Une ou plusieurs instructions peuvent être rassemblées par des accolades ({...}) pour former une instruction composée ou plus communément, un bloc d'instructions.

if(i < 0) {
  message = "Attention, i ne peut pas être négatif !"; 
  System.out.println(message); 
}

Un bloc d'instruction agît syntaxiquement parlant, comme une seule instruction.

En outre, une instruction composée d'un spécificateur de type, éventuellement précédé de modificateurs d'accès, suivi d'un identificateur et éventuellement d'une affectation et enfin terminé par un point-virgule, s'appelle une déclaration de variable.

Les commentaires permettent de rendre votre code lisible et surtout d'en faciliter ultérieurement la maintenance.

En général, l'insertion de commentaire se fait soit en fin de ligne, soit sur une nouvelle ligne mais en aucun cas au sein d'une ligne de commande.

Il existe deux méthodes permettant d'intégrer des commentaires aux programmes Java.

La première consiste à placer un double slash (//) devant le texte comme dans l'exemple ci-dessous :

image = "fond.gif"; //image de fond

if (x = 2) //redirection vers la seconde page
{
  url = ("page2.html");
}
else
{ //sinon retourne à la page d'accueil
  url = ("accueil.html");
}

La seconde solution est d'encadrer le texte par un slash suivi d'une étoile (/*) et la même séquence inversée (*/) comme le montre l'exemple suivant :

/*Voici un commentaire*/

/*

  Encore un autre commentaire

*/

/*Ce commentaire est

   écrit sur deux lignes*/

Les programmes Java acceptent également des commentaires de documentation visualisables par des navigateurs Web.
Ces commentaires peuvent contenir du balisage HTML, ainsi que des balises spéciales commençant par une arobasce (@) permettant de documenter un programme Java sous une forme standard.

/**

 * <p>Titre : Programme Java</p>

 * <p>Description : Mon premier programme...</p>

 * <p>Copyright : Copyright (c) 2002</p>

 * <p>Société : Ma société</p>

 * @author Marc MOLARDI

 * @version 1.0

 */

Ce genre de commentaire permet de créer une documentation HTML à partir du fichier source (fichier.java)en utilisant l'utilitaire javadoc.exe du kit de développement Java.

javadoc -d c:\chemin\doc\ fichier_source.java

Les opérateurs permettent d'accéder, de faire référence ou de manipuler les éléments du langage Java tels que des classes ou des variables.

Le langage Java possède, donc, un jeu complet d'opérateurs permettant de multiples combinaisons d'expressions.

Les opérateurs d'affectation permettent l'assignation d'une valeur à une variable.

variable opérateur valeur;

L'opérateur d'affectation de base est le signe d'égalité (=), qui assigne la valeur de son opérande droit à son opérande gauche. C'est-à-dire, droit = gauche assigne la valeur de gauche à droite.

variable = valeur;

Il est également possible de combiner les opérations d'affectation et de calcul par l'intermédiaire d'un opérateur spécial.

variable op= valeur;
// est équivalent à
variable = variable op valeur;

x += 5; // correspond à x = x + 5;

y /= 2; // correspond à y = y / 2;

La promotion arithmétique assure la compatibilité entre le type de chacune des opérandes, par une conversion au type plus large de l'opérande la plus faible si les types sont compatibles, sinon le compilateur génère une erreur si le transtypage doit être explicite.

Pour une affectation simple et combinée de valeurs primitives numériques, le type de l'opérande de gauche doit être identique ou plus large que celui de l'opérande de droite, sinon une erreur de dépassement de capacité peut se produire lors du temps d'exécution.

type_opeD operandeD;
type_opeG operandeG op= operandeD;
// est équivalent à
type_opeG operandeG op= (type_opeG)operandeD;

class op {
  public static void main(String[] args){
  byte   w = 8;
  int  x = 422;
  float  y = 12.4f;
  double z = 448.3641d;

  System.out.println("1 : " + w + " += " + x + " = " + (w += x));
  System.out.println("2 : " + x + " += " + y + " = " + (x += y));
  System.out.println("3 : " + y + " += " + z + " = " + (y += z));
  System.out.println("4 : " + w + " += " + z + " = " + (w += z));
  System.out.println("5 : " + z + " += " + w + " = " + (z += w));
  System.out.println("6 : " + x + " += " + w + " = " + (x += w));
  }
}
// affiche
1 : 8 += 422 = -82 // erreur
2 : 422 += 12.4 = 434
3 : 12.4 += 448.3641 = 460.7641
4 : -82 += 448.3641 = 110 // erreur
5 : 448.3641 += 110 = 558.3641
6 : 434 += 110 = 544

Pour une affectation d'objets, les types références doivent être compatibles entre eux, sinon le compilateur générera une erreur.

• Les classes doivent donc être identiques ou le type de l'opérande de gauche doit être une superclasse.
• Si l'opérande de gauche possède un type représentant une interface, l'opérande de droite doit implémenter cette interface.
• Si l'opérande de gauche possède un type Object, l'opérande de droite peut être de n'importe quel type.

interface Inter { ... }
class SuperClasse implements inter { ... }
class Classe extends SuperClasse { ... }

class Affectation {
  public static void main(String[] args){
  Classe RefObjD = new Classe();
  Classe RefObjG = RefObjD;
  // ou
  SuperClasse RefObjG = RefObjD;
  // est équivalent à
  SuperClasse RefObjG = (SuperClasse)RefObjD;

  Object RefObjO = RefObjG;
  // est équivalent à
  Object RefObjO = (Object)RefObjG;

  Inter RefObjI = RefObjG;
  // est équivalent à
  Inter RefObjI = (Inter)RefObjG;
  }
}

Les opérateurs de signe permettent d'indiquer le signe d'une valeur numérique.

Ces opérateurs se placent toujours à la gauche des opérandes.

{[ + ] | - } opérande

Le signe moins (-) est requis pour spécifier qu'un opérande est négatif.

-opérande

int x = -10;
int y = -x;

Le signe plus (+) est optionnel, puisque par défaut tous les opérandes sont positifs.

+opérande
// est équivalent à
valeur_numérique

+10
// est équivalent à
10

double a = +14.62;
double b = a;

Les opérateurs de signe peuvent être appliqués à un opérande de n'importe quel type primitif (byte, short, char, int, long, float et double) à l'exception des booléens.

Les opérateurs arithmétiques permettent d'effectuer des calculs mathmétiques.

x = 100;
y = 1024;
z = y - x - 16;

Un opérateur arithmétique possède deux opérandes (des littéraux ou des variables), dont les valeurs sont numériques (entier ou à virgule flottante)et renvoient une valeur numérique.

Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).

Les opérateurs arithmétiques peuvent être utilisés avec n'importe quelle combinaison de type de données numériques.

L'exception ArithmeticException est lancée dans le cas d'une division dont le diviseur est un nombre entier nul et le dividende un entier (byte, short, int ou long) ou d'un entier (idem) modulo par un nombre entier nul.

class Division {
  public static void main(String[] args){
  int x = 10;
  int y = 0;
  float z = 0.0f;

  System.out.println(x / y); // provoque une exception
  System.out.println(x % y); // provoque une exception

  System.out.println(x / z);// affiche Infinity
  System.out.println(x % z);// affiche NaN
  }
}

Le type de résultats peuvent varier en fonction du type de chacune des opérandes d'une opération arithmétiques.

type opérande_gauche;
type opérande_droite;
type resultat = opérande_gauche opérateur opérande_droite;

Les opérations arithmétiques sur les nombres entiers restent fiables. Par contre, des calculs simples ,dont les opérandes sont des nombres à virgule flottante, se révèlent parfois très approximatifs.

System.out.println(1.1f - 1.0f);
System.out.println(1.1d - 1.0d);
System.out.println(1.1 + 1.0);
System.out.println(1.1 * 0.5);
System.out.println(1.1 / 2.0);
/* Affichent
0.10000000000000009
0.10000000000000009
2.1
0.55
0.55
*/

Face à ces carences possibles dans les opérations arithmétiques et plus particulièrement la soustraction avec des valeurs float ou double, il faut préférer effectuer ces calculs avec la classe BigDecimal qui propose les méthodes add(), substract(), multiply() et divide().

BigDecimal decimal = new BigDecimal("1.1");
System.out.println(
          decimal.subtract(new BigDecimal("1.0")).doubleValue()); 

BigDecimal decimal = new BigDecimal(1.1);
System.out.println(
          decimal.subtract(new BigDecimal(1.0)).doubleValue());

/* Affichent
0.1
0.10000000000000009
*/

Afin de s'assurer de la précision des résultats, il faut créer des objets BigDecimal avec des chaines de caractères plutôt que des nombres décimaux.

Les opérateurs d'incrémentation et de décrémentation permettent respectivement d'augmenter ou de diminuer de un la variable concernée.

i = 0;
i++; //i = 1
i--; //i = 0

Les opérateurs peuvent se placer avant ou après une variable, provoquant une modification respectivement avant ou après que la variable ne soit utilisée. L'expression contenant ce genre d'opérateurs est toujours évaluée avant l'utilisation de la variable concernée.

class Increment {
  public static void main(String[] args){
  int i = 10;
  System.out.println(++i);
  //affiche 11;

  i = 10;
  System.out.println(i++);
  //affiche 10
  }
}

Le type des variables peuvent être de n'importe quel type numérique (byte, short, char, int, long, float et double).

Les opérateurs de comparaisons permettent de comparer leurs opérandes et de renvoyer une valeur logique en fonction du résultat.

Tous ces opérateurs renvoient un résultat booléen ; si la comparaison est réussie, la valeur logique true est retournée, dans le cas contraire c'est false.

int x = 12;;
int y = 24;
boolean resultat = x < y;
// resultat = true
a = "bonjour";
b = "hello";
boolean resultat = a == b;
// resultat = false

Les opérandes ne peuvent être que des types numériques soit des nombres entiers (byte, short, int et long) ou à virgule flottante (float et double) ou encore des caractères (char) pour les opérateurs de comparaisons suivants : <, >, <=, >=, ==, !=.

Les deux opérateurs d'égalité (==) et de différence (!=) peuvent également être utilisés sur des références d'objet.
Dans ce cas, l'opération consiste en une comparaison de références et non de types de référence.
Les références sont comparées afin de contrôler si elles désignent le même objet.

public class inst {
  public static void main(String[] args) {
  Classe ref = new Classe();
  Classe x = new Classe();
  Object y = ref;
  Object z = null;
  if (ref == x)
      System.out.println("ref et x sont égales !");
  else
      System.out.println("ref et x ne sont pas égales !");

  if (ref == y)
      System.out.println("ref et y sont égales !");
  else
      System.out.println("ref et y ne sont pas égales !");

  ref = null;
  if (ref == z)
      System.out.println("ref et z sont égales !");
  else
      System.out.println("ref et z ne sont pas égales !");
  }
}

class Classe {
 //Instructions...
}

Au temps d'exécution, les résultats des opérateurs == et != sont respectivement true et false, si les valeurs des opérandes sont nulles ou se référent au même objet ou au même tableau, sinon le résultat est false et true.

Deux instances d'une même classe représentant un même objet possèdent des références différentes.

Une erreur au moment de la compilation se produit, si il est impossible de transtyper le type d'un opérande vers l'autre et réciproquement, les valeurs de ces deux opérandes sont forcément différentes lors du temps d'exécution.

Pour une comparaison de deux références d'objet, il est préférable d'utiliser plutôt la méthode equals() définie dans la classe java.lang.Object.

La promotion arithmétique se charge de convertir un des opérandes vers le type le plus large des deux pour effectuer la comparaison.

int x = 16;
byte y = 32;
resultat = x > y;
// y est transtypé à int pour effectuer la comparaison

L'opérateur ternaire permet de poser une structure conditionnelle compacte à trois opérandes.

Type variable
variable = Condition ? Expression_1 : Expression_2;
// est équivalent à 
if (Condition) 
  { Expression_1; }
else
  { Expression_2; }

L'opérateur ternaire utilise l'expression conditionnelle retournant true ou false, pour déterminer laquelle des deux expressions doit être exécutée.

L'opérateur ternaire fonctionne comme une instruction if... else. Si la condition initiale renvoie true, alors la première instruction est éxécutée sinon la deuxième est activée.

String message = (jour == "Lundi") ? "Bonne reprise du travail !"
                         : "Bonne continuation !";

float Prix;
float difference = (Prix >= 100) ? Prix - 100 : 100 - Prix;

Le type du résultat de l'instruction ternaire est du même type que celui des expressions sous certaines conditions :

• La promotion numérique s'assure de rendre compatible le type des deux expressions. Par exemple, si l'une des opérandes est du type byte, short ou char et l'autre de type int, alors le résultat sera de type int.
• Par contre, si l'une des opérandes est une expression constante du type int et l'autre du type byte, short ou char, alors le résultat sera l'un de ces derniers types précités.
• De même, si l'une des expressions est du type byte et l'autre short, alors le type du résultat sera short.
• Si les deux expressions sont d'un type référence distinct et compatible, alors le résultat sera du type représentant la superclasse.
• Si l'une des expressions est d'un type référence et l'autre un type null, alors le résultat sera du type référence précité.
• Si les deux expressions possèdent un type identique, y compris null, alors le résultat sera de ce type.

SuperClasse obj_1 = new SuperClasse();
Classe obj_1 = new Classe();
SuperClasse res = i > 0 ? obj_1 : obj_2;

byte taille_1;
short taille_2;
short res = t == 100 ? taille_1 : taille_2;

Les opérateurs au niveau du bit agissent sur les valeurs binaires consituées des nombres 0 et 1.

Dans le langage Java, le signe de la valeur binaire est préservé.

Ces opérateurs sont classés selon trois catégories :

• les opérateurs de décalage (>>, >>>, et <<),
• l'opérateur d'inversion (~),
• les opérateurs booléens (&, |, ^ et !).

Ces opérateurs agissent essentiellement sur des opérandes de types booléens ou numériques intégraux (byte, short, char, int et long) pour respectivement les opérations logiques ou de décalage.

L'opérateur unaire d'inversion (~) ne peut être appliqué qu'à des opérandes de type numérique intégral (byte, short, char, int et long). Dans ce dernier cas, une inversion de l'ensemble des bits est accomplie avec y compris le signe de la valeur s'il existe.

La promotion arithmétique assure la conversion d'une des opérandes vers le type le plus large d'entre eux afin d'effectuer l'opération de décalage et produit toujours un résultat entier int ou long.

1101 & 0111 //retourne 0101
0001 & 1000 //retourne 0000
1001 & 0001 //retourne 0001

1101 | 0111 //retourne 1111
0001 | 1000 //retourne 1001
1001 | 0001 //retourne 1001

1101 ^ 0111 //retourne 1010
0001 ^ 1000 //retourne 1001
1001 ^ 0001 //retourne 1000

!1101 //retourne 0010
!0001 //retourne 1110
!1001 //retourne 0110

~x // équivalent à (-x)-1
(~x)+1 // équivalent à -x

15 << 2 
/*0000 1111 décalé de 2 bits produit 

0011 1100 et donc retourne 60*/

10 >> 1 
/*0000 1010 décalé de 2 bits produit 

0000 0101 et donc retourne 5*/

-16 >> 2 
/*1111 0001 décalé de 2 bits produit 

1111 1100 et donc retourne -4*/

14 >>> 1
/*0000 1110 décalé de 1 bits produit 

0000 0111 et donc retourne 7*/

Les opérations de décalage à gauche et à droite sont équivalent respectivement à multiplier ou à diviser par 2ⁿ.

3 << 2 // retourne 12 soit 3 * 22

32 >> 3 // retourne 4 soit 32 / 23

Les opérateurs logiques permettent de comparer des expressions booléennes et retournent des valeurs booléennes.

boolean variable = expression_1 opérateur expression_2;

boolean variable = (x >= y) && (y < z);

Les opérateurs logiques && et || (appelés parfois opérateurs de court-circuit) évaluent le premier opérande, puis si cela est nécessaire, le second.

Il est également possible d'utiliser les opérateurs logiques &, | et ^ pour effectuer des comparaisons. Dans ce cas, l'opérateur effectuera dans tous les cas l'évaluation des deux opérandes.

Les opérateurs & et | sont couramment utilisés pour obliger Java à calculer une variable présente dans l'opérande de droite.

var = (j++ < 0) && (i-- > 0);

(a < 10) && (b > 10) 
/*Si a et b sont inférieures à 10,

l'opérateur retourne True*/

(a >= 1) || (b == "fin") 
/*Si a est supérieur ou 
égal à 1 ou/et 
si b est égal 
à fin
alors l'opérateur renvoie 
true, 
sinon il retourne false*/

!(a <= 100) 
/*Si a est inférieur ou égal à 100
 
alors l'opérateur retourne false,
 
sinon il renvoie true*/

(a < 10) & (b > 10) 
/*Si a et b sont inférieures à 10,
 
l'opérateur évalue True & True
 
et retourne True*/

(a >= 1) | (b == "fin") 
/*Si a est supérieur ou 
égal à 1 
et si b n'est pas égal 
à fin 
alors l'opérateur évalue 
True | False 
et retourne True*/

(a > 1) ^ (b != 10) 
/*Si a est supérieur à 1
 
et si b est différent 10
 
alors l'opérateur évalue True ^ True
 
et retourne False*/

L'opérateur d'enchaînement + permet de concaténer deux chaînes de caractères, en retournant une autre qui est le résultat de la concaténation des deux opérandes.

String Resultat = Chaine_1 + Chaine_2;

L'opérataur de concaténation peut également s'appliquer à des valeurs de type char.

class Concatenation {
  char[] tab = {'b','o','n','j','o','u','r'};
  public static void main(String[] args){
  String = res = "";
  for(int i = 0; i < tab.length; i++){
      res = res + tab[i];
  }
  System.out.println(res);
  }
}

L'opérateur d'affectation += peut également être utilisé pour enchaîner des chaînes de caractères en boucle.

String Chaine = "Les sanglots longs ";
Chaine += "de l'automne.";
// Chaine = Chaine + "de l'automne.";

// Chaine = "Les sanglots longs de l'automne."

"mon" + " " + "programme"
// retourne "mon programme"

texte = "Un programme";
texte_2 = "Java™";
resultat = texte . " " . texte_2;
// retourne "Un programme Java™"

L'opérateur de transtypage () (appelé également transtype) permet de convertir à un nouveau type une référence d'objet ou une donnée primitive.

Le compilateur Java transforme automatiquement un type dans un autre lorsque cela s'avère nécessaire. Le transtypage (cast en anglais) permet d'effectuer explicitement cette conversion.

(type) expression;

byte nb = 16;
int nombre = (int)nb;

Le transtypage peut être réalisé sur tous les types primitifs à l'exception du type booléen.

Néanmoins, il est possible d'être confronter à une perte d'information lorsque le type de transtypage est inférieur à celui d'origine.

class TransType {
  static int nb = 192;
  static byte nombre = (short)nb;
  public static void main(String[] args){
  System.out.println("Nombre entier = " + nb);
  System.out.println("Nombre entier court = " + nombre);
  // affiche :

  //    Nombre entier = 192

  //    Nombre entier court = -64
  }
}

Lorsqu'une donnée est transtypée dans un type moins large, le nombre de bits excédentaires à gauche est supprimé, engendrant une dégradation de la valeur initiale comme dans l'exemple précédent.

Bien que cela provoque une erreur pouvant être conséquente pour un programme, aucune exception n'est lancée pour avertir le programmeur de ce risque.

Par contre à l'inverse, lorsqu'un transtypage "implicite" illégal est tenté, alors une exception est lancée indiquant une incompatibilité de type.

double nb = 1.56;
int entier = nb;

Les références d'objet peuvent également être transtypés à l'intérieur d'une famille de types.

Il est possible de convertir une référence d'objet d'une certaine classe en une référence d'objet d'une autre classe seulement si les classes sont en relation par l'intermédiaire d'un héritage.

interface Inter { ... }

class Classe extends I { ... }

class Derivee extends A { ... }

Derivee obj_enfant = new Derivee();
// Conversion implicite
Classe obj_parent = (Classe)obj_enfant;
// équivaut à Classe obj_parent = obj_enfant;
Inter obj_interface = (Inter)obj_parent;
// équivaut à Inter obj_interface = obj_parent;
Inter obj_interface = (Inter)obj_enfant;
// équivaut à Inter obj_interface = obj_enfant;

// Conversion explicite
Derivee obj_enfant = (Derivee)obj_parent;
Classe obj_parent = (Classe)obj_interface;
Derivee obj_enfant = (Derivee)obj_interface;

Le transtypage de référence d'objet n'est pas permis dans toute les situations, un type parent pouvant être incompatible avec une partie de sa descendance.

class Personne { ... }
class SalariePublique extends Personne { ... }
class SalariePrivee extends Personne { ... }

SocietePrivee oPSPri = new SocietePrivee();
Personne oP = oPSPri;
// Erreur puisque oP n'est pas forcément un oPSPub

// dans ce cas il est une instance de la classe SalariePrivee

SocietePublique oPSPub = (SocietePublique)oP;

Il n'est pas permis de transtyper une donnée primitive vers une référence d'objet et réciproquement.

L'opérateur instanceof permet de vérifier si une référence d'objet est une instance d'une certaine classe ou interface.

boolean resultat = reférence_objet instanceof {Classe | Interface};

L'opérateur instanceof s'applique aux références d'objets mais ne sert pas à comparer deux objets entre eux mais simplement à en déterminer la classe d'instanciation ou l'interface d'implémentation.

L'opérateur retourne true si l'objet désigne effectivement une instance de la classe ou d'une classe dérivée de cette dernière, sinon il retourne toujours false.
Si la référence d'objet implémente l'interface spécifiée, alors l'opérateur renvoie également true, sinon false.

Toutes les classes héritant de Object et partant tous les objets étant des instances d'une classe dérivée de Object, l'expression ref_objet instanceof Object vaut toujours True.

Si l'objet est égal à null, dans tous les cas, le résultat est false.

Si le transtypage de l'opérande de gauche vers le type de référence n'est pas autorisé lors de la compilation, le compilateur indiquera une erreur semblable pour la tentative de comparaison avec l'opérateur instanceof.

class Classe {
  ...
}

class Classe_Etendue extends Classe {
  ...
}

class Autre_Classe{
  ...
}

class Programme {
  void methode(){
  Classe objet_1 = new Classe_Etendue();
  Classe objet_2 = new Classe();
  Object objet_3 = new Classe();
  Object objet_4 = new Autre_Classe();
  Object objet_5 = null;
  Object objet_6 = new Object();
  objet_6 = objet_1;

  boolean resultat = objet_1 instanceof Classe_Etendue;
  // resultat = True
  boolean resultat = objet_1 instanceof Classe;
  // resultat = true
  boolean resultat = objet_2 instanceof Classe_Etendue;
  // resultat = false
  boolean resultat = objet_3 instanceof Classe;
  // resultat = true
  boolean resultat = objet_4 instanceof Object;
  // resultat = false
  boolean resultat = objet_5 instanceof Classe;
  // produit une erreur de compilation.
  boolean resultat = objet_5 instanceof Object;
  // resultat = true
  boolean resultat = objet_6 instanceof Classe_Etendue;
  // resultat = true
  boolean resultat = objet_6 instanceof Classe;
  // resultat = true
  }
}

Pour une comparaison de types de référence, il est préférable d'utiliser plutôt la méthode isAssignableFrom() définie dans la classe java.lang.Class.

L'opérateur new est utilisé pour créer un objet (ou une instance de classe).

Classe reference_objet = new Constructeur([Arguments...]);

String texte = new String("Une chaîne de caractère");

ClassePerso objet = new ClassePerso();

La création d'un objet peut être réalisée à partir d'une classe prédéfinie dans Java ou d'une classe conçue par un utilisateur.

L'objet résidant en mémoire, est accessible dans le programme par l'intermédaire d'une référence d'objet. Souvent, une utilisation impropre de ce vocabulaire est commise, conduisant parfois à des confusions.

Lors de la création d'un objet, deux types distincts sont affectés :

• le premier appelé type référence est affecté à la référence d'objet,
• le second appelé type de temps d'exécution (runtime) est affecté à l'objet résidant en mémoire.

SuperClasse ref_obj = new constructeur_ClasseDerivee();

Object chaine = new String("Un texte...");
// type référence : Object

// type runtime : String

Cependant, les classes représentées par ces types doivent être liées par une relation d'héritage, sinon une exception relatant une incompatibilité de type sera lancée par le compilateur.

class type {
  public static void main(String[] args){
    Boolean valeur = new String("true");
  }
}
// type référence : Object

instance.java:3: incompatible types

found   : java.lang.String

required: java.lang.Boolean

  Boolean valeur = new String("true");

                              ^

La priorité des opérateurs détermine l'ordre dans lequel les expressions sont exécutées dans une déclaration.

Il est possible d'ignorer la priorité d'opérateur en utilisant des parenthèses.

L'associativité détermine également un ordre d'exécution pour des opérateurs d'une priorité égale.

Un opérateur associatif à gauche signifie que l'opérande de gauche est d'abord calculée.

int resultat = a + b - c;
// équivaut
int resultat = (a + b) - c;

Un opérateur associatif à droite signifie que l'opérande de droite est d'abord calculée.

int resultat = a += b -= c = a + b;
// équivaut
int resultat = (a += (b -= (c = (a + b))));

double resultat = x * -y - 42 / z % --x + 2;
// équivaut
double resultat = (((x * (-y)) - ((42 / z) % (--x))) + 2);

La table suivante décrit la priorité des opérateurs, du moins élevé vers le plus élevé, ainsi que leur associativité.

Les instructions conditionnelles permettent de poser une condition avant d'exécuter un bloc d'instructions.

L'instruction conditionnelle la plus répandue dans les scripts demeure la fameuse structure if.

if (condition_booleenne){
  // bloc d'instructions...
}
if (y != 0)
  System.out.println("x / y = " + x / y);

La condition de l'instruction if doit toujours retourner un type booléen.

if (y)
  // y n'étant pas booléen, la condition est erronée
  System.out.println("x / y = " + x / y);

if (y != 0)
  // y étant pas booléen, la condition est correcte
  System.out.println("x / y = " + x / y);

Lorsque la commande if ne comporte qu'une seule instruction dans son bloc, alors les accolades deviennent facultatives.

L'instruction if peut être accompagnée de else, voire d'une combinaison else if afin de formuler une alternative par défaut (sinon) ou une ou plusieurs conditions différentes (sinon si).

if (Première_condition){
  // Premier bloc d'instructions...
}
else if(Seconde_condition){
  // Second bloc d'instructions...
}
...
else if(Nième_condition){
  //Nième bloc d'instructions...
}
else{
  //bloc d'instructions par défaut...
}

if (journee == "matin")
  System.out.println("C'est le matin !");
else if (journee == "après-midi")
  System.out.println("C'est l'après-midi !");
else if (journee == "soirée")
  System.out.println("C'est la soirée !");
else
  System.out.println("C'est la nuit !");

Cette structure conditionnelle fonctionne de la façon suivante en sachant que si une condition est vraie, le bloc d'instructions correspondant est exécuté puis la sortie de la structure complète est opérée :

• Si la variable est égale à matin, alors est affiché C'est le matin !,
• sinon si journee est égal à après-midi,
• alors sera affiché C'est l'après-midi !,
• sinon si journee est égal à soirée, alors sera affiché C'est la soirée !,
• sinon sera affiché C'est la nuit !.

Une structure conditionnelle if...else if...else peut être remplacée par une instruction switch dont le fonctionnement est sensiblement similaire et en outre la syntaxe est bien plus compacte.

Toutefois, une instruction switch n'accepte dans ses différents cas (case) que des valeurs entières (int, short, byte) et des caractères (char), les autres (long, float, double, boolean, Object) n'étant pas autorisés.

switch (variable){
  case valeur_1:
  //Premier bloc d'instructions...
  break;
  case valeur_2:
  //Second bloc d'instructions...
  break;
  ...
  case valeur_N:
  //Nième bloc d'instructions...
  break;
  default:
  //bloc d'instructions par défaut...
  break;
}

switch (int heure)
{
  case 6:
  System.out.println("C'est le matin !");
  Break;
  ...
  case 14:
  System.out.println("C'est l'après-midi !");
  Break;
  ...
  case 21:
  System.out.println("C'est la soirée !");
  Break;
  ...
  default:
  System.out.println("C'est la nuit !");
  Break;
}

La variable entière heure est comparée successivement à chacune des valeurs explicitée par l'instruction case. Si la comparaison est bonne, le bloc d'instructions correspondant est exécuté.
L'instruction break est nécessaire afin de quitter la structure conditionnelle immédiatement après que la condition adéquate eut été trouvée. Dans le cas contraire, les autres instructions case seraient également évaluées.
Par ailleurs, correspondant à else, l'instruction default fournit une alternative par défaut à switch.

L'instruction ternaire offre une structure plus compacte sous réserve de ne proposer que deux possiblités selon une condition spécifiée.

resultat = condition ? première_alternative : seconde_alternative;

Si la condition est vraie alors la première alternative est retournée, sinon c'est la seconde.

Les boucles permettent de répéter des opérations jusqu'à ce qu'une ou plusieurs conditions soient réunies.

Le langage Java possède plusieurs structures itératives, ayant la même fonction mais possédant des caractéristiques différentes.

D'autre part, ces boucles peuvent ête utilisées avec des instructions de sortie : break et continue avec des possibilités de labélisation.

La boucle for se démarque par sa compacité puisqu'elle contient entre parenthèses trois expressions permettant de l'initialiser (ex : i = 0;) de poser une condition à son terme (ex : i > 10) et de l'incrémenter ou de décrémenter automatiquement (ex : i++).

for (initialisation; condition_booléenne; incrémentation){
  // bloc d'instructions...
}

L'expression d'initialisation peut être une simple affectation mais aussi une déclaration de variable.
Dans ce dernier cas, l'argument d'itération ne sera accessible que dans l'instruction for et dans son bloc d'instructions.

int i;
for (i = 0; i < 10; i++)
  System.out.println("\ni = " + i);

for (int i = 0; i < 10; i++)
  System.out.println("i = " + i);

Le bloc d'instructions à exécuter dans une boucle for doit être contenu à l'intérieur d'accolades, s'il n'y a qu'une seule instruction, les accolades sont facultatives.

for (int i = 0; i < 10; i++)
  System.out.println(i + "\r\n");

La boucle for peut aussi bien utiliser des variables de type entier qu'à virgule flottante comme argument.

for (float i = 0; i < 10; i += 0.5)
  System.out.println(i + "\r\n");

Littéralement, cette boucle accomplit des opérations à partir d'un état initial et jusqu'à une certaine condition par le pas indiqué par l'incrémentation.

Il est possible de placer plusieurs instructions d'initialisation et d'itérations dans une boucle for en les séparant par des virgules, mais, il sera alors interdit de déclarer des variables.

class BoucleFor {
  public static void main(String[] args){
  int i, j;
  for(i = 0, j = 0; i + j < 10; i++, j += i)
      System.out.println("i = " + i + " / j = " + j + "\r\n");
  }
}

// résultat de la boucle
i = 0 / j = 0
i = 1 / j = 1
i = 2 / j = 3
i = 3 / j = 6

class AutreBoucleFor {
  public static void main(String[] args){
  int i, j;
  for(i = 0, j = 0; i < 10; ++i, j += i)
      System.out.println("i = " + i + " / j = " + j + "\r\n");
  }
}

// résultat de la boucle
i = 0 / j = 0
i = 1 / j = 1
i = 2 / j = 3
i = 3 / j = 6
i = 4 / j = 10
i = 5 / j = 15
i = 6 / j = 21
i = 7 / j = 28
i = 8 / j = 36
i = 9 / j = 45

Les boucles for peuvent s'imbriquer permettant par exemple d'explorer un tableau multidimensionnel.

import java.math.*;

class BoucleFor {
  static double[][] tailles = {{1.82, 1.65, 1.78, 2.01, 1.98},
                                    {2.11, 1.62, 1.78, 1.84},
                                    {2.01, 1.85, 2.36, 1.61, 1.67}};
  static double total = 0.0d;
  static int longueur_total;

  public static void main(String[] args){
  for(int i = 0; i < tailles.length; i++) {
      longueur_total += tailles[i].length;
      for(int j = 0; j < tailles[i].length; j++) {
        total += tailles[i][j];
        System.out.println(i + " et " + j + " : " 
                           + tailles[i][j] + "\n");
      }
  }
  System.out.println("        -----\n");
  BigDecimal moyenne = new BigDecimal(total / longueur_total);
  System.out.println("Moyenne: " + moyenne.setScale(2, 1));
  }
}}

La boucle de Djikstra est un artifice algorithmique utilisant une instruction for sans fin, contenant une structure conditionnelle d'arrêt en son sein. Cette boucle est souvent utilisée pour la validation de saisie d'un utilisateur.

class BoucleDjikstra {
    public static void main(String args[]){
        try{
            char lettre;
            for(;;){
                lettre = (char)System.in.read();
                if(lettre == 'f') break;
                System.out.println("Saisissez un caractere 'f' pour terminer !");
            }
        }
        catch(Exception e){
            System.out.println("Une exception d'entrée/sortie "
                                               + "s'est produite !");
        }
    }
}

La boucle for-each, introduite à partir du JDK 1.5, permet d'utiliser une boucle for spécifique pour itérer une collection Java.

Collection collection = new Vector();
for(Object valeur : collection){
  System.out.println(valeur.toString());
}
//équivaut à
for (Iterator ite = collection.iterator(); ite.hasNext(); )
  System.out.println(ite.next().toString());
}
//équivaut à
for (int i = 0; i < collection.size(); i++)
  System.out.println(collection.get(i).toString());
}

La boucle for est capable de parcourir n'importe quelle collection Java, soit des listes (List), des ensembles (Set) ou des associations clé/valeur (Map). Dans ce dernier type de collection, la boucle for doit déclarer un objet Map.Entry représentant une paire clé/valeur.

TreeMap associations = new TreeMap();
for (Map.Entry entree : associations){
  System.out.println(entree.getKey() + " " + entree.getValue());
}

Désormais, les collections Java peuvent expliciter le type des valeurs contenues dans une collection. Evidemment la boucle for-each prend en compte cette caractéristique. Pour cela, il suffir d'indiquer le type de la valeur à exploiter dans la boucle.

ArrayLIst<String> liste = new ArrayList<String>();
for(String valeur : liste){
  System.out.println(valeur);
}

HashTable<String, ZipFile> associations = 
                        new Hashtable<String, ZipFile>();
for(Map.Entry entree : associations){
  String cle = entree.getKey();
  ZipFile archive = entree.getValue();
}

public class Videos {
  private ArrayList liste;
  public Videos(){
    liste = new Videos();
  }
  public void enregistrer(){
    liste.put(new Video("Voyage au bout de l'enfer", "Michael Cimino", 1978));
    liste.put(new Video("Le jour le plus long", "Ken Annakin", 1962));
    liste.put(new Video("Un pont trop loin", "Richard Attenborough", 1977));
    liste.put(new Video("Platoon", "Oliver Stone", 1986));
    liste.put(new Video("Full metal jacket", "Stanley Kubrik", 1987));
    liste.put(new Video("La ligne rouge", "Terrence Malick", 1998));
    liste.put(new Video("The patriot", "Roland Emmerich", 2000));
    liste.put(new Video("Outrages", "Brian De Palma", 1990));
    liste.put(new Video("Paris brûle-t-il ?", "René Clément", 1966));
    liste.put(new Video("Tora ! Tora ! Tora !", "Richard Fleischer", 1970));
    liste.put(new Video("Guerre et Paix", "King Vidor", 1956));
    liste.put(new Video("Apocalypse now", "Francis Ford Coppola", 1979));
  }
  public String lister(){
    StringBuffer sb = new StringBuffer();
    for(Video video : videos){
      sb.append(video.toString());
      sb.append(System.getProperty("line.separator"));
    }
  }
}

public class Video {
  private String titre;
  private String realisateur;
  private int annee;
  public Video(
              String titre,
              String realisateur,
              int annee){
    this.titre = titre;
    this.realisateur = realisateur;
    this.annee = annee;
  }
  public String toString(){
    StringBuffer sb = new StringBuffer();
    sb.append(this.titre);
    sb.append(";");
    sb.append(this.realisateur);
    sb.append(";");
    sb.append(this.annee);
    return sb.toString();
  }
}

La différence principale entre les boucles while et do...while est que la seconde structure effectuera quelque soit la condition initiale, une première itération, soit exécutera une première fois le bloc d'instructions.

La boucle while contient essentiellement comme argument une condition d'arrêt toujours évaluée avant chaque itération.

L'initialisation et l'incrémentation devront être explicitées respectivement avant et à l'intérieur de la boucle.

initialisation;
while (condition_booléenne){
  bloc d'instructions...
  incrémentation;
}

int i = 0;
while (i < 10){
  System.out.println(i + "\r\n");
  i++;
}

la boucle do...while contrairement à while... évalue la condition après chaque itération.

initialisation;
do{
  bloc d'instructions...
  incrémentation;
}
while (condition_booléenne);

int i = 0;
do{
  System.out.println(i + "\r\n");
  i++;
}while (i < 10);

Littéralement, ces boucles accomplissent des opérations tant qu'une condition est vraie :

• tant que condition faire instructions (while).
• faire instructions tant que condition (do... while...),

Contrairement à la boucle for, ces boucles nécessitent une initialisation des éventuels variables incrémentables avant la structure.

La condition des structures itératives, soit l'expression se trouvant immédiatement après while entre paranthèses, doit fournir une valeur du type booléen : true ou false.

Dans les deux cas, il est possible d'omettre les accolades délimitant le bloc d'instructions si ce dernier ne contient qu'une seule instruction.

class Boucles {
  static String[] jour_semaine = {"lundi", "mardi", "mercredi", "jeudi", 
                                       "vendredi", "samedi", "dimanche"};
  public static void main(String[] args){
  int i = 0;

  do {
      System.out.println("Jour de la semaine : " 
                                + jour_semaine[i] + "\n");
      i++;
   } while(i < jour_semaine.length);

  System.out.println("------------------------");

  while(--i >= 0) {
      System.out.println("Jour de la semaine : " 
                                + jour_semaine[i] + "\n");
  }
  }
}

Les instructions break et continue facilitent respectivement la sortie complète et l'arrêt pour l'itération en cours d'une boucle suite à une condition particulière nécessitant une action précise.

while(condition){
  // Bloc d'instructions...
  break;
  /* sortie de la boucle avant la prochaîne itération

   et passage à la prochaine instruction après la boucle */
  // Bloc d'instructions...
}
// Prochaines instructions...


while(condition){
  // Bloc d'instructions...
  continue;
  /* arrêt de la boucle à l'itération en cours
 
   mais passage à l'itération suivante */
  // Bloc d'instructions...
}

Il est possible d'utiliser des étiquettes (ou labels) avec les instructions continue et break afin d'indiquer au programme le début de l'instruction à reprendre après la sortie d'une itération.

break label;
continue label;
premiereBoucle: for(i = 0; i < 10; i++) {
  boucleExterne: for(int j = 0; j <= 4; j++) {
    if (j == 4) {
      break premiereBoucle;
    }
    for(k = 0; k < 3; k++) {
      System.out.println('('i + ', ' + j + ', ' + k + ')rn');
      continue boucleExterne;
    }
  }
}

Les deux instructions étiquetées permettent de reprendre les itérations à la première boucle for si j est égal à 4, et à la seconde boucle après l'impression des valeurs i, j et k.

Evidemment, les instructions d'arrêt étiquetées doivent être placées à l'intérieur des boucles désignées par les labels.

int a = 0;
Exterieur: for(int i = 0; i < 10; i++){
  int j = 0;
  while(j < 1000){
    a++;
    j++;
    if(i == 5){
      continue Exterieur;
    }
  }
}
System.out.println("a = " + a);

Les labels sont particulièrement utiles lors de l'utilisation de boucles imbriquées dans un programme.

class Boucles {
  public static void main(String[] args){
    premiere_boucle: for(int i = 0; i < 10; i++) {
      seconde_boucle: for(int j = 0; j < 10; j++) {
        troisieme_boucle: for(int k = 0; k < 10; k++) {
          if((i * j * k) == 9) {
            System.out.println("Sortie Première boucle " 
                                             + (i * j * k));
            continue premiere_boucle;
          }
          if((i * j * k) == 125) {
            System.out.println("Sortie Seconde boucle " 
                                             + (i * j * k));
            continue seconde_boucle;
          }
          if((i * j * k) == 343) {
            System.out.println("Sortie Troisième boucle " 
                                             + (i * j * k));
            continue troisieme_boucle;
          }
        }
      }
    }
  }
}

Le langage Java reconnaît plusieurs types de données permettant de différencier les informations utilisées par un programme.

En premier lieu, les types de données sont classées selon deux catégories distinctes :

• les types primitifs ou de base,
• les types composites ou de référence.

Les types de données primitifs regroupent les valeurs numériques entières ou décimales, les caractères simples et Unicode ainsi que les booléens true et false.

Les types de données composites sont des structures composées de plusieurs informations de types primitifs ou composites comme les classes, les tableaux et les chaînes de caractères provenant plus exactement de la classe String.

La conversion des types de données permet de modifier le type initial d'une valeur en un autre en respectant toutefois certaines contraintes. Par exemple, il n'est pas possible de convertir une valeur en type booléen, un objet en un objet de classe sans corrélation. De même, si le transtypage d'un nombre en un type supérieur est permis comme un entier court en un type long, l'inverse comme un nombre décimal simple en un entier long, peut produire des erreurs et donc Java tentera d'empêcher ce type de conversion.

byte -> short -> int -> long -> float -> double

La conversion de type de données de la gauche vers la droite (le sens de l'élargissement) s'effectue automatiquement, tandis que dans le sens inverse (ou sens de la restriction), il est nécessaire de passer par un transtypage explicite.

// transtypage explicite
int x = 10;
int y = 3;

valeur = x / y; // retourne 3

valeur = (float)x / y // retourne 3.33...

// transtypage automatique
float x = 10;
int y = 3;

valeur = x / y // retourne 3.33...

Il est également possible de placer des caractères spéciaux (l, f, et d) immédiatement après le littéral numérique afin d'effectuer une opération de transtypage.

// Conversion d'un valeur numérique en type long
long a = 199999999999999999L;

// Conversion d'un valeur numérique en type float
float b = 3.0F;

float x = b + 24F;

// Conversion d'un valeur numérique en type double
double c = 15D;

double y = c / x * 12D;

Dans le langage Java, tous les littéraux entiers sont de type int. De la même façon, tous les littéraux à virgule flottante sont de type double.

La promotion numérique permet de rendre compatible le type des opérandes avant qu'une opération arithmétique ne soit effectuée.

int a = 12;
short b = 15;
int resultat = a + b;
// Promotion numérique
int resultat = a + (int)b;

Une conversion (cast) vers le type le plus large de l'une des opérandes est appliquée implicitement à l'opérande possèdant le type le moins large.

Un type large est déterminé en fonction :

• du nombre de bits permettant le codage binaire d'une valeur numérique,
• de l'ordre de la gamme des types, c'est-à-dire que les nombres à virgule flottante sont toujours plus larges que les entiers.

Le résultat d'une opération binaire ou unaire est toujours un nombre de type int, long, float ou double.

typeG opérandeG;
typeD opérande_droite;

typeR resultat = opérandeG opérateur;
// ou
typeR resultat = opérateur opérandeG;

typeR resultat = opérandeG opérateur opérandeD;

Une opération unaire sur des nombres de type int, long, float ou double ne nécessite aucune promotion numérique puisque le type résultant est identique.

Les types byte et short ne sont pas compatibles avec le type char bien que les premiers soient inférieurs ou égaux en terme de largeur, mais ne font pas partis de la même gamme de types.

byte a = 10;
short b = 12;

char c = a; 
char d = b;
// produisent une erreur de compilation
// possible loss of precision

char a = 'c';
int b = a;
// est équivalent à
int b = (int)a;
// b = 99;

En résumé, le type plus large conserve toujours la prédominance sur l'autre type dans une opération arithmétique binaire.

Les tableaux sont des structures de données regroupant plusieurs valeurs de même type.

Les tableaux constituent des collections d'informations homogènes, c'est-à-dire, de valeurs primitives ou d'objets de même type.

Les éléments d'un tableau peuvent être :

• des primitives (float, int, char, etc.),
• des références d'objets (String, Object),
• des références de tableaux.

La taille d'un tableau est fixée d'une façon permanente suite à la déclaration du tableau et à l'allocation de ressources systèmes pour ce dernier. Un tableau est donc non-mutable.

Une alternative à ce type de tableaux est représentée par les vecteurs, pouvant être réalloués dynamiquement et de plus possédant la capacité de contenir des collections d'objets disparates.

La déclaration des tableaux s'effectuent par l'intermédiaire de crochets ([...]).

type identificateur[];

type[] identificateur;

double resultats[];

char[] lettres;

String[] employes;

Il est possible de placer les crochets après l'identificateur ou après le type pour obtenir une déclaration de tableau.

La taille d'un tableau n'est spécifié qu'à partir du moment de son utilisation dans le programme. Ainsi, la mémoire ne sera allouée que lorsque cela sera nécessaire.

La définition d'une référence d'un tableau, c'est-à-dire la spécification de la taille du tableau référencé par la variable, s'accomplit en utilisant l'opérateur new.

identificateur = new type[taille];

notes = new int[10];
// la variable notes fait référence à
 
// un tableau de 10 valeurs entières.

La déclaration peut se combiner à la définition du tableau produisant une instruction plus compacte.

long[] idClient = long[100000];

Par défaut, les valeurs de chaque élément d'un tableau sont égales à :

• 0 pour des entiers (int, short, ...),
• 0.0 pour des nombres à virgule flottante (double, float, ...),
• u0000 pour des caractères (char),
• false pour des booléens (boolean),
• null pour des objets (Object, String).

Les tableaux peuvent être initialisés par l'intermédiaire d'une liste de valeurs séparées par une virgule et compris entre des accolades.

type[] identificateur = {valeur, ..., valeurN};

type identificateur[] = {valeur, ..., valeurN};

int[] notes = {10, 9, 12, 14, 16, 15, 17, 20, 19, 18};

int notes[] = {10, 9, 12, 14, 16, 15, 17, 20, 19, 18};

Un tableau existant peut être référencé par une autre variable par le biais d'une simple affectation.

int[] resultats = int[10];

int[] resultats = notes;
// Les deux variables notes et resultats
 
//référencent désormais le même tableau

Dans ce cas de figure, lorsque le contenu du tableau aura subi une modification quelconque par le truchement de l'une des variables, l'autre répercutera évidemment les différences induites puique leur point commun est justement l'objet tableau et son contenu.

class Tableau {
  public static void main(String args[]) {
    int[] notes = {10, 15, 12, 10, 9, 19, 13, 5, 7, 20};
    int[] copie = notes;
    for(int i = 0; i < notes.length; i++)
      if(notes[i] < 10) notes[i] = 10;
    System.out.println ("NOTES :");
    for(int i = 0; i < copie.length; i++)
      System.out.println ("Note n°" + i + " : " + notes[i]);
    System.out.println ("COPIE :");
    for(int i = 0; i < copie.length; i++)
      System.out.println ("Note n°" + i + " : " + copie[i]);
  }
}

L'accès aux éléments d'un tableau est réalisé en utilisant ses indices, soit les numéros de chacun de ses éléments, en sachant que le premier commence à l'indice 0.

valeur = identificateur[indice];

premiereNote = notes[0]; // = 10

sixiemeNote = notes[5]; // = 15

dixiemeNote = notes[9]; // = 18

La redéfinition d'un tableau entraîne la perte de l'ancienne structure avec toutes ses valeurs.

notes = int[50];
// Création d'un nouveau tableau de 50 valeurs entières

// initialisées par défaut à 0,

// et entraînant la suppression de celui de 10 valeurs

La boucle for permet de parcourir un tableau d'une manière automatique.

int total = 0;
for(i = 0; i < 10; i++) {
  total += notes[i];
  System.out.println(notes[i] + "rn");
}
System.out.println("----rn");
System.out.println(total / 10);

D'autre part, la propriété length associée à un objet de type Array, fournit la taille d'un tableau.

int taille = notes.length; // taille = 10

En conséquence, dans une boucle for, la valeur conditionnelle peut être remplacée par cette propriété.

class BoucleFor {
  static int notes[] = {10, 9, 12, 14, 16, 15, 17, 20, 19, 18};
  static int total = 0;
  public static void main(String[] args){
    int i, j;
    for(i = 0; i < notes.length; i++) {
      total += notes[i];
      System.out.println("note  " + i + " : " + notes[i] + "n");
    }
    System.out.println("         ----n");
    System.out.println("Moyenne : " + total / notes.length);
  }
}

Les tableaux multidimensionnels sont des structures complexes possédant plusieurs indices.

Les dimensions dans ces tableaux sont en fait des références vers de simples tableaux. Un tableau à trois dimensions contiendra un premier tableau référençant plusieurs autres tableaux, référençant eux mêmes encore d'autres tableaux qui contiennent des valeurs.

La création de tels tableaux s'effectue en posant autant de crochets qu'il est nécessaire, à la suite de son type ou de son identificateur.

type[][]... identificateur;

type identificateur[][]...;

// Déclaration correcte mais peu claire
type[][] identificateur[];

double[][] remuneration;
// Définition d'un tableau à deux dimensions

double[][][] remuneration;
// Définition d'un tableau à trois dimensions

La définition des tailles d'un tableau multidimensionnel utilise, à l'instar des tableaux simples, l'opérateur new.

identificateur = new type[taille_1][taille_2];

remuneration = new double[20][12];
// Tableau de 20 tableaux de 12 éléments primitifs

remuneration = new double[3][20][12];
// Tableau référençant 3 tableaux de 

// 20 autres de 12 éléments primitifs

Les tableaux multidimensionnels acceptent les variations dans leur dimension. Le tableau remuneration à trois dimensions représentant respectivement les succursales, les employés et le nombre de mois, pourraient ne pas avoir le même nombre d'employés par succursale, si bien qu'il faudrait modifier la définition du tableau pour que cela soit pris en compte.

remuneration = new double[3][][];

remuneration[0] = new double[20][12];
remuneration[0] = new double[15][12];
remuneration[0] = new double[11][12];

L'initialisation de ce genre de tableau nécessite l'utilisation d'accolades imbriquées.

identificateur[][] = {{Valeur, ..., ValeurN}, 
                             ...,
                             {Valeur, ..., ValeurN}};
...
Identificateur[][][] = {{{Valeur, ...}, ..., {Valeur, ...}},
                                ...,
                                {{Valeur, ...}, ..., {Valeur, ...}}};

remuneration[][] = {{1351.02, 1410.85, ..., 1519.36},
                           ...,
                           {2085, 1810.85, ..., 2519.36}};
// Initialisation de 12 valeurs dans
 
// chaque ligne d'un tableau bidimensionnel.

Dans un tableau bidimensionnel, la variation du second indice avec une valeur fixe pour le premier, permet d'accéder aux valeurs présentes dans une ligne, l'inverse permettant l'accès aux valeurs dans une colonne.

valeur_ligne = identificateur[i_fixe][j_variable];

valeur_colonne = identificateur[i_variable][j_fixe];

for(j = 0; j < 12; j++)
  paie_1 += remuneration[0][j];
// total sur une ligne

for(i = 0; i < 20; i++)
  paie_total_fev += remuneration[i][0];
// total sur une colonne

La taille d'une dimension d'un tableau peut être récupérée par la propriété length.

int taille_i = identificateur.length;

int taille_j = identificateur[i].length;

int taille_k = identificateur[i][j].length;
...

int taille = identificateur[0].length;
// taille = 12

Le parcours automatique de tous les éléments d'un tableau multidimensionnel, nécessite l'emploi de plusieurs boucles imbriquées.

class BoucleFor {
  static double[][] remuneration = {{1351.02, 1410.85, 1519.36},
                                    {1501.21, 1610.62, 1908.78, 1930.84},
                                    {2085.01, 1810.85, 2519.36}};
  static double total = 0.0d;
  public static void main(String[] args){
    for(int i = 0; i < remuneration.length; i++) {
      for(int j = 0; j < remuneration[i].length; j++) {
        total += remuneration[i][j];
        System.out.println(i + " et " + j + " : " 
                           + remuneration[i][j] + "n");
      }
    }
    System.out.println("        --------n");
    System.out.println("total  : " + total);
  }
}

Les chaînes de caractères permettent de stocker n'importe quelle séquence de caractères alphanumériques.

Le type de données String provient en réalité de la classe String, et partant, les chaînes de caractères sont des objets String.

Tous les caractères Unicode, tels que les lettres, les chiffres, les espaces, les signes de ponctuation et tous les autres sont acceptés du moment que l'ensemble est encadré par des guillemets doubles ("...")ou simples ('...').

"Une chaîne de caractères..."

Pour les caractères spéciaux, il existe des séquences d'échappement Unicode permettant de les intégrer dans une chaîne de caractères.

\' // apostrophe
\" // guillemet double

\n // nouvelle ligne
\r // retour chariot
\t // tabulation
\/ // barre oblique
\\ // barre oblique inversée
\f // saut de page

\ooo // octal
\xhh // hexadécimal
\udddd // caractère unicode

"\tL\'île fût submergée par les eaux !\r\n"

La déclaration d'une chaîne de caractères s'effectue en posant le nom de la classe suivie d'un identificateur.

String identificateur;

String texte;

Suite à la déclaration, une affectation à une valeur permet d'initialiser la variable.

identificateur = "Chaîne de caractères...";

String autre_texte = null;
// variable de type String sans référence

texte = "Le sommet de la terre de Johannesbourg a été un échec !";

Les objets String sont inaltérables (ou non-mutables), c'est-à-dire que les chaînes de caractères ne peuvent être modifiées. Lors de la réaffectation d'une valeur, la variable détruit l'ancienne chaîne de caractères et en référence une nouvelle.

String texte = "Le vilain ogre";

texte += " a tout fait capoter !";
// provoque la suppression de "Le vilain ogre"

// texte référence le nouveau littéral

// "Le vilain ogre a tout fait capoter !"

La concaténation des chaînes de caractères s'accomplit au moyen du signe plus (+).

String resultat = "chaîne 1" + "chaîne 2";

resultat += "autre chaîne...";
// resultat = "chaîne 1chaîne 2autre chaîne..."

Les objets StringBuffer sont des chaînes de caractères mutables, c'est-à-dire, dont la taille et le contenu peuvent être modifiés dynamiquement.

Dans le cas des objets StringBuffer, il est nécessaire de créer des instances de la classe StringBuffer par le biais de l'opérateur new.

StringBuffer chaine = new StringBuffer("Chaîne initiale");

Ainsi contrairement aux objets String, il devient possible de supprimer, d'ajouter, d'insérer ou de remplacer de nouvelles données directement dans la chaîne de caractères d'origine par l'intermédiaire de méthodes spécialisées telles que respectivement delete(), append(), insert() ou replace().

class TestStringBuffer {
  public static void main(String args[]) {
    StringBuffer ch = new StringBuffer();
    System.out.println("Capacite : " + ch.capacity());
    ch = ch.append("Confucius :\n");
    ch = ch.append("Quand on est capable d'accomplir la justice,"
                                  + " il faut tenir sa parole.");
    System.out.println (ch);
    System.out.println("Capacite : " + ch.capacity());
    ch = ch.insert(ch.indexOf("la justice"), 
                                   "sa promesse sans manquer a ");
    System.out.println (ch);
    System.out.println("Capacite : " + ch.capacity());
    ch = ch.replace(ch.indexOf("on ")
                                  + "on ".length(), ch.indexOf("accomplir"), "peut ");
    System.out.println (ch);
    System.out.println("Capacite : " + ch.capacity());
  }
}

La méthode toString() est appelée implicitement lors d'une tentative d'affichage de l'objet StringBuffer. Ainsi dans ce cas, on peut se passer de l'écriture ci-dessous :

System.out.println(ch.toString());

A partir de cet objet, des méthodes diverses peuvent être appliquées afin de consulter ou de modifier l'état de l'objet.

import specialIO.*;
/**

 * Cette application permet de crypter et de décrypter 

 * une chaine de caractères à l'aide de l'algorithme de César

 */
class CryptageChaine {
  static public String chaine;
  static public StringBuffer copieChaine;
  static public int ecart = 1;
  /**

   * Cette méthode permet d'exécuter le programme et 

   * de lancer une saisie de l'opérateur puis de crypter 

   * et de décrypter une chaîne de caractères.

   */
  public static void main(String args[]) {
    System.out.print ("Veuillez saisir une chaine de caracteres : ");
    chaine = Console.in.readLine();
    copieChaine = new StringBuffer(chaine);
    System.out.println ("***  CRYPTAGE  ***");
    cryptage();
    System.out.println ("*** DECRYPTAGE ***");
    decryptage();
  }
  /**

   * Cette méthode permet de crypter une chaîne de caractères.

   */
  public static void cryptage(){
    for(int i = 0; i < chaine.length(); i++){
      char car = chaine.charAt(i);
      if(car > (char)('z'-ecart))
        copieChaine.replace(i, i+1, ecart == 1 ? "a" : ""
                                                         +(char)('a'+ecart-1));
      else if(chaine.charAt(i) == ' ')
        copieChaine.replace(i, i+1, "$");
      else
        copieChaine.replace(i, i+1, ""+(char)(car+ecart));
    }
    System.out.println("Chaine d'origine : " + chaine);
    System.out.println("Chaine cryptee   : " + copieChaine);
  }
  /**

   * Cette méthode permet de décrypter une chaîne de caractères.

   */
  public static void decryptage(){
    for(int i = 0; i < copieChaine.length(); i++){
      char car = copieChaine.charAt(i);
      if(car < (char)('a'+ecart))
        copieChaine.replace(i, i+1, ecart == 1 ? "z" : ""
                                                         +(char)('z'-ecart-1));
      else if(copieChaine.charAt(i) == '$')
        copieChaine.replace(i, i+1, " ");
      else
        copieChaine.replace(i, i+1, ""+(char)(car-ecart));
    }
    System.out.println("Chaine d'origine : " + chaine);
    System.out.println("Chaine decryptee : " + copieChaine);
  }
}

Un objet StringBuffer n'est pas directement compatible avec son homologue String. La conversion de l'une vers l'autre et réciproquement contraint à utiliser :

• le constructeur StringBuffer() avec comme argument une chaîne de caractères,

  String ch = "Une chaîne quelconque !";
  StringBuffer chb = new StringBuffer(ch);

• la méthode tostring() de l'objet StringBuffer retournant une chaîne de caractères.

  StringBuffer chb = new StringBuffer("Une chaîne quelconque !");
  String ch = chb.toString();

Les objets StringBuffer sont utilisés par le compilateur pour implémenter l'opérateur de concaténation '+'.

String ch1 = "La Justice";
String ch2 = "vitesses";
String resultat = ch1 + "fonctionne à deux " + ch2 + " !";
// Compilation
String resultat = new StringBuffer().append(ch1)
                                .append("fonctionne à deux ")
                                .append(ch2).append(" !").toString();

Une nouvelle instance vide de la classe StringBuffer est créée, puis chaque chaîne de caractères de l'expression initiale est ajoutée à l'objet, par le biais des méthodes append() et enfin la méthode toString() se charge de retourner un objet String conforme au type de l'expression.

Tant que la longueur d'une séquence de caractères contenue dans l'objet StringBuffer n'excède pas la capacité initiale, il n'est pas nécessaire d'allouer de nouvelles ressources à l'objet. Par contre, lorsque la mémoire tampon interne de l'objet ne suffit plus, alors de nouvelles ressources systèmes nécessaires sont allouées automatiquement à l'objet.

La méthode equals() déterminant une égalité d'objet, permet de comparer deux références d'instance de classe par rapport à leur valeur.

boolean resultat = ref_obj1.equals(ref_obj2);

L'égalité d'objet est obtenue lorsque deux objets distincts contiennent une valeur identique, à ne pas confondre avec l'égalité de référence, obtenue si deux références d'objets pointent vers un même objet.

class equal {
  public static void main(String[] args){
  String ref_obj1 = new String("Un texte.");
  String ref_obj2 = new String("Un texte.");
  if(ref_obj1.equals(ref_obj2))
      System.out.println("Réussi");
  else System.out.println("Echec");

  ref_obj1 = "Une autre chaîne !";
  if(ref_obj1.equals(ref_obj2))
      System.out.println("Réussi");
  else System.out.println("Echec");
  }
}
//affiche
Réussi
Echec

La méthode equals() est définie dans la superclasse java.lang.Object. Elle est outrepassée dans des sous-classes telles que java.lang.String, java.lang.Boolean, java.util.Vector, etc..

Le comportement de la méthode equals() varie selon la classe qui l'invoque.

La méthode equals() invoquée par une référence d'instance de la classe Object effectue un comparaison d'égalité de référence avec un argument d'un type quelconque.

Object ref_obj1 = new Object();
Object ref_obj2 = new Object();
UneClasse ref_obj3 = new UneClasse();
Object ref_obj4 = ref_obj1;

boolean resultat = ref_obj1.equals(ref_obj2);
// resultat = false;

boolean resultat = ref_obj1.equals(ref_obj3);
// resultat = false;

boolean resultat = ref_obj1.equals(ref_obj4);
// resultat = true;

Par contre, lorsque deux références pointent vers des objets d'un type identique, elles sont effectivement comparés par rapport à leur valeur.

Boolean ref_obj1 = new Boolean(true);
Boolean ref_obj2 = new Boolean(true);

boolean resultat = ref_obj1.equals(ref_obj2);
// resultat = true;

boolean resultat = ref_obj1.equals(ref_obj3);
// resultat = true;

Si un objet d'un type quelconque est comparé à un autre objet de type Object, alors si les deux objets sont des instances d'une même classe, une comparaison de valeur devient possible, sinon la méthode equals() retourne false.

UneClasse ref_obj1 = new UneClasse();
UneClasse ref_obj2 = new UneClasse();
Object ref_obj3 = new Object();
Object ref_obj4 =  = new UneClasse();

boolean resultat = ref_obj1.equals(ref_obj3);
// resultat = false;

boolean resultat = ref_obj1.equals(ref_obj4);
// resultat = true;

ref_obj3 = ref_obj2;
boolean resultat = ref_obj1.equals(ref_obj3);
// resultat = true;

Dans tous les cas, si les types du temps d'exécution sont différents et même si les types références sont identiques, la méthode equals() retourne toujours false.

class equal {
  public static void main(String[] args){
  String ch = new String("Un texte.");
  String ch2 = new String("Un texte.");
  Boolean log = new Boolean(true);
  Boolean log2 = new Boolean(true);
  Object obj = new Object();
  Object obj2 = new Object();
  String ch3 = new String("U");
  Character car = new Character('U');
  Object obj_car = new Character('U');
  Object obj_ent = new Integer(10);
  Object obj_ent2 = new Long(10);

  if(obj.equals(obj2)) System.out.println("Obj(obj) : Réussi");
  else System.out.println("Obj(obj) : Echec");

  if(obj.equals(log2)) System.out.println("Obj(log) : Réussi");
  else System.out.println("Obj(log) : Echec");

  if(obj.equals(ch2)) System.out.println("Obj(ch) : Réussi");
  else System.out.println("Obj(ch) : Echec");

  if(ch.equals(obj2)) System.out.println("ch(obj) : Réussi");
  else System.out.println("ch(obj) : Echec");

  if(ch.equals(ch2)) System.out.println("ch(ch) : Réussi");
  else System.out.println("ch(ch) : Echec");

  if(ch.equals(log2)) System.out.println("ch(log) : Réussi");
  else System.out.println("ch(log) : Echec");

  if(log.equals(obj2)) System.out.println("log(obj) : Réussi");
  else System.out.println("log(obj) : Echec");

  if(log.equals(log2)) System.out.println("log(log) : Réussi");
  else System.out.println("log(log) : Echec");

  if(log.equals(obj2)) System.out.println("log(obj) : Réussi");
  else System.out.println("log(obj) : Echec");

  if(car.equals(ch3)) System.out.println("car(ch) : Réussi");
  else System.out.println("car(ch) : Echec");

  if(ch3.equals(car)) System.out.println("ch3(car) : Réussi");
  else System.out.println("ch3(car) : Echec");

  if(car.equals(obj_car))
      System.out.println("car(obj_car) : Réussi");
  else System.out.println("car(obj_car) : Echec");

  if(obj_ent.equals(obj_ent2))
      System.out.println("obj_ent(obj_ent2) : Réussi");
  else System.out.println("obj_ent(obj_ent2) : Echec");

  if(obj_ent2.equals(obj_ent))
      System.out.println("obj_ent2(obj_ent) : Réussi");
  else System.out.println("obj_ent2(obj_ent) : Echec");

  obj = log;
  if(log2.equals(obj))
      System.out.println("log(obj=log) : Réussi");
  else System.out.println("log(obj=log) : Echec");

  if(obj.equals(log2))
      System.out.println("obj=log(log) : Réussi");
  else System.out.println("obj=log(log) : Echec");
  }
}

Par ailleurs, l'égalité d'objet est vraie dans les deux sens.

Les constantes contiennent une valeur fixe et sont caractérisées par un identficateur et un type de données à l'instar des variables.

Les constantes peuvent être déclarées dans les classes ou dans les méthodes en utilisant le mot-clé final.

final String COULEUR_NOIRE = "#000000";

final int CODE = 1537503;

final double PI = 3.14;

Par convention, le nom des constantes est toujours en majuscules afin de les distinguer sans équivoques des variables.

La tentative de modifier une constante dans le programme entraînera une erreur lors de la compilation.

Les variables permettent de stocker dans une zone mémoire des informations utilisables dans un programme Java.

Il est nécessaire de déclarer le nom et le type des variables avant de pouvoir leur affecter une valeur.

modificateur type identificateur [= valeur];

• Le nom d'une variable est appelé un identficateur obéissant à certaines règles syntaxiques.
• Le type de la variable correspond au type de données qu'elle devra contenir, en l'occurrence soit un type primitif (int, float, char, boolean, etc.), soit un type composite (String, File, Vector, Socket, Array, etc.).
• La valeur de la variable est appelée un littéral, et doit être conforme à son type de données.
• Le modificateur d'accès de la variable (private, protected, public et par défaut) représente son type d'accessiblité au sein d'un programme.
• D'autres modificateurs peuvent être ajoutés, il s'agît de :
  • final pour définir une constante,
  • static rendant la variable accessible par la classe entière et même sans l'instanciation de cette classe,
  • transient interdisant la sérialisation de la variable,
  • volatile empêchant la modification asynchrone de la variable dans un environnement multi-threads.

Les modificateurs peuvent apparaître dans n'importe quel ordre.

public int hauteur = 100;

static String unite = "mètres";

long population = 6000000000;

boolean reussite = false;

final char CR = '\r';

float = 10.87E5;

URL adresse = new URL("http://java.sun.com/");

private String[] tableau;

transient private long code_secret;

Il est interdit de définir deux fois la même variable au sein d'une même portée.

La portée détermine le partie d'un programme, dans laquelle une variable peut être utilisée.

La portée des variables diffère selon leur emplacement au sein du code Java. En fait, lorsqu'une variable est déclarée au sein d'un bloc de code comme une classe ou une méthode, elle ne peut être utilisée que dans ce même bloc.

public class classe_comptage {
  /* i est utilisable dans toute la classe 
      y compris dans ses méthodes */
  int i = 0;

  public void compteur(){
  // pas est seulement utilisable

  // dans la méthode compteur
    int pas = 5
    while(i <= 100){
      system.out.println(i + 'rn');
      i += 5;
    }
  }
}

Par défaut, les variables possèdent une portée essentiellement locale dans dans leurs blocs respectifs délimités par des accolades.

{
  int x = 1;
  // seul x est accessible à cet endroit
  {
    // x est accessible à cet endroit,

    // y n'est pas accessible puisque la 

    // variable n'est pas encore déclarée
    int y = 2;
    // x et y sont accessibles
  }
  // y n'est pas accessible,

  // x est accessible à cet endroit
}

En se fondant sur cette règle, une variable définie dans une classe peut être accèdée dans toute la classe et une autre définie dans une méthode restera accessible dans cette seule méthode.

public class calcul {
  int a = 10;
  public static void main(String[] args){
    int b = 4;
    System.out.println("resultat : " + a * b);
  }
}

Il est possible de déterminer la portée des variables plus précisément, par le truchement d'un modificateur d'accès.

Les variables peuvent avoir une portée globale, soit une accessibilité entre toutes les classes de tous les paquetages, à condition d'utiliser le modificateur d'accès public lors de leur déclaration.

public class affichage {
  public String texte = 'Un texte...';

  public void affiche(){
    system.out.printl(texte);
}

public class modification {
  public void ajout(){
    texte += 'Un second paragraphe...';
  }
}

La portée entre classe peut être limitée aux seules sous-classes, en déclarant une variable avec le modificateur d'accès protected.

Les variables déclarées avec le modificateur d'accès private ne peuvent être accédées que dans la classe elle-même.

private string chaine = "Une chaîne de caractères...";

Un programme reposant sur des variables globales peut être à l'origine de bogues difficiles à détecter. C'est pourquoi, il est préférable d'utiliser des variables locales offrant plus de sûreté avec une durée de vie limitée.

class calcul{
  int a = 1;
  void addition(){
    int b = 1;
    b += a;
    // a = 2
  }
  void soustraction(){
    int c = 1;
    c -= a + b;
    /* provoque une erreur car b n'est
        accessible que dans addition() */
  }
}

Les variables peuvent être utilisées de différentes manières dans un programme, toutefois toutes doivent être impérativement initialisées avant leur utilisation.

Les variables déclarées dans les méthodes doivent être initialisées manuellement.
Les variables déclarées dans les classes et les tableaux sont initialisés automatiquement à une valeur nulle dépendant de leur type de données.

Une variable peut être manipulée directement à partir de sa classe d'appartenance, voire d'autres classes, il s'agît des variables membres.

class UneClasse {
  static int nombre;
  private float prix;
  public String nom_article = "DVD";
    ...
    static public void UneMethode(int nb){
    nombre = nb;
    ...
  }

  public int UneAutreMethode(String article){
    if(nom_article == article)
      prix = 14.99f;
    ...
  }
  ...
}

Cette catégorie de variables se divisent en deux parties :

• les variables de classe, déclarées avec un modificateur static, sont utilisables dans toute la classe et même hors d'une instance.
  Elles existent dès et tant que que la classe est chargée.
• les champs appelés également attributs ou champs d'instance, déclarés dans la classe avec un modificateur d'accès quelconque (private, protected, public ou par défaut), stockent les valeurs des instances d'une classe.
  Elles existent lors d'une instanciation de classe et jusqu'à leur passage au Garbage Collector.
  Ces variables peuvent être exploitées :
  • dans toute la classe, hormis dans les méthodes statiques,
  • dans toutes instances d'une classe.

Par conséquent, à l'instar d'une méthode, il est possible d'appeler une variable suite à l'instanciation de sa classe d'appartenance.
Dans ce cas, le modificateur d'accès n'a pas d'importance puisqu'il s'intéresse au niveau de classe et non au niveau d'instance. Ainsi, une variable déclarée avec le modificateur le plus restrictif, private pourra être accédée par un objet.

public static void main(String[] args){
  UneClasse objet = new UneClasse();
  objet.prix = 18.55;
  objet.nom_article = "pantalon";
  ...
}

Une variable peut être utilisée seulement à partir de sa méthode d'appartenance, c'est le cas des variables locales ou également appelées automatiques.
Elles ont une durée de vie limitée, le temps d'exécution d'une méthode.
Par ailleurs, le seul modificateur accepté pour ces variables, est final.

public class Variable {
  static String chaine;
  private String chaine2;
  public String chaine3;

  public static void main(String[] args){
    int i;
    String valeur, temp = "";
    Variable objet = new Variable();

    if(args.length > 0)
      for(i = 0; i < args.length; i++)
        temp += " " + args[i];
    else
      temp = "Valeur par defaut";

    // La variable statique chaine est exploitable
 
    // par toutes les méthodes de la classe
    chaine = temp;

    // chaine2 ne peut être utilisé directement dans 

    // une méthode statique comme suit chaine2 = temp;,

    // par contre suite à l'instanciation de sa classe,

    // la variable devient utilisable par le biais de son objet.
    objet.chaine2 = temp;

    // Par l'intermédiaire des arguments, les valeurs

    // de variables locales peuvent être transmises à des 

    // méthodes, lesquels peuvent renvoyer d'autres valeurs.
    valeur = objet.affecte(temp);

    System.out.println("Variable statique : " + chaine);
    System.out.println("Variable privée : " + objet.chaine2);
    System.out.println("Variable locale : " + valeur);

    // Par l'intermédiaire des arguments, les valeurs

    // de variables locales peuvent être transmises à des méthodes,

    // lesquels peuvent renvoyer d'autres valeurs.
    objet.affiche();
  }

  private void affiche(){
    String chaine3 = chaine;
    System.out.println("Variable publique : " + chaine3);
  }

  public String transmet(String argument){
    String chaine4 = argument;
    return chaine4;
  }
}

Les modificateurs permettent d'affecter un comportement spécifique à une classe, une méthode ou une variable.

Il existe deux catégories de modificateurs :

• les modificateurs d'accès : définissant le mode d'accès pour les éléments d'un programme Java,
• les autres modificateurs : indiquant certaines particularités pour des éléments.

Les modificateurs d'accès déterminent la visibilité des classes, méthodes ou variables par rapport aux autres membres et aux autres classes, ainsi qu'entre les paquetages.

Dans la plupart des cas, il est préférable de restreindre autant que possible la portée des éléments d'un programme Java, dans la mesure où, l'encapsulation est un des concepts fondamentaux de la programmation orientée objet.

En effet, une classe peut être complétement encapsulées en déclarant toutes ses variables privées, mais en permetant aux accesseurs d'accèder à ces dernières et aux mutateurs de les modifier, créant ainsi une interface publique (voir les méthodes d'accès).
De plus, un membre privé peut être accédé par n'importe quel instance de sa classe parente.

Les classes ne peuvent être ni privées et ni protégées, hormis les classes internes, celles définies au sein d'une classe.

Le modificateur d'accès par défaut est parfois appelé Friendly (Appellation non-officielle provenant du langage C++).

Ce tableau décrit les modificateurs d'accès possibles pour chaque élément principal d'un programme Java.

En l'absence d'un modificateur, Les constructeurs sont par défaut uniquement accessibles dans le paquetage de la classe parente.
Le modificateur private appliqué au constructeur entraîne l'impossibilité d'instancier sa classe.

Les accès dans les membres d'interfaces (abstraits) ne peuvent être que publiques, et par voie de conséquence, l'accès par défaut est également publique.

interface UneInterface {
  public String uneMethode();
  boolean uneAutreMethode();
  // Les deux méthodes sont publiques
}

Ce tableau indique comment les autres membres d'un même paquetage ou d'un autre différent, sont capables d'accèder aux membres d'une classe et d'en hériter.

A l'intérieur d'un paquetage, seuls les membres et les classes internes privés ne peuvent être accessibles pour d'autres éléments de ce même paquetage. De même, il est impossible pour ces derniers, d'en hériter.

Depuis l'extérieur d'un paquetage, une des différences concerne les éléments protégés, puisque tout en étant inaccessibles, ils peuvent être hérités par d'autres (classes dérivées) situés dans un paquetage distinct.

package package1;

public class UnePremiereClasse {
  type var_pardefaut;
  public type var_publique;
  protected type var_protegee;
  private type var_privee;

  public void uneMethode(){
    var_pardefaut = valeur;
    var_publique = valeur;
    var_protegee = valeur;
    var_privee = valeur;
  }
}

public class UneSecondeClasse {
  UnePremiereClasse UnObjet = new UnePremiereClasse();
  public void uneMethode(){
    UnObjet.var_pardefaut = valeur;
    UnObjet.var_publique = valeur;
    UnObjet.var_protegee = valeur;
  }
}

public class UneSousClasse extends UnePremiereClasse {
  public void uneMethode(){
    var_pardefaut = valeur;
    var_publique = valeur;
    var_protegee = valeur;
  }
}

package package2;

public class UneQuatriemeClasse {
  public void uneMethode(){
    // Aucun accès à UnePremiereClasse...
  }
}

import package1.UnePremiereClasse;
public class UneTroisiemeClasse {
  UnePremiereClasse UnAutreObjet = new UnePremiereClasse();
  public void uneMethode(){
    UnAutreObjet.var_publique = valeur;
  }
}

public class UneAutreSousClasse extends UnePremiereClasse {
  public void uneMethode(){
    var_publique = valeur;
    var_protegee = valeur;
  }
}

public class UneDerniereSousClasse extends UneAutreSousClasse {
  public void uneMethode(){
    var_publique = valeur;
    var_protegee = valeur;
  }
}

Le modificateur abstract est utilisé dans le but d'identifier des classes et des méthodes abstraites.

[modificateurs] abstract class NomClasse {
  ...
}

L'implémentation d'une classe abstraite est remise à ses sous-classes.

Une classe abstraite ne peut seule, avoir d'instances puisqu'elle ne contient que des informations incomplètes.

Une méthode abstraite ne possède pas de bloc d'instructions encadré par des accolades, lequel est remplacé par un séparateur point-virgule (;).

abstract Type uneMethode([Type Argument...]);

Une méthode abstraite peut posséder un à plusieurs arguments.

Lorsqu'une classe étend une classe abstraite, elle doit implémenter toutes les méthodes abstraites de cette dernière en les outrepassant (overriden), soit de redéclarer la méthode avec les mêmes arguments mais en lui fournissant un bloc d'instructions. Sinon, elles doivent être à nouveau déclarées comme abstraites dans la classe étendue.

Le modificateur final ne peut être utilisé avec des classes ou des méthodes abstraites, sans quoi il serait impossible d’étendre les classes et d’outrepasser les méthodes.

Pour en savoir plus, consultez le chapître Les classes abstraites.

Le modificateur final est utilisé pour éviter une extension des classes ou une modification des méthodes ou des variables.

Lorsque le modificateur final apparaît dans une déclaration de classe, cela signifie que la classe ne peut être étendue.

final class NomClasse {
  ...
}

Une méthode portant le modificateur final ne peut pas être remplacée dans une sous-classe.

final Type nomMethode {
  ...
}

En outre, une méthode finale pourra être optimisée par le compilateur, puisqu'elle ne peut être sous-classée.

Par ailleurs, les méthodes déclarées avec le modificateur static ou private sont implicitement finales.

Une variable dont le modificateur est final, signifie que cette variable sera une constante aussitôt après son affectation.

final Type nomVariable;
nomVariable = valeurConstante;

final Type nomVariable = valeurConstante;

Le modificateur final peut être appliqué aux arguments d'une méthode, ainsi qu'aux variables locales.

void uneMethode(final char unArgument) {
  final int variableLocale = 10;
  for(int i = 0; i < variableLocale; i++) {
    System.out.println(i + " - " + unArgument + "rn");
  }
}

Ce type de déclaration permet l'accès des variables locales ou arguments finaux par des classes intérieures locales.

Le modificateur native est utilisé dans le but d'identifier une déclaration de méthode native, c'est-à-dire écrite dans un autre langage que Java.

[modificateurs] native Type nomMethode([Arguments]) 
                                                                    throws TypeException;

A l'instar des méthodes abstraites, une méthode native remplace son bloc d'instructions par un point-virgule.

Une méthode native ne peut pas être déclarées avec le modificateur abstract.

Les méthodes natives présentes dans les bibliothèques dynamiques partagées propre à la plateforme de développement, peuvent être accédées par un programme Java à l'aide de l'interface JNI.

Evidemment, en raison de sa connexité avec la plateforme cible, une méthode native n'est pas portable.

Le modificateur static permet de déclarer une variable, une méthode de classe ou un intialisateur statique, c'est-à-dire que le membre demeure disponible dans une classe entière plutôt que dans un objet spécifique.

Une déclaration de méthodes et de variables de classe permet également de rendre ces derniers, exploitables même si la classe n'a pas été instanciée.

Une variable statiques peuvent être référencées par toutes les instances de sa propre classe ou par l'identificateur de sa classe ele-même.

static type identificateur;

static int nombre = 3;

static String chaine = "Une chaîne de caractères...";

Par exemple, une classe Classe possède une variable statique var et RefClasse1 et RefClasse2 sont des références à des instances de Classe. La variable statique var peut être référencée comme RefClasse1.var, RefClasse2.var et Classe.var. Toutes ces références pointent la même valeur ou le même objet.

Les méthodes statiques sont utilisées uniquement pour accéder aux variables statiques et appeler les méthodes statiques, de sa classe d'appartenance.

public class calcul{
  static int nombre = 0;
  public void calcul(valeur1, valeur2){
    i = valeur1;
    j = valeur2;
  }

  static int compteur(){
    return nombre++;
  }
}

les variables et les méthodes non statiques ne peuvent être respectivement ni accédées et ni appelées par des méthodes statiques.

Une méthode portant le modificateur static ne peut pas être outrepassée.

Les initialisateurs statiques sont des blocs d'instructions encadrées par des accolades sans identificateur, destinés à être exécutés lorsque leur propre classe d'appartenance est chargée et après que les variables statiques soient allouées et initialisées.

static {
  // Bloc d'instructions...
}

public class Increment {
  static int i = 0;
  static int j = 0;
  static int k = 0;

  // Déclaration d'un initialisateur statique
  static {
    System.out.println("Exemple de membres statiquesrn");
    for(;i < 5; i++) {
      System.out.println("i = " + i + "rn");
      j++;
    }
  }

  public static void main(String[] args) {
    for(;j < 10; j++)
      System.out.println("j = " + j + "rn");
    for(;k < 10; k++)
      System.out.println("k = " + k + "rn");
  }
  // A la fin des boucles :
  // j aura parcouru de 0 jusqu'à 4
  // j aura parcouru de 5 jusqu'à 9
  // k aura parcouru de 0 jusqu'à 9
}

Il n'est pas possible d'utiliser la référence this dans les méthodes statiques et encore moins dans les initialisateurs.

Le modificateur synchronized permet de contrôler l'accès aux objets partagés dans un environnement multi-threads.

Ce modificateur permet d'éviter que plusieurs unités d'exécution (ou threads) puissent accéder simultanément au même objet.

Pour qu'une classe Java soit utilisable en multi-tâches, il est nécessaire qu'elle possède des méthodes synchronized.
En fait, toutes les méthodes de tous les objets doivent être synchronisées pour une utilisation correcte de l'objet dans un environnement multi-threads.

synchronized objet

synchronized (expression){
  ...
}

public void nomMethode(String[] tableau) {
  synchronized (tableau){
    // Instructions...
  }
  ...
}

Dans le cas d'un bloc d'instructions synchronisé, l'objet adéquat est l'argument entre les paranthèses.

Une méthode synchronisée permet d'appliquer un dispositif de verrouillage sur un objet ou sur une classe à partir duquel, elle est appelée.

void synchronized nomMethode(){
  ...
}
//est équivalent à
void nomMethode(){
  synchronized (this){
    ...
  }
}

Dans le cas d'une méthode d'instance synchronisée, l'objet adéquat est représenté par le mot-clé this.

Lorsqu'une thread veut exécuter une méthode d'instance portant le modificateur synchronized, Java verrouille l'instance de classe.
Subséquemment, une autre thread invoquant une méthode synchronisée sur ce même objet, sera bloquée tant que que le verrou ne sera pas levé.

class Calculatrice {
  int x;
  int y;
  ...
  // Ces méthodes synchronisées garantiront que

  // les variables x et y ne seront pas modifiées
 
  // durant l'une des opérations
  public synchronized float addition(){
    return x + y;
  }
  public synchronized float soustraction(){
    return x - y;
  }
  public synchronized float multiplication(){
    return x * y;
  }
  public synchronized float division(){
    return x / y;
  }
  ...
}

De la même façon, si une thread veut exécuter une méthode de classe (static) portant le modificateur synchronized, Java pose un verrou empêchant un autre thread de solliciter une méthode synchronisée de la même classe.

Dans le cas d'une méthode statique synchronisée, l'objet de classe adéquat est l'instance de java.lang.Class définissant cette méthode de classe.

Les méthodes synchronisées ne peuvent pas s'exécuter en concurrence, leur permettant ainsi de maintenir un état stable dans l'entité partagée.

Lorsque l'exécution d'une méthode synchronized se termine de n'importe quelle manière, le verrou est levé et une autre méthode synchronisée peut alors à son tour être exécutée.

class UniteExecution extends Thread {
  static String message[] = {"Ceci","est","une",
                               "demonstration","de",
                               "Thread","dans","Java."};

  public static void main(String args[]){
    UniteExecution UE1 = new UniteExecution("Premier Thread : ");
    UniteExecution UE2 = new UniteExecution("Second Thread : ");
    UE1.start();
    UE2.start();
    boolean UE1_actif = true;
    boolean UE2_actif = true;
    while(UE1_actif || UE2_actif) {
      if(UE1_actif && !UE1.isAlive()){
        UE1_actif = false;
        System.out.println("UE 1 est inactif.");
      }
      if(UE2_actif && !UE2.isAlive()){
        UE2_actif = false;
        System.out.println("UE 2 est inactif.");
      }
    }
  }

  public UniteExecution(String chaine){
    super(chaine);
  }

  public void run(){
    synchronized(System.out){
      System.out.print(getName());
      for(int i = 0; i < message.length; i++) {
        temporisation();
        System.out.print(message[i]);
        if(i == message.length - 1)
          System.out.println("n");
        else
          System.out.print(" ");
      }
    }
  }

  void temporisation(){
    try {
      sleep(800);
    }
    catch (InterruptedException x){
      System.out.println("Un problème s'est produit !");
    }
  }
}

Le modificateur transient permet de déclarer qu'une variable ne peut pas être sérialisée.

transient Type nomVariable;

Ainsi, les méthodes gérant la persistance d'un objet ne prennent pas en compte ce type de variable.

Ce modificateur est particulièrement adapté pour la protection de données sensibles, dans la mesure ou il empêche leur écriture dans un flux.

D'autre part, les variables transientUn champ transient sert à indiquer aux méthodes qu'elle ne fait pas partie de la persistance de l'objet. Cette fonctionnalité n'a été mise en oeuvre qu'à partir de Java 1.1, et sert à éviter de sauvegarder des champs ne servant qu'à des calculs intermédiaires (indices par exemple).

Le modificateur volatile indique qu'une variable de classe ne peut être modifiée de manière asynchrone dans un environnement multiprocesseur.

volatile nomVariable;

Les variables volatiles sont préservées d'une certaine dégradation sous des conditions multichaînées.

Le modificateur volatile permet de s'assurer d'un accès ordonné des unités d'exécutions (ou threads) sur une variable.

Une variable volatile ne peut utiliser le modificateur final.

Le modificateur strictfp permet de contrôler le comportement de la virgule flottante par rapport au standard IEEE 754 (Standard for Binary Floating-Point Arithmetic).

Le modificateur strictfp ne peut être appliqué qu'à :

• des classes,
• des interfaces,
• des méthodes.

Par défaut, les calculs sur les nombres de type double ou float sont effectués d'une façon non stricte dans une classe, une interface ou une méthode. Pour éviter cela, il suffit d'utiliser le modificateur strictfp dans leur déclaration.

strictfp class NomClasse {...}

strictfp interface INomInterface {...}

strictfp type méthode(){...}

L'entité déclarée avec le modificateur strictfp est alors dite FP-strict.

Si une classe est FP-strict, cela implique que ses méthodes sont également FP-strict.

Toutefois, le modificateur strictfp ne peut s'appliquer ni aux méthodes d'interfaces, ni aux constructeurs de classes.

Le modificateur strictfp permet de garantir les mêmes rendus de calculs, quelle que soit la machine virtuelle Java (JVM) sur laquelle l'opération est effectuée.

public strictfp class FPStrict {
  public static void main(String[] args){
    double nb_double = 1e+307;
    System.out.println("nb_double = " + nb_double);

    System.out.println("32.0 * nb_double * 1.0 / 2.0 = " 
                          + 32.0 * nb_double * 1.0 / 2.0);
    // (((32.0 * nb_double) * 1.0) / 2.0)

    // ((Infinity * 1.0) / 2.0)

    // affiche Infinity en ignorant le reste du calcul

    // pourtant l'expression est égale à 16 * nb_double

    // soit 1.6e+308

    System.out.println("32.0 / 2.0 * nb_double = "
                          32.0 / 2.0 * nb_double);
    // ((32.0 / 2.0) * nb_double)

    // 16 * nb_double

    // affiche 1.6e+308
  }
}

En principe, le modificateur strictfp devrait conraindre la JVM à évaluer la première expression de telle sorte qu'elle retourne une valeur identique à celle de la seconde expression.

Les méthodes Java, équivalentes aux fonctions ou aux procédures présentes dans d'autres langages, sont utilisées dans les classes et permettent de définir des opérations à accomplir sur un objet ou dans une classe.

Une méthode est un sous-programme destiné à exécuter un bloc d'instructions suite à son appel dans un programme principal.

Il existe plusieurs types de méthodes dans Java. Elles sont chargées à différentes étapes du déroulement d'un programme, d'effecuer des tâches précises, comme l'initialisation d'un objet nouvellement créé ou l'accès et la manipulation de membres spécifiques.

Les méthodes sont composées d'un modificateur d'accès optionnel, d'un type de retour, d'un identificateur, d'éventuels arguments entre paranthèses et surtout d'un bloc d'instructions compris entre des accolades.

[modif_acces] type_retour nom_methode([arguments])
                             [throws Classes_Exceptions...]
{
  // Bloc d'instructions...
  [return ValeurDeRetour;]
}

La partie déclarative d'une méthode, soit l'ensemble des éléments précédant le bloc d'instructions délimités par des accolades, s'appelle la signature de la méthode. Cette dernière contient toutes les caractéristiques permettant d'utiliser convenablement les méthodes. Ainsi, on distingue :

• les modificateurs d'accès et spéciaux,
• le type de valeur retourné,
• le nom de la méthode,
• la liste des paramètres,
• les exceptions susceptibles d'être lancées par la méthode.

Le modificateur d'accès (public, private ou protected) détermine la visibilité de la méthode dans sa propre classe, ainsi que dans d'autres classes et également à l'intérieur ou à l'extérieur de paquetages.

Les méthodes peuvent être également :

• final empêchant la surcharge ou l'outrepassement de la méthode,
• static rendant la méthode disponible dans la classe entière et même si cette dernière n'est pas instanciée,
• synchronized permettant de contrôler l'accès aux objets partagés,
• strictfp permettant d'indiquer que toutes les expressions de la méthode sont en virgule flottante stricte.

Le type permet de spécifier le type de données retourné par la méthode au moyen de l'instruction return. Si cette dernière ne renvoie aucune valeur, alors le mot-clé void devra être indiqué.

void affichage(){
  System.out.println("Une chaîne de caractères...");
}

String concatenation(String chaine){
  chaine += chaine;
  return chaine;
}

Le nom de la méthode correspond aux règles des identificateurs Java.

Les arguments sont facultatifs. Il est possible de passer à une méthode, un à plusieurs arguments (correspondants aux paramètres listés dans la signature de la méthode) pouvant être une constante, une variable, une expression ou encore un appel de méthode retournant une valeur.

L'instruction throws permet de déclarer les classes d'exceptions susceptibles de se produire dans la méthode.

Le bloc d'instructions peut contenir n'importe quelles commandes Java à l'exception d'autres méthodes, mais doit être impérativement terminé par une instruction return, dans le cas ou la méthode renverrait une valeur de retour.

L'utilisation des méthodes d'une classe passe par leur appel dans un programme Java.

Avant tout appel d'une méthode d'instance, il faut instancier la classe concernée afin de produire un objet. Ensuite, cet objet doit être joint par un point au nom de la méthode suivi de ses éventuels arguments entre paranthèses.

// instance de classe
nom_classe nom_objet = new nom_classe();

// appel d'une méthode
nom_objet.nom_methode([arguments...]);

Les méthodes de classe peuvent être accédées directement dans une classe par d'autres méthodes statiques.

Les méthodes peuvent accepter des données provenant de l'extérieur par l'intermédiaire des paramètres, lesquels sont listés entre des parenthèses suivant l'identificateur de la méthode.

modif type méthode([liste_des_paramètres])
{ ... }

Les paramètres sont séparés par des virgules et énoncent pour chacun d'eux, un type et un identificateur.

type méthode(type id, ..., type idN)
{ ... }

Subséquemment, des arguments peuvent être passés si nécessaire à la méthode, lors de son appel dans un programme.

méthode(arg, ..., argN);

Le passage d'arguments devra respecter le sens de l'élargissement des types de données.

class Calculatrice {
  static short arg_a = 10;
  static short arg_b = 25;

  public static void main(String[] args){
    Calculatrice obj = new Calculatrice();
    // appel de la méthode avec passage d'arguments
    //respectant le sens de l'élargissement short -> int
    int res = obj.addition(arg_a, arg_b);
    System.out.println(res);
  }

  // définition de la méthode avec paramètres
  public int addition(int param_a, int param_b){
    return (param_a + param_b);
  }
}

Dans ce cas de figure, les méthodes peuvent recueillir des données de deux façons différentes :

• Passage par valeur,
• Passage par référence.

Toutes les données de type primitif (byte, short, char, int, long, float et double) sont passées à une méthode par valeur, c'est-à-dire qu'une copie de la donnée est mise à disposition de la méthode et non l'original.

class Arg {
  int a = 10;
  int b = 20;

  public static void main(String[] args){
    Arg obj = new Arg();
    int resultat = obj.uneMethode(a, b);
    // a vaut toujours 10
    // b vaut toujours 20
  }

  int uneMethode(int x, int y){
    // x vaut 10
    // y vaut 20
    return (++x - ++y);
    // x vaut 11
    // y vaut 21
  }
}

Par conséquent, une méthode ne peut modifier que la copie d'une donnée, sans pour autant affecter la valeur de l'original.

Pour le passage par référence, la méthode reçoit dans ce cas, une copie d'une référence vers un objet.
Mais, cette copie de la référence originale pointe précisément sur le même objet. De cette manière, toutes les opérations produites par la méthode réceptrice, affecte l'objet référencé également par l'argument transmis. Cela peut, donc, conduire à la modification potentielle d'une ou plusieurs valeurs d'attribut de l'objet en cours par la méthode réceptrice.

class Arg {
  String ch = new String("Un texte");
  String ch2 = new String("très bien présenté !");

  public static void main(String[] args){
    Arg obj = new Arg();
    System.out.println("Valeur de l'objet original (avant) : " + obj.ch);
    concatener(obj);
    // ch vaut "Un texte très bien présenté !"
    // ch2 vaut toujours "très bien présenté !"
    System.out.println("Valeur de l'objet original (après) : " + obj.ch);
  }

  static void concatener(Arg objet){
    objet.ch += " " + objet.ch2;
    // objet.ch vaut "Un texte très bien présenté !"
    // objet.ch2 vaut toujours "très bien présenté !"
    System.out.println("Copie d'objet : "+ objet.ch);
  }
}

Toutes les modifications apportées à l'objet passé en argument à une méthode sont permanentes et se répercutent donc dans le reste du programme et cela même si la méthode en question a cessé son activité.

En outre, des méthodes peuvent utiliser des variables définies dans une classe.

Les variables publiques, protégées, privées et par défaut peuvent être accédées de façon directe par n'importe quel méthode, à l'exception des méthodes statiques.

Les variables statiques peuvent être utilisées directement par toutes les méthodes et en particulier par les méthodes statiques.

Toutes les variables accédées de cette manière peuvent subir des modifications directes et permanentes depuis le bloc d'instructions des méthodes.

Une méthode est capable de retourner une valeur fabriquée localement, d'un type quelconque exploitable à l'endroit où l'appel s'est produit, en général une méthode d'un niveau supérieur.

[modif] type_retour nomMethode([liste_params]){
  // instructions...
  return valeur;
}

A cet effet, une méthode dispose de :

• l'instruction return, destinée à retourner un résultat,
• un type de retour situé dans la signature de la méthode, indiquant le type du résultat renvoyé.

class UneClasse {
  public static void main(String[] args){
    double r = 10;
    double resultat = surface(r);
    System.out.println("Surface d'un cercle de "+ r + "cm : " + resultat);
  }
  public static double surface(double rayon){
    return (Math.pow(rayon, 2) * Math.PI) / 2;
  }
}

L'évaluation de l'instruction return par la Machine Virtuelle Java, entraîne l'arrêt immédiat de l'exécution de la méthode courante, ainsi que le transfert le résultat de l'expression à l'appelant.

Il est possible de placer plusieurs instructions return dans une méthode, mais à l'unique condition que chaque commande de ce type soit placée dans une structure conditionnelle.

class UneClasse {
  public static void main(String[] args){
    double v = 10;
    char t = 'd';
    System.out.println("Surface d'un cercle d'un " 
                       + (t == 'r' ? "rayon" : "diametre") 
                       + " de " + v + "cm : " + surface(v, t) + "cm2");
  }
  public static double surface(double val, char type){
    if(type == 'r')
        return (Math.pow(val, 2) * Math.PI) / 2;
    else if(type == 'd')
        return (Math.pow(val, 2) * 2 * Math.PI) / 4;
    else
        System.out.println ("Le type de la valeur n'a pas été spécifiée !");
        return 0.0;
  }
}

Une méthode peut retourner aussi bien une valeur primitive (char, int, double, etc.) qu'un objet (String, Vector, File, etc.).
Dans le premier cas, une copie de valeur est réalisée entre le résultat produit par la méthode appelée et l'éventuelle variable, méthode ou expression destinée à recevoir ce résultat.
Dans le second cas, c'est une copie de la référence de l'objet résultant qui est accomplie. De cette manière, lorsque la méthode appelée cesse son activité, la référence d'origine est détruite, mais l'objet reste disponible dans le programme par l'intermédiaire de la copie de référence.

import java.net.*;
import java.io.*;
public class UneClasse {
  public static void main(String[] args) throws IOException {
    URL resCon = saisieAdresse();
    System.out.println ("Protocole : " + resCon.getProtocol() 
              + "\nHote : " + resCon.getHost() 
              + "\nChemin : " + resCon.getPath() 
              + "\nFichier : " + resCon.getFile() 
              + "\nRequete : " + resCon.getQuery());
  }
  public static URL saisieAdresse() throws IOException {
    String url = "http://www.unsite.com/rep/fichier.html?requete=valeur";
    URL adresse = new URL(url);
    return adresse;
  }
}

Il est tout à fait possible de ne pas utiliser la valeur de retour d'une méthode. Cela est souvent le cas dans les méthodes qui ne retourneraient qu'une valeur booléenne indiquant la réussite (true) ou l'échec (false) du traitement.

import java.net.*;
import java.io.*;
public class UnClass {
  public static void main(String[] args) throws IOException {
    URL resCon = saisieAdresse();
    affichage(resCon);
  }
  public static URL saisieAdresse() throws IOException {
    String url = "http://www.unsite.com/rep/fichier.html?requete=valeur";
    URL adresse = new URL(url);
    return adresse;
  }
  public static boolean affichage(URL adr) throws IOException {
    if(!adr.equals("")){
      System.out.println ("Protocole : " + adr.getProtocol() 
                + "\nHote : " + adr.getHost() 
                + "\nChemin : " + adr.getPath() 
                + "\nFichier : " + adr.getFile() 
                + "\nRequete : " + adr.getQuery());
      return true;
    }
    else {
      System.out.println ("L'adresse URL est vide !");
      return false;
    }
  }
}

Si une méthode retourne une valeur, il faut impérativement spécifier un type de retour dans la signature de la méthode, sinon une erreur de compilation se produira indubitablement.

A l'inverse, si une méthode ne renvoie aucune valeur, alors le mot-clé spécial void doit être spécifié afin d'indiquer explicitement cette caractéristique.

L'encapsulation est un concept fondamental de la programmation orientée objet en fournissant aux classes l'entière responsabilité de la représentation interne de leurs propres données tout en autorisant la manipulation de ces dernières par des méthodes spéciales dites d'accés.

Les méthodes d'accès, appelées accesseur (getter) ou mutateur (setter), fournissent une interface publique permettant de manipuler les membres encapsulés, c'est-à-dire ceux possédant un modificateur d'accès private à partir d'autres classes.

• Les accesseurs permettent d'accéder à des membres privés.
• Les mutateurs permettent de modifier des membres privés.

La méthode dite accesseur, permettant de retourner la valeur d'un membre privé, doit avoir comme type de retour, le spécificateur de type de la variable à renvoyer.

Par ailleurs, l'accesseur, en général, ne nécessite pas d'arguments et doit toujours posséder un modificateur publique.

public TypeVariable getNomVariable()
{...}

public class UneClasse {
  public static void main(String[] argv){
    AutreClasse obj = new AutreClasse();
    int nb_AC = obj.getNombre();
  }
}

class AutreClasse {
  private int nombre;
  public int getNombre(){
    return nombre;
  }
}

Une méthode dite mutateur, permettant la modification de la valeur d'un membre privé, doit posséder un paramètre correspondant à la valeur à affecter au membre concerné. En outre, le paramètre doit avoir le même type que le membre privé.

D'autre part, le mutateur, en général, ne retourne pas de valeur et doit toujours posséder un modificateur publique à l'instar de l'accesseur.

public void setNomVariable(TypeVariable ValeurVariable)
{...}

public class UneClasse {
  public static void main(String[] argv){
    AutreClasse obj = new AutreClasse();
    int nouv_nb = 100;
    obj.setNombre(nouv_nb);
  }
}

class AutreClasse {
  private int nombre;
  public void setNombre(int nouveau_nombre){
    nombre = nouveau_nombre;
  }
}

Par convention, il est préférable de nommer spécifiquement les méthodes en les faisant précéder du préfixe get pour un accesseur et du préfixe set pour un mutateur comme dans les exemples précédents.

Si la représentation interne de la classe subit des modifications, c'est-à-dire si les données sont modifiées comme le type ou l'identificateur d'un membre concerné, il est impérativement nécessaire de répercuter les éventuels changements au niveau des méthodes d'accès.

public class UneClasse {
  public static void main(String[] argv){
    AutreClasse obj = new AutreClasse();
    int nouv_nb = 100;
    obj.setNombre(nouv_nb);
    int nb_AC = obj.getNombre();
  }
}

class AutreClasse {
  private int nb_personnels;
    public int getNombre(){
    return nb_personnels;
  }

  public void setNombre(int nouveau_nombre){
    nb_personnels = nouveau_nombre;
  }
}

Les modifications apportées à la classe encapsulée ne peuvent et souvent ne doivent avoir aucun effet sur son utilisation par d'autres classes devant continuer à fonctionner correctement, à condition de ne pas toucher les identificateurs des méthodes d'accès et de vérifier la compatibilité des types des variables, paramètres et arguments concernés.

La méthode main constitue la partie principale du programme, permettant l'exécution d'une application Java.

public static void main(String[] args){
  //instructions...
}

public indique que la méthode peut être appelée par n'importe quel objet.

static indique que la méthode est une méthode de classe, c'est-à-dire qu'elle restera accessible même s'il n'existe aucune instance de la classe.

void indique qu'aucune valeur ne sera retournée par la méthode.

L'argument de la méthode main est un tableau d'éléments textuels fournissant le moyen de passer des informations à l'application. Chaque chaîne de caractères du tableau est appelée un argument de ligne de commande.

public class AfficheArguments {
  public static void main (String[] args){
  for (int i = 0; i < args.length; i++)
      System.out.println('args[' + i + '] : ' + args[i]);
  }
}

// Lancement de la classe en ligne de commande
java AfficheArguments Le langage de programmation Java
/* Affichage des arguments de la ligne de commande
args[0] : Le
args[1] : langage
args[2] : de
args[3] : programmation
args[4] : Java */

Les arguments de ligne de commande sont tous les éléments suivants l'identificateur de classe. Ce dernier, les options et la commande java n'en font pas partie.

java [-options] identificateur_classe arguments...

java -verbose:class UneClasse Un argument
/* deux arguments 
args[0] : Un
args[1] : argument */

Lorsque la méthode main est trouvée dans une classe, elle devient la méthode à partir de laquelle démarre automatiquement le programme.

Public class Repetition {
  String balise = "<br>";
  public static void main(String[] args){
    for(int i = 0; i < 10; i++)
      System.out.println(balise);
  }
}

Un programme Java simple ne pourrait contenir qu'une seule classe renfermant une méthode main regroupant les instructions destinées à être exécutées.

D'autre part, il est permis d'utiliser une méthode main() avec un type de retour, mais elle ne sera pas appelée lorsque la classe sera invoquée.

public static String main(String[] args){
  ...
}

Le constructeur est une méthode spéciale d'une classe, permettant d'initialiser les membres de cette classe et également, d'exécuter différentes opérations initiales définies par le programmeur.

L'instanciation d'une classe (ou la création d'un objet) nécessite l'utilisation de l'opérateur new appelant un constructeur.

NomClasse ref_objet = new Constructeur();

L'identificateur du constructeur doit être en tout point identique à l'identificateur de la classe.

IdentificateurClasse ref_objet = new IdentificateurClasse();

En l'absence d'une déclaration de constructeur dans une classe, le compilateur Java en génère automatiquement un par défaut, lequel n'aura pas d'argument et aucune autre fonction que de créer un objet.

public class UneClasse {
  // Aucun constructeur défini
  ...
}
// est équivalent à
public class UneClasse {
  // Génération automatique de ce constructeur
  public UneClasse(){
    super();
  }
  ...
}

Le modificateur d'accès du constructeur par défaut, est toujours le même que celui de sa classe.

Afin d'éviter cette création automatique, il peut être parfois préférable de déclarer un constructeur mieux adapté aux besoins de la classe.

class NomClasse {
  // méthode constructeur
  modificateur NomClasse([type Paramètre, ...])
                         [throws ClasseExceptions...] {
  // Bloc d'instructions...
  }
}
...
//Instanciation de la classe
NomClasse ref_objet = new NomClasse([Arguments]);

Le constructeur doit avoir un identificateur en tout point semblable à celui de sa classe.

Les constructeurs peuvent être déclarés avec un modificateur d'accès public, protected, par défaut ou private.
Les constructeurs sont par défaut uniquement accessibles dans le paquetage de la classe parente.
Le modificateur private entraîne l'impossibilité d'instancier la classe du constructeur et également de l'étendre.

Un constructeur ne peut être déclaré avec les modificateurs suivants : abstract, static, final, native, synchronized, ou strictfp.
Si la classe est FP-Strict, le constructeur l'est également implicitement.

Le constructeur ne peut retourner une valeur, et donc, sa déclaration ne contient aucun type de retour. En fait, l'instance de l'objet est toujours le type retourné par un constructeur.

Le constructeur peut posséder un à plusieurs paramètres permettant notamment l'affectation des champs de l'objet avec des valeurs fournies par l'utilisateur.

class Article {
  int idProduit;
  float prix;
  float reduction;

  Article(int idProduit, float prix, float reduction) {
    this.idProduit = idProduit;
    this.prix = prix;
    this.reduction = reduction;
  }
}

Article livre = new Article(9782212075021, 55.0, 5.0);

La clause throws optionnelle permet d'indiquer que le constructeur peut déclencher les exceptions spécifiées.

La définition d'un constructeur doit apparaître au moins une fois dans une classe, mais n'est en aucun cas une nécessité absolue, dans la mesure où aucune initialisation particulière ne serait nécessaire au démarrage de l'objet.

Parfois, il est utile de définir dans une classe, plusieurs constructeurs avec des signatures distinctes (voir La surcharge des méthodes). Cela permet d'initialiser un objet de plusieurs façons différentes.

class Article {
  String nomProduit;
  int idProduit;
  float prix;
  float reduction;

  public Article(int idProduit, float prix, float reduction) {
    this.idProduit = idProduit;
    this.prix = prix;
    this.reduction = reduction;
  }

  public Article(String nomProduit, float prix, float reduction) {
    this.nomProduit = nomProduit;
    this.prix = prix;
    this.reduction = reduction;
  }
}
...
Article livre = new Article(9782744090004, 329.0, 0.0);

Article livre = new Article("Maîtrisez Java 2", 329.0, 0.0);

Utilisé avec des constructeurs multiples, le mot clé this contient la liste des arguments correspondant à la liste des paramètres d'un des constructeurs de la classe en cours, permettant d'abréger la rédaction des affectations dans les définitions suivantes.

import java.util.*;
import java.text.*;

class UneClasse {
  String date_envoi;
  String expediteur;

  String destinataire;

  public UneClasse(String dest, String exp){
    Date date_actuelle = new Date();
    DateFormat formatage =
             DateFormat.getDateInstance(DateFormat.FULL, Locale.FRANCE);
    date_envoi = formatage.format(date_actuelle);
    expediteur = exp;
    destinataire = dest;
    System.out.println("nUneClasse(String String)");
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }
  public UneClasse(int jm, int mm, int aaaa,
                            String dest, String exp){
    this(dest, exp);
    date_envoi = jm + "/" + mm + "/" + aaaa;
    System.out.println("nUneClasse(int int int String String)");
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }
  public UneClasse(String js, int jm, String mm, int aaaa,
                            String dest, String exp){
    this(dest, exp);
    date_envoi = js + " " + jm + " " + mm + " " + aaaa;
    System.out.println("nUneClasse(String int String int String String)");
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }
  public UneClasse(int jm, String mm, int aaaa,
                            String dest, String exp){
    this(dest, exp);
    date_envoi = jm + " " + mm + " " + aaaa;
    System.out.println("nUneClasse(int String int String String)");
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }
  public UneClasse(String dest){
    this(4, 11, 2002, dest, "ADV Consulting");
    System.out.println("nUneClasse(String)");
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }

  public static void main(String[] args){
    UneClasse obj1 = 
        new UneClasse("adresse destinataire", "adresse expéditeur");
    UneClasse obj2 = 
        new UneClasse(2, 11, 2002, 
                          "adresse destinataire", "adresse expéditeur");
    UneClasse obj3 = 
        new UneClasse("Samedi", 2, "Novembre", 2002, 
                          "adresse destinataire", "adresse expéditeur");
    UneClasse obj4 = new UneClasse("adresse destinataire");
  }
}

Dans des conditions similaires, le mot clé super contient la liste des arguments correspondant à la liste des paramètres d'un des constructeurs de la superclasse, permettant d'invoquer directement ce constructeur à partir de la classe étendue.

import java.util.*;
import java.text.*;

class SousClasse extends SuperClasse {
  String date_envoi;
  String destinataire;

  public SousClasse(String date_complete, String exp){
    this("Madame","MALLET", "Carole", 
                  "1 allee d'Artois", 
                  93330, "Neuilly-sur-Marne");
    date_envoi = date_complete;
    expediteur = exp;
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }

  public SousClasse(String civilite,
                                String nom,
                                String prenom,
                                String adresse,
                                int code_postal,
                                String ville){
    super(nom, prenom, adresse, code_postal, ville);
    Date date_actuelle = new Date();
    DateFormat formatage = 
             DateFormat.getDateInstance(DateFormat.FULL, Locale.FRANCE);
    this.date_envoi = formatage.format(date_actuelle);
    this.destinataire = 
                       civilite + " " + super.adresse_expedition;
    System.out.println("Date : " + date_envoi);
    System.out.println("destinataire (SousClasse) :n" 
                             + destinataire);
  }

  public SousClasse(int date_complete, String exp){
    super("144 avenue Saint Antoine", 13015);
    Integer dd = new Integer(date_complete);
    date_envoi = dd.toString();
    expediteur = exp;
    this.destinataire = super.adresse_expedition;
    System.out.println("Date : " + date_envoi);
    System.out.println("Expéditeur : " + expediteur);
    System.out.println("destinataire : " + destinataire);
  }

  public static void main(String[] args){
    SousClasse obj =
                  new SousClasse("Mademoiselle", "DUBOIS", "Laure", 
                                              "99 cours Vitton", 
                                              69006, "Lyon");
    SousClasse obj4 = new SousClasse("02/11/2002", "M. Jean SOUPIR");
    SousClasse obj3 = new SousClasse(29102002, "M. Marc MILLAUD");
  }
}

class SuperClasse {
  static String adresse_expedition;

  public SuperClasse(String nom, 
                                  String prenom, 
                                  String adresse, 
                                  int code_postal, 
                                  String ville){
    adresse_expedition = nom + " " + prenom + "n" 
                             + adresse + "n" 
                             + code_postal + " " + ville;
    System.out.println("Adresse d'expédition (SuperClasse) :n" 
                             + adresse_expedition);
  }

  public SuperClasse(String adresse, int code_postal){
    adresse_expedition = "Societe ADV Internet Consuting" 
                             + adresse + "n" 
                             + code_postal + " " + "Marseille";
    System.out.println("nAdresse d'expedition (SuperClasse) 
                             + adresse_expedition);
  }
}

Si this et super doivent être utilisés dans des constructeurs, il faut qu'ils apparaissent en tant que première instruction. Par voie de conséquence, il n'est possible d'utiliser qu'un seul de ces mots clés dans une définition de constructeur.

La liste des arguments du mot-clé this ou super provoquera respectivement l'appel du constructeur de la classe ou de la superclasse possédant les paramètres appropriés.

D'autre part, la liste des arguments présentées par les mots clés this et super, doit correspondre parfaitement à l'énumération des paramètres du constructeur référence (types, nombre et séquence des paramètres).
L'identificateur de chaque paramètre n'a aucune importance.

Un appel explicite du constructeur d'une superclasse doit être effectué avec le mot clé super dans les constructeurs des classes étendues, si cette superclasse ne possède pas de constructeur sans arguments.

Le polymorphisme consituant un concept majeur de la programmation orientée objet, la surcharge (overload) des méthodes est l'une des représentantes de cette particularité dans le langage Java.

Si deux méthodes possédent un nom semblable mais différentes signatures, le nom de ces méthodes est dit surchargé.

Chaque méthode se distingue par une signature spécifique, c'est-à-dire :

• le nom,
• le type des paramètres,
• la séquence de ces derniers.

modif type_retour nom(type param, ..., type paramN)
{ ... }
int calculer(float somme, int pourcentage)
{ ... }

Le type de retour ne fait pas partie de la signature d'une méthode car lors de l'appel d'une méthode, rien ne suggère au compilateur quel est le type de retour attendu.

class UneClasse {
  public int uneMethode(int un_parametre){
    // Bloc d'instructions...
  }
  public long uneMethode(int un_parametre){
    // Bloc d'instructions...
  }
}
...
UneClasse obj = new UneClasse();
System.out.println(obj.uneMethode(100));
// Quelle méthode est attendue ?

// De plus, une erreur se produit lors de la
 
// compilation de la classe UneClasse.

Il n'existe aucune contrainte à propos des types de retour à condition que les méthodes aient des signatures strictement différentes, sinon le compilateur générera une erreur.

Les clauses d'exceptions throws des deux méthodes surchargées n'ont aucune incidence sur la validité de la surcharge.

Les méthodes peuvent être déclarées dans une même classe ou provenir de l'héritage d'une superclasse, ou l'une est déclarée dans une classe et l'autre héritée d'une superclasse.

Ainsi dans une classe ou dans une hiérarchie de classes, plusieurs méthodes peuvent posséder un nom identique si leurs paramètres sont différents.
Si des méthodes possèdent des paramètres identiques mais sont déclarées dans des classes distinctes, les méthodes sont dites outrepassées (voir L'outrepassement des méthodes).

void calcul()
{ // instructions... }

void calcul(int valeur, int autre_valeur)
{ // instructions... }

void calcul(float valeur, int autre_valeur)
{ // instructions... }

// Appels des méthodes
operation.calcul();

operation.calcul(100);

operation.calcul(12.3, 4);

Les méthodes surchargées peuvent avoir un type de retour et des modificateurs distincts à condition que leurs paramètres soient différents.

void calcul()
{ // instructions... }

public int calcul(int parametre)
{ // instructions... }

protected double calcul(int argument, double autre_argument)
{ // instructions... }

Toutefois, deux méthodes ne peuvent avoir un nom et des paramètres identiques avec un type de retour différent. Dans ce cas, le compilateur Java générera une erreur.

int calcul(int parametre)
{ // instructions... }

double calcul(int parametre)
{ // instructions... }
// Ceci entrainerait une erreur de compilation !

Dans sa propre classe, une méthode privée peut être surchargée sans problème. De même, une méthode de même nom peut être créée dans une classe héritée sans provoquer d'erreur de compilation ou d'exécution.

class Prog {
  static String l_argument = "";
  static char caracteres[];
  public static void main(String[] args){
    if(args.length > 0)
      for(int i = 0; i < args.length; i++)
        l_argument += args[i] + " ";
    else
        l_argument = "Les arguments sur la ligne de commande !";
    caracteres = l_argument.toCharArray();
    UneClasse ref_obj = new UneClasse();
    ref_obj.uneMethode(l_argument);
    ref_obj.setMethodeCl(caracteres[0]);
    // erreur de compilation due à un
 
    // appel directe d'une méthode privée
    ref_obj.uneMethode(caracteres[0]);  }
}
class SuperClasse {
  private void uneMethode(String un_parametre){
    System.out.println("Methode privee(SuperClasse) : " + un_parametre);
  }
  private void uneMethode(char un_parametre){
    System.out.println("Methode privee(SuperClasse) : " + un_parametre);
  }
  public void setMethodeS1(String param){
    uneMethode(param);
  }
  public void setMethodeS2(char param){
    uneMethode(param);
  }
}

class UneClasse extends SuperClasse {
  public void uneMethode(String un_parametre){
    System.out.println("Methode privee(UneClasse) : " + un_parametre);
    super.setMethodeS1(un_parametre);
  }
  private void uneMethode(char un_parametre){
    System.out.println("Methode publique(UneClasse) : " + un_parametre);
    super.setMethodeS2(un_parametre);
  }
  public void setMethodeCl(char un_parametre){
    uneMethode(un_parametre);
  }
}

D'ailleurs, les méthodes statiques peuvent également être surchargées sans aucune contrainte.

La surcharge des méthodes s'applique de la même façon aux constructeurs. Ainsi, il devient possible à une classe de posséder plusieurs constructeurs permettant de paramétrer différemment un objet lors de sa création.

class Article {
  int idProduit;
  float prix = 0.0f;
  float reduction = 0.0f;

  Article(int idProduit, float prix, float reduction) {
    this.idProduit = idProduit;
    this.prix = prix;
    this.reduction = reduction;
  }
  Article(int idProduit) {
    this.idProduit = idProduit;
  }
}

Dans le cas des constructeurs, il n'existe pas de type de retour. Donc, la surcharge ne tient compte que du nom et des paramètres de ce genre particulier de méthodes.

L'outrepassement (overriding) des méthodes représente l'autre mode d'implémentation du polymorphisme dans le langage Java, permettant la redéfinition du comportement d'une ou plusieurs méthodes d'une superclasse, à partir d'une classe étendue.

Une méthode d'instance (public, protected ou par défaut) déclarée dans une superclasse peut être outrepassée (override) dans une autre classe :

• si cette dernière est une classe dérivée de la superclasse,
• si la méthode outrepassée n'est pas privée et est accessible à partir de la sous-classe.

Une méthode statique déclarée dans une superclasse ou une interface peut être cachée (hide) par une autre méthode statique :

• si elle possède une signature identique,
• si elle est déclarée dans une classe étendant ou implémentant respectivement cette superclasse ou interface.

Malgré la différence précitée entre les méthodes d'instance et de classe, les règles d'outrepassement sont exactement les mêmes dans les deux cas.

Une erreur de compilation se produit si une méthode d'instance tente d'outrepasser une méthode statique et inversement.

class SuperClasse {
  static void methodeClasse(){
    ...
  }
}
class ClasseDerivee extends SuperClasse {
  // erreur de compilation
  public void methodeClasse(){
    ...
  }
}

L'outrepassement (parfois remplacement) est autorisé si les deux méthodes possèdent un nom, une liste de paramètres et un type de retour identiques, mais l'une (méthode d'origine) doit être localisée dans une superclasse et l'autre (méthode outrepassée) dans une classe dérivée.

class UneClasse {
  modificateur type uneMethode(type un_parametre)
                                  [throws ClasseException] {
    ...
  }
}

class UneClasseEtendue extends UneClasse {
  modificateur type uneMethode(type un_parametre)
                                  [throws ClasseException] {
    ...
  }
}

Les identificateurs des paramètres peuvent être différents dans les deux méthodes sans avoir aucune incidence sur le bon fonctionnement du programme.
Par contre, les paramètres doivent posséder exactement les mêmes types et le même ordre que dans la méthode à outrepasser.

Le modificateur d'accès de la méthode outrepassée ne doit pas être plus restrictif que celui de la méthode de la superclasse.

Sémantiquement, une méthode de superclasse privée entraîne une impossiblité d'appliquer une surcharge ou un outrepassement à partir d'une classe étendue puisqu'elle ne peut être héritée par une sous-classe.
Cependant techniquement, une sous-classe peut parfaitement posséder une méthode d'une signature identique à une autre déclarée avec le modificateur d'accès private dans une superclasse sans engendrer d'erreur. Mais dans ce cas, aucune relation n'existe entre les deux méthodes.

En outre, une méthode de superclasse ne peut être outrepassée pour devenir privée dans une classe étendue.

De même, une méthode finale ne peut être outrepassée car elle ne peut être modifiée.

Par ailleurs, s'il existe une clause throws dans la déclaration de la méthode d'origine, celle outrepassée doit obligatoirement spécifier les mêmes types d'exceptions afin d'éviter tout conflit conduisant fatalement à une erreur de compilation.

Parfois, il peut être utile de pouvoir appeler la méthode de la superclasse, outrepassée dans la classe en cours. Cela est possible en utilisant le mot-clé super faisant référence à la superclasse.

class SuperClasse {
  public void uneMethode(String un_parametre){
    System.out.println("SuperClasse : " + un_parametre);
  }
}

class UneClasse extends SuperClasse {
  public void uneMethode(String un_parametre){
    System.out.println("UneClasse : " + un_parametre);
  }
  public void uneMethodeDeSuperClasse(String un_parametre){
    super.uneMethode(un_parametre);
  }
}

class Prog {
  public static void main(String[] args){
    String l_argument = "";
    if(args.length > 0) {
      for(int i = 0; i < args.length; i++){
        l_argument += args[i] + " ";
      }
    }
    UneClasse ref_obj = new UneClasse();
    ref_obj.uneMethode(l_argument);
    ref_obj.uneMethodeDeSuperClasse(l_argument);
    // affiche :
    //  UneClasse : argument...
    //  SuperClasse : argument...
  }
}

Le mot-clé super ne peut être utilisé que pour appeler une méthode dans la classe immédiatement supérieure. Par exemple, si une troisième classe héritait de la classe UneClasse, le mot-clé super ne pourrait être utilisé deux fois (super.super.methode()) pour appeler directement la méthode de la classe SuperClasse.

class UneTroisiemeClasse extends UneClasse {
  public void uneMethode(String un_parametre){
    System.out.println("UneTroisiemeClasse : " + un_parametre);
  }
  public void uneMethodeDeSuperSuperClasse(String un_parametre){
    // formulation incorrecte
    super.super.uneMethode(un_parametre);
    // formulation correcte
    super.uneMethodeDeSuperClasse(un_parametre);
  }
}

Les mots clés This et Super sont utilisés pour faire référence à un membre courant, respectivement dans la classe et dans la superclasse en cours.

Ces mots-clés permettent de manipuler des membres ou des méthodes provenant d'une classe courante ou d'une classe parente.

Le mot clé this permet de faire référence à l'objet en cours.

Le mot clé this permet de désigner des variables définies dans une classe, à partir d'une méthode.

this.nomVariable;

public class NomClasse{
  int x = 10;
  public void methode(int x){
    /* affecte la valeur de l'argument 'x' de 
      la méthode à la variable de classe 'x' */
    this.x = x;
    System.out.println(this.x);
  }
}

Il n'est pas nécessaire d'utiliser le mot clé this, lorsque les identificateurs de variables et d'arguments ne présentent aucune équivoque.

En fait, le mot clé this, constituant une variable système, est passé subrepticement en argument, à chaque méthode d'une classe, si bien qu'implicitement, chaque variable définie dans la classe porte la variable this.

Le mot clé super permet de faire référence à l'objet parent.

Le mot-clé super permet de désigner des membres de la superclasse, et partant de manipuler ces derniers à partir d'une sous-classe.

super.nomVariable

super.nomMethode()

Ce mot clé peut également être utilisé avec une liste d'arguments optionnels pour appeler le constructeur de superclasse.

super(Arguments, ...);

Un intialisateur (ou initialiseur) est un bloc d'instructions encadré par des accolades, destiné à être exécuté juste avant le constructeur d'une classe.

{
  // Bloc d'instructions...
}

class NomClasse {
  String a, b, c, d, resultat;

  {
      a = "Initialisation";
      b = "avant";
      c = "le";
      d = "constructeur";
  }

  public NomClasse(){
    resultat = a + " " + b + " " + c + " " + d + " ";
  }

  public static void main(String[] args) {
    NomClasse objet = new NomClasse();
    objet.affiche(objet.resultat);
  }

  static void affiche(String chaine){
    System.out.println(chaine);
  }
}

Lors d'une instanciation de classe, les initialisateurs de cette dernière sont exécutés immédiatement avant le constructeur.

Un initialisateur statique est un bloc d'instructions encadré par des accolades possédant un modificateur static.

static {
  // Bloc d'instructions...
}

Les initialisateurs statiques ne s'intéressent qu'à des variables ou des méthodes portant le modificateur static.

class NomClasse {
  static String a = "variable statique a.";
  static String b;
  String c = "Variable par défaut c";
  String d;

  // Exécuté en premier
  static {
    b = "variable b initialisee dans l'initialisateur statique.";
    affiche(b);
  }

  // Exécuté en troisième
  public NomClasse(){
    d = "variable initialisee dans le constructeur";
    System.out.println(d);
  }

  public static void main(String[] args) {
    // Exécuté en second
    affiche(a);
    NomClasse objet = new NomClasse();
    // Exécuté en quatrième
    objet.affiche(objet.c);
    NomClasse objet2 = new NomClasse();
    // Exécuté en dernier
    objet2.affiche(objet2.d);
  }

  static void affiche(String chaine) {
    System.out.println(chaine);
  }
}

Lors d'une instanciation de classe, les initialisateurs statiques sont exécutés après que les données statiques soient allouées et avant le constructeur.

Les intialisateurs statiques permettent de lancer des traitements uniquement pour la première instance d'une classe, car ils ne sont exécutés qu'une seule fois.

Les initialisateurs statiques se révélent également utiles pour l'initialisation complexes de variables statiques.

Les classes constituent le fondement de la programmation Java. Toutes les méthodes et les variables sont contenues à l'intérieur de classes et existent dans un programme au travers des objets résultant d'instanciations de classes.

Une classe est un modèle qui décrit les données et les comportements associés aux instances de ces classes.

Les données associées à une classe ou à un objet sont stockées dans des variables et le comportement associé à une classe ou à un objet est défini par des méthodes.

Une instanciation de classe permet de créer un objet possédant des aspects et des perceptions semblables aux autres instances de la même classe. Une instance de classe constitue un synonyme d'objet.

La déclaration d'une classe constitue une étape essentielle de la programmation orientée objet, et partant, du développement en langage Java.

La déclaration d'une classe s'effectue par l'intermédiaire du mot clé class.

modificateur class Identificateur {
  //Bloc d'instructions...
}

Les modificateurs possibles pour une classe de haut niveau ne peuvent être que :

• public,
• abstract,
• final,
• strictfp.

Le modificateur d'accès public permet de rendre la classe accessible à travers toutes les classes de tous les paquetages. Une seule et unique classe peut être publique dans un fichier source.

D'autres modificateur d'accès sont possibles comme private, protected ou friendly rendant la classe visible uniquement dans son propre paquetage.

Le modificateur final indique que la classe ne peut être étendue.

Le modificateur abstract indique que la classe est abstraite.

Le mot-clé class permet de commencer la définition d'une classe.

Un nom est spécifié à la classe afin de pouvoir l'identifier dans un programme.

Les accolades délimitent le bloc d'instructions définissant les variables, les méthodes et les éventuelles sous-classes de la classe.

import java.io.*;
import java.lang.*;
import java.util.*;

public class Annuaire {

  public static void main(String[] args) {
    String nomFichier = "annuaire.txt";
    String ligne = null;
    String nom = null
    String prenom = null;
    int telephone = 0;
    try {
      FileReader flux = new FileReader(fichier);
      BufferedReader tampon = new BufferedReader(flux);

      while ( (ligne = tampon.readLine()) != null ){
        StringTokenizer st = new StringTokenizer(ligne, ",");
        nom = st.nextToken();
        prenom = st.nextToken();
        try {
          telephone = new Integer(st.nextToken()).intValue();
        }
        catch (NumberFormatException e) {
          System.out.println("Une exception s'est produite ! : " 
                          + e.getMessage());
          System.out.println("Affichage de la pile :n");
          e.printStackTrace();
        }
        System.out.println(nom + " " + prenom + " : " + telephone);
      }
      tampon.close();
      flux.close();
    }
    catch (IOException e) {
      System.out.println("Une exception s'est produite ! : " 
                        + e.getMessage());
      System.out.println("Affichage de la pile :n");
      e.printStackTrace();
    }
  }
}

La conception de classe peut recourir à des artifices grammaticaux telles que is a (est un/une) et has a (a un/une ou possède un/une) utilisés dans des descriptions de classes.

La relation is a sous-entend un héritage entre deux classes.

Le chêne est un arbre.
(The oak is a tree.)

La classe chêne hérite de la classe arbre.

class Arbre {
  ...
}
class Chene extends Arbre {
  ...
}

La relation has a sous-entend la possession d'une variable par une classe.

L'arbre a une consommation en eau, une taille,

un nombre de branches et un nombre de feuilles.

(The tree has a water consumption, a size,

a number of branches and a number of sheets.)



La classe Arbre possède quatre variables :

consommation_eau en litres,
taille en mètres,
nombre_branches,
nombre_feuilles.


class Arbre {
  float consommation_eau;
  float taille;
  int nombre_branches;
  int nombre_feuilles;
  ...
}

Les deux artifices peuvent évidemment se combiner pour donner des énoncés plus ou moins complexes.

Le chêne est un arbre qui a une consommation
 
en eau, une taille, un nombre de branches 

et un nombre de feuilles.

(The oak is a tree which has a water consumption, 

a size, a number of branches and a number of sheets.)

class Arbre {
  float consommation_eau;
  float taille;
  int nombre_branches;
  int nombre_feuilles;
  ...
}
class Chene extends Arbre {
  ...
}

Le langage Java permet d'accomplir une programmation orientée objets. Effectivement, un programme Java constitue un groupe d'objets, lesquels possèdent chacun des caractéristiques propres et se complémentent dans le but d'accomplir un travail.

Tous les objets sont issus de classes créées par l'intermédiaire de l'instruction class suivi d'un identificateur.

public class nom_classe{
  //instructions...
}

Un objet est caractérisé par des attributs le décrivant et des comportements représentant ces actions.

Les attributs sont en fait les variables contenues déclarées dans la classe de l'objet.

Les comportements sont les méthodes figurant dans cette même classe.

public class calcul{
  int i = 10;
  int j = 12;
  public void multiplication(){
    System.out.println(i + " * " + j " = " + i * j);
  }
}

/*
  Deux attributs i et j
  Une méthode multiplication
*/

L'utilisation d'un objet dans un programme est possible à condition de déclarer une instance d’un type de classe. Cette opération s'effectue à partir de l'opérateur new affectant une instance de classe à une variable.

nom_classe nom_objet = new nom_classe();

calcul operation = new calcul();

A partir de là, il devient possible d'utiliser les variables et les méthodes de la classe à partir de l'objet.

//premiere_operande = 10
int premiere_operande = operation.i;
//seconde_operande = 12
int seconde_operande = operation.j;
//affiche 10 * 12 = 120
operation.multiplication();

//seconde_operande = 12
operation.j = 24;
//affiche 10 * 24 = 240
operation.multiplication();

Chaque classe contient une méthode spécialisée dénommée constructeur, lequel possède toujours un nom semblable à celui de sa classe et ne peut renvoyer une valeur de retour.

Lors de l'utilisation de l'opérateur new, le constructeur est automatiquement appelé afin d'affecter des ressources telles que la définition et l'initialisation de variables, nécessitées par l’objet.

public class calcul{
  int i = 10;
  int j = 12;
  public void calcul(int val1, int val2){
    i = val1;
    j = val2;
  }
  public void multiplication(){
    System.out.println(i + " * " + j " = " + i * j);
  }
}

calcul operation = new calcul(250, 100);
//affiche 250 * 100 = 25000
operation.multiplication();

L'héritage est un concept fondamental de la programmation orientée objet car il permet la création d'une nouvelle classe à partir d'une classe existante.

Dans le langage Java, l'héritage multiple n'est pas possible, puisqu'une classe ne peut posséder qu'une seule et unique superclasse. Par contre, une classe parente peut avoir une à plusieurs sous-classes.

Les classes héritant d'autres classes sont dites dérivées ou étendues, voire même directement appelées des sous-classes et la classe parente est parfois appelée superclasse ou générique.

Le mot-clé extends est utilisé dans une déclaration de classe dérivée, pour spécifier une superclasse.

modificateur_acces SuperClasse {
  //...
}

modificateur_acces class ClasseDerivee extends SuperClasse{
  //...
}

Par défaut, toutes les classes héritent de la superclasse la plus élevée dans la hiérarchie, c'est à dire de la classe Object.

//Hiérarchie de classes pour la classe Applet
java.lang.Object
  |
  +--java.awt.Component
        |
        +--java.awt.Container
            |
            +--java.awt.Panel
                  |
                  +--java.applet.Applet

Une classe dérivée hérite de toutes les méthodes et propriétés de la superclasse. La sous-classe peut ainsi définir de nouveaux membres qui ajouteront de nouvelles fonctionnalités à celles existantes, mais aussi de redéfinir des membres hérités à l'aide de la surcharge des méthodes, du mot clé super ou de la réaffectation des variables.

class super_classe {
  // Déclarations des attributs
  type attribut_1;
  type ...
  type attribut_N;

  // Déclarations des fonctions
  public type nom_methode_1 (type param_1, ..., type param_N){
    //Bloc d'instructions...
  }
  ...
  public type nom_methode_N (type param_1, ..., type param_N){
    //Bloc d'instructions...
  }
}

class nouvelle_classe extends super_classe {
  // Déclarations des nouveaux attributs
  type attribut_1;
  type ...
  type attribut_N;

  // Déclarations des nouvelles fonctions
  public type nom_methode_1 (type param_1, ..., type param_N){
    //Bloc d'instructions...
  }
  ...
  public type nom_methode_N (type param_1, ..., type param_N){
    //Bloc d'instructions...
  }
}

Un mécanisme spécifique appelé liaison dynamique (ou liaison tardive) détermine à l'exécution d'un programme (runtime) quelles sont les méthodes les plus appropriées à appeler, lorsque ces dernières ont été surchargées. Ces méthodes doivent possèder un modificateur d'accès soit public, soit protected. Si les méthodes sont privées, statiques ou finales alors elles sont directement invoquées sans utiliser la liaison dynamique.

class Animal {
  public void manger(){
    //...
  }
  public void seDeplacer(){
    //...
  }
}
class Bison extends Animal {
  public void manger(){
    //...
  }
  public void seDeplacer(){
    //...
  }
  public void brouter(){
    //...
  }
  public void transhumer(){
    //...
  }
}
class Tigre extends Animal {
  public void manger(){
    //...
  }
  public void deplacer(){
    //...
  }
  public void devorer(){
    //...
  }
}
Animal animal = new Animal();
Tigre tigre = new Tigre();
Bison bison = new Bison();

//Appel de la méthode déclarée au sein de la superclasse Animal
animal.manger();

//Appel des méthodes surchargées déclarées au sein des sous-classes
bison.manger();
tigre.manger();

//Appel de la méthode surchargée déclarée au sein de la sous-classe Tigre
animal = tigre;
animal.manger();

//Appel de la méthode surchargée déclarée au sein de la sous-classe Bison
animal = new Bison();
animal.manger();

La JVM se fonde sur le type dynamique d'un objet pour déterminer les méthodes à invoquer et non sur son type référence.

En ce qui concerne les propriétés surchargées, le fonctionnement est radicalement différent.

class Animal {
  public float poids = 0;
}
class Bison extends Animal {
  public float poids = 400;
}
class Tigre extends Animal {
  public float poids = 250;
}
Animal animal = new Animal();
Tigre tigre = new Tigre();
Bison bison = new Bison();

//Appel du champ déclaré au sein de la superclasse Animal
System.out.println(animal.poids;); //0

//Appel des champs surchargés déclarés au sein des sous-classes
System.out.println(bison.poids;); //400
System.out.println(tigre.poids;); //250

//Appel du champ déclaré au sein de la superclasse Animal
animal = tigre;
System.out.println(animal.poids;); //0

//Appel du champ surchargé déclaré au sein de la superclasse Animal
animal = new Bison();
System.out.println(animal.poids;); //0

Lors du processus de compilation, le mécanisme de typage statique contraint les propriétés d'un objet à suivre le type référence de ce dernier.

L'utilisation du modificateur abstract dans une déclaration de classe signifie qu'une ou plusieurs des méthodes à l'intérieur du corps de la classe sont déclarées comme abstraites.

abstract modificateur NomClasse {
  modificateur Type NomMethode();
  ...
}

Si une méthode à l'intérieur de la classe est déclarée avec le modificateur abstract, alors cette classe doit être définie explicitement comme abstraite.

abstract modificateur NomClasse {
  abstract modificateur Type nomMethode([Type Arguments, ...]);
  ...
}

Les classes déclarées avec le modificateur abstract ne peuvent être instanciées. Les classes abstraites contraignent à fournir un bloc d'instructions pour chacune de leurs méthodes abstraites à l'intérieur d'une nouvelle classe dérivée, laquelle pourra être instanciée.

abstract modificateur NomClasse {
  modificateur NomMethode();
  ...
}

modificateur_acces ClasseDerivee extends NomClasse {
  modificateur_acces Type nomMethode() {
  // Bloc d'instructions...
  }
  ...
}

Une classe dérivée d'une classe abstraite doit impérativement implémenter toutes les méthodes abstraites de cette dernière, sinon elle doitporter le modificateur abstract dans sa déclaration.

Une interface pouvant être considérée comme étant une classe abstraite, une classe qui en implémente une doit être déclarée abstraite si toutes les méthodes de l'interface n'y sont pas implémentées.

Les classes abstraites sont utilisées pour fournir des méthodes et des variables communes à l'ensemble de leurs sous-classes.

Une interface est un modèle d'implémentation, permettant de mettre en relation des entités sans rapports.

Dans le langage de programmation Java, une interface, définissant un protocole de comportement, est un élément que des objets sans liens utilisent pour interagir entre eux.

La déclaration d'une interface s'effectue par l'intermédiaire de l'instruction interface.

modificateur_acces interface NomInterface {
  //...
}

Une interface déclarée avec un modificateur d'accès public peut être implémentée par n'importe quelle classe intérieure ou extérieure à son paquetage. A défaut, elle ne pourra être utilisée que dans le paquetage parent.

Par ailleurs, toutes les interfaces portent implicitement le modificateur abstract.

Une interface peut être déclarée avec le modificateur strictfp permettant de contrôler le comportement de la virgule flottante.

Il ne peut exister qu'une seule et unique interface publique par fichier source, à l'instar des classes publiques. Par convention, une interface publique donne son nom au fichier source.

De plus, Java ne permettant pas l'héritage multiple, l'utilisation des interfaces permet de palier à cette carence dans la mesure où une classe peut désormais implémenter plusieurs interfaces.

L'instruction implements permet d'indiquer que la classe fournit une implémentation pour une ou plusieurs interfaces. Ce mot clé doit toujours être placé après la clause d'extension introduite par extends.

class NomClasse implements NomInterface, ..., NomInterfaceN {
  //...
}

Les interfaces possèdent en général dans leur bloc d'instructions, des déclaration de méthodes sans corps ainsi que des déclaration de variables.

// Déclaration de méthode
modificateur_acces Type nomMethode();
// Déclaration de variable
modificateur_acces Type nomVariable = ValeurConstante;

public interface ValidationEnvoi {
  final float TIMBRE = 0.46f;

  public void Poste(float timbre, String adr_exp);
  public boolean PossedeUnTimbre();
  public boolean PossedeUneAdressedExpedition();
  public boolean Envoi();
}

Toutes les méthodes contenues dans une interface sont implicitement déclarées publiques et abstraites.

Les méthodes ne peuvent être déclarées avec les modificateurs final, native, static, et synchronized.

Toutes les variables, en fait des constantes, contenues dans une interface sont implicitement déclarées publiques, statiques et finales et doivent avoir une valeur constante d'affectation.

Les constantes ne peuvent être déclarées avec les modificateurs transient et volatile.

Afin d'éviter une redondance dans les déclarations de méthodes et de constantes, il est inutile de spécifier explicitement les modificateurs par défaut précités.

Toutes les classes implémentant une interface doivent possèder les méthodes déclarées dans cette dernière en y ajoutant toutefois un bloc d'instructions.

public class Lettre implements ValidationEnvoi {
  int nb_timbres = 0;
  String adr_exp = null;
  boolean valide_timbre = false;
  boolean valide_adresse = false;

public void Poste(int timbre, String adr_exp) {
    this.nb_timbres = timbre;
    this.adr_exp = adr_exp;
    System.out.println("Timbre : " + this.timbre + "n" +
                        "Adresse : " + this.adr_exp);
  }

public boolean PossedeUnTimbre() {
    if (nb_timbres > 0)
      return valide_timbre = true;
    else
      return valide_timbre = false;
  }

  public boolean PossedeUneAdressedExpedition() {
    if (adr_exp != null)
      return valide_adresse = true;
    else
      return valide_adresse = false;
  }

  public boolean Envoi() {
    if (valide_timbre && valide_adresse)
      return true;
    else
      return false;
  }

  public float PrixTimbres() {
      return this.nb_timbres * TIMBRE;
  }
}
  
public class Appli {
  public static void main(String args[]) 
    String adresse = "Mlle Julie LAMYrn"
                   + "10 Allée d'Artoisrn"
                   + "93330 Neuilly Sur Marne";
    int affranchissement = 1;

    Lettre envoiLettre = new Lettre();

    envoiLettre.Poste(affranchissement, adresse);

    System.out.println("Adresse d'expedition : " +
        (envoiLettre.PossedeUneAdressedExpedition() ? "Oui" : "Non"));

    System.out.println("Affranchissement : " +
        (envoiLettre.PossedeUnTimbre() ? "Oui" : "Non"));

    System.out.println("Montant de l'affranchissement : " +
        envoiLettre.PrixTimbres() + " €");

    System.out.println("Procedure d'envoi validee : " +
        (envoiLettre.Envoi() ? "Oui" : "Non"));
  }
}

Les interfaces ne peuvent implémenter d'autres interfaces. Par contre, elles peuvent hériter de plusieurs autres interfaces.

public interface NomInterface 
              extends AutreInterface, ..., AutreInterface 
...

Le bloc d'instructions des interfaces contient essentiellement des déclarations de constantes et de méthodes abstraites.

Les interfaces constituent une catégorie particulière des classes abstraites.

Les classes internes (inner classes) peuvent être situées à différent niveau d'une classe normale. Elles représentent une particularité intéressante et subtile de la programmation avec le langage Java.

class ClasseParente {
  modificateur class ClasseInterne 
                          [extends SuperClasse] 
                          [implements ListeInterfaces] {
    // Instructions...
  }

  modificateur interface InterfaceInterne {
    // Instructions...
  }

  // Instructions...
}

Il existe quatre types de classes imbriquées :

• les classes internes simples, définies au niveau des classes,
• les classes internes statiques, représentant une classe de sommet intérieure,
• les classes locales, définies au niveau des méthodes,
• les classes internes anonymes, définies au niveau d'une instance.

Les interfaces peuvent être également déclarées à n'importe quel endroit d'une classe.

Une classe interne peut définir de la même manière, une à plusieurs autres classes internes.

Les classes internes après la compilation sont enregistrées dans un fichier .class particulier.

ClasseParente$ClasseInterne.class

Les fichiers stockant des classes locales possèdent un format différent incluant un identificateur numérique représentant la méthode d'inclusion.

ClasseExterne$1$ClasseLocale.class

Les classes anonymes sont stockées dans un format distinct incluant, lui aussi, un identificateur numérique représentant l'instance d'inclusion.

ClasseExterne$1.class

De cette façon, le nom d'une classe interne peut être identique à celui d'une autre sans pour autant créer d'ambiguités, lors de l'emploi de l'une ou l'autre des classes.

Chaque type de classes ou interfaces intérieures possèdent des spécifités programmatiques propres.

Les classes internes simples sont définies au sein des classes. Elles constituent des membres à part entière des classes d'inclusions au même titre que des variables ou des méthodes.

class ClasseParente {
  ...
  modificateur class ClasseInterne {
    // instructions...
  }
  ...
}

Une classe interne peut être déclarée avec n'importe lequel des modificateurs d'accès (public, protected, par défaut ou private) et les modificateurs spéciaux abstract, final ou static. Les classes possèdant le modificateur static deviennent des classes internes statiques.

Une classe interne déclarée avec le modificateur d'accès private implique que cette classe ne pourra être utilisée que dans sa classe parente.

Les classes internes ne peuvent pas être déclarées à l'intérieur d'initialisateurs statiques ou de membres d'interface.

Les classes internes ne doivent pas déclarer de membres statiques, hormis s'ils comportent le modificateur final, dans le cas contraire, une erreur de compilation se produit.

class Classeinterne {
  static final x = 10; // constante statique
  static int y = 12; // erreur de compilation
  ...
}

Toutefois, les membres statiques de la classe externe peuvent être hérités sans problème par la classe interne.

Les classes imbriquées sont capables d'accéder à toutes les variables et méthodes de la classe parente, y compris celles déclarées avec un modificateur private.

class ClasseParente {
  int x = 10;
  int y = 12;
  private int addition(){
    return (x + y);
  }
  class ClasseInterne {
    void verification(){
      if((x + y)== addition())
        System.out.println("La classe interne a bien accédé "
                          + "aux membres de sa classe parente.");
    }
  }
  public static void main(String[] args){
    ClassParente obj_out = new ClasseParente();
    ClasseInterne obj_in = obj_out.new ClasseInterne();
    obj_in.verification();
  }
}

Cette notation particulière spécifie que l'objet créé est une instance de la classe interne associée à l'objet résultant de l'instanciation d'une classe de plus haut niveau.

L'instanciation de la classe interne passe obligatoirement par une instance préalable de la classe d'inclusion.
La classe parente est d'abord instanciée, puis c'est au tour de la classe interne de l'être par l'intermédiaire de l'objet résultant de la première instance.

ClassParente obj_out = new ClasseParente();
ClasseInterne obj_in = obj_out.new ClasseInterne();
// est équivalent à
ClasseInterne obj_in = (new ClassParente()).new ClasseInterne();

Il est possible d'utiliser une méthode de la classe parente pour créer directement une instance de la classe interne. Toutefois, lors de l'appel de la méthode, il sera nécessaire de créer une instance de la classe d'inclusion.

class ClasseParente {
  int x = 10;
  int y = 12;
  private int addition(){
    return (x + y);
  }
  class ClasseInterne {
    public void verification(){
      if((x+y)== addition())
        System.out.println("La classe interne a bien accédé "
                          + "aux membres de sa classe parente.");
    }
  }
  void rendDisponible(){
    // Création d'une instance de la classe interne
    ClasseInterne obj_in = new ClasseInterne();
    // Appel d'une méthode de la classe interne
    obj_in.verification();
  }
  public static void main(String[] args){
    // Création préalable d'une instance de la classe parente
    ClasseParente obj_out = new ClasseParente();
    // Appel de la méthode instanciant la classe interne
    obj_out.rendDisponible();
  }
}

Cette manière de créer une instance de la classe interne est possible grâce à la référence d'objet this désignant une instance de la classe parente.

ClasseInterne obj_in = new ClasseInterne();
// est équivalent à
this.ClasseInterne obj_in = this.new ClasseInterne();

L'utilisation implicite du mot-clé this permet au constructeur de la classe parente de créer une instance de la classe interne. Le constructeur de cette dernière pourra alors exécuter ses propres instructions.

class ClasseParente {
  int x = 10;
  int y = 12;
  // constructeur externe
  ClasseParente(){
    // Création d'une instance de la classe interne
    new ClasseInterne();
  }
  public static void main(String[] args){
    // Création préalable d'une instance de la classe parente
    new ClasseParente();
  }
  private int addition(){
    return (x + y);
  }
  class ClasseInterne {
    // constructeur interne
    ClasseInterne(){
      if((x + y)== addition())
        System.out.println("La classe interne a bien accédé "
                          + "aux membres de sa classe parente.");
    }
  }
}

Il est possible d'imbriquer des classes sur plusieurs niveaux. Une classe normale peut contenir une à plusieurs classes internes et ces dernières peuvent contenir également une à plusieurs autres classes intérieures.

class ClasseParente {
  int x = 10;
  int y = 12;

  public static void main(String[] args){
  ClasseInterne obj_in = 
                      (new ClasseParente()).new ClasseInterne();
    obj_in.verification();
  }

  private int addition(){
    return (x + y);
  }

  class ClasseInterne {
    public void verification(){
      if((x + y)== addition())
        System.out.println("La classe interne a bien accédé "
                          + "aux membres de sa classe parente.");
        ClasseInterneInterieure obj_inin = 
                        new ClasseInterneInterieure();
        System.out.println(obj_inin.ajouter());
    }
    class ClasseInterneInterieure {
      int z = 10;
      int ajouter(){
        return (z + x);}
    }
  }
}

La classe doublement imbriquée ne peut être instanciée que dans sa classe parente directe.

Les méthodes et les variables d'instance d'une classe interne ne deviennent disponibles dans la classe parente qu'après l'instanciation de cette classe imbriquée.

Parfois, il peut être nécessaire de distinguer les variables situées dans les classes interne et externe.

class Externe {
  int x = 10;
  int y = 12;
  Externe(){
    new Interne();
  }
  public static void main(String[] args){
    new Externe();
  }
  class Interne {
    int x = 8;
    int y = 14;
    Interne(){
      if(this.x + this.y == Externe.this.x + Externe.this.y)
        System.out.println("La classe interne a bien "
                          + "accédé à l'ensemble des membres "
                          + "des classes imbriquées.");
    }
  }
}

Le mot-clé this permet d'accéder à un membre de la classe en cours, c'est-pourquoi this.variable accède au membre de la classe interne et Externe.this.variable à celui de la classe parente spécifiée.

Les classes internes statiques peuvent accéder à l'ensemble des membres statiques de leur classe parente, à l'instar des méthodes de classe.

class ClasseParente {
  static int x = 10;
  static int y = 12;
  // La classe interne statique ne 
  // peut accèder à cette variable
  int z = x + y;
  static int addition(){
    return (x + y);
  }
  // La classe interne statique ne 
  // peut accèder à cette méthode
  int resultat(){
    return (z);
  }
  static class ClasseInterne {
    ClasseInterne(){
      if((x + y)== addition())
        System.out.println("La classe interne a bien accédé aux "
                          + "membres statiques de sa classe parente.");
    }
  }
  public static void main(String[] args){
    new ClasseInterne();
  }
}

Il n'est pas nécessaire de créer une instance de la classe parente pour pouvoir instancier la classe intérieure statique contrairement aux classes internes simples.

Il est possible de créer une instance d'une classe interne par l'instruction suivante :

new ClasseParente.ClasseInterne()

Le mot-clé this n'est pas utilisable dans le contexte des classes internes statiques, et partant, celles-ci n'ont pas accès aux variables et méthodes non-statiques de leur classe d'inclusion.

Les méthodes d'une classe interne statique peuvent être accédées dans la classe parente de la même façon que les classes internes simples, c'est-à-dire, suite à l'instanciation de leur propre classe.

class ClasseParente {
  static int x = 10;
  static int y = 12;
  static int addition(){
    return (x + y);
  }
  static class ClasseInterne {
    void verification(){
      if((x + y)== addition())
        System.out.println("La classe interne a bien accédé aux "
                          + "membres statiques de sa classe parente.");
    }
  }
  public static void main(String[] args){
    ClasseInterne obj_in = new ClasseInterne();
    obj_in.verification();
  }
}

Une classe locale est définie à l'intérieur d'une méthode, et partant, agît librement et essentiellement au sein de cette dernière.

modificateur class UneClasse {
  modificateur type_retour uneMethode([Liste de paramètres]){
    class UneClasseLocale {
      // instructions...
    }
  }
}

Il n'est possible de déclarer des classes locales, dont la portée est limitée au bloc, qu'avec les modificateurs final ou abstract. Les modificateurs suivants : public, protected, private et static, sont interdits.

Les données membres d'une classe externe peuvent être accédés par la classe locale.

class ClasseExterne {
  int x = 10;
  int y = 12;
  int z = x + y;
  void addition(){
    class ClasseLocale {
      boolean verification(){
        if(x + y == z)
          return true;
        else
          return false;
      }
    }

    ClasseLocale obj_in = new ClasseLocale();
    if(obj_in.verification()){
      x = x + y;
      System.out.println("La classe interne a bien accédé aux "
                          + "membres de la classe extérieure.n"
                          + "x = " + x + "ny = " + y + "nz = " + z);
     }
     else 
       System.out.println("Erreur !");

   }
   public static void main(String[] args){
     ClasseExterne obj_out = new ClasseExterne();
     obj_out.addition();
  }
}

Seules les variables locales et les paramètres de la méthode d'inclusion, déclarées avec le modificateur final, peuvent être exploitées par les classes internes locales, sinon une erreur se produit lors de la compilation. De plus, ces variables doivent être impérativement assignées avant leur emploi dans la classe locale.

class ClasseExterne {
  int x = 10;
  int y = 12;
  // Paramètre constant utilisable par la classe locale
  ClasseExterne(final int p){
    // Constante utilisable par la classe locale
    final int a = 20;
    // Variable inutilisable par la classe locale
    int b = 44;
    class ClasseLocale {
      boolean verification(){
        if(x + y == a + p)
          return true;
        else
          return false;
      }
    }

    ClasseLocale obj_in = new ClasseLocale();
      if(obj_in.verification()){
        x = x + y;
        System.out.println("La classe interne a bien accédé aux "
                          + "membres de la classe extérieure.n"
                          + "x = " + x + "ny = " + y + "na = " + a);
      }
      else 
        System.out.println("Erreur !");
  }
  public static void main(String[] args){
    ClasseExterne obj_out = new ClasseExterne(2);
  }
}

Lorsqu'une classe locale est déclarée dans une méthode statique, alors les variables d'instances de la classe externe ne sont plus accessibles pour la classe imbriquée.

class ClasseExterne {
  static int x = 10;
  static int y = 12;
  static int z = x + y;
  static void addition(){
    class ClasseLocale {
      boolean verification(){
        if(x + y == z)
          return true;
        else
          return false;
      }
    }

    ClasseLocale obj_in = new ClasseLocale();
    if(obj_in.verification()){
      x = x + y;
      System.out.println("La classe interne a bien accédé aux "
                          + "membres statiques de la classe extérieure.n"
                          + "x = " + x + "ny = " + y + "nz = " + z);
     }
     else 
       System.out.println("Erreur !");

    }
    public static void main(String[] args){
    addition();
  }
}

Seules, les variables statiques de la classe externe peuvent être exploitées par la classe localisée dans la méthode statique.

L'utilisation d'une classe locale ne dépend pas de l'instanciation d'une classe externe, contrairement aux classes internes simples. Autrement dit, il n'est donc pas utile d'instancier d'abord la classe externe pour instancier ensuite la classe locale.

Les classes anonymes (anonymous classes) sont déclarées immédiatement après l'expression d'instanciation d'une classe, permettant directement d'étendre ou d'implémenter respectivement la classe ou l'interface instanciée.

new Classe([Liste d'arguments]) {
  // Instructions de la classe anonyme...
};

new Interface() {
  // Instructions de la classe anonyme...
};

La déclaration d'une classe anonyme doit être toujours suivie d'un point virgule immédiatement après son accolade fermante, sans quoi une erreur de compilation serait générée.

Les classes anonymes obéissent aux mêmes restrictions que les classes locales et de plus, ne peuvent ni être abstraites (abstract) ni être statiques (static).
Par contre, elles portent toujours implicitement le modificateur final.

En fait, aucun modificateur n'est permis dans une déclaration de classe anonyme.

Dans le cas d'une extension, la classe anonyme doit outrepasser une à plusieurs des méthodes de la classe à instancier. La surcharge et la définition d'une nouvelle méthode ne sont pas permis sinon elles provoqueraient une erreur de compilation.

class ClasseExterne {
  static int x = 10;
  static int y = 12;
  public static void main(String[] args){
    Calcul obj = new Calcul() {
      float resultat;
      public float addition(float a, float b) {
        resultat =  a + b;
        System.out.println(resultat);
        return resultat;
      }
      public float soustraction(float a, float b) {
        resultat =  a - b;
        System.out.println(resultat);
        return resultat;
      }
      public float multiplication(float a, float b) {
        resultat =  a * b;
        System.out.println(resultat);
        return resultat;
      }
      public float division(float a, float b) {
        if(b != 0){
        resultat =  a / b;
        System.out.println(resultat);
        return resultat;
        }
        else
        return 0;
      }
    };
    obj.addition(x, y);
    obj.soustraction(x, y);
    obj.multiplication(x, y);
    obj.division(x, y);
  }
}

class Calcul {
  public float addition(float a, float b) {
    return a + b;
  }
  public float soustraction(float a, float b) {
    return a - b;
  }
  public float multiplication(float a, float b) {
    return a * b;
  }
  public float division(float a, float b) {
    return a / b;
  }
}

Dans le cas d'une implémentation, la classe anonyme doit définir chacune des méthodes abstraites de l'interface à instancier, sinon une erreur de compilation se produira.

class ClasseExterne {
  static int x = 10;
  static int y = 12;

  public static void main(String[] args){

    ICalcul obj = new ICalcul() {
      public float addition() {
        resultat = (float)(x + y);
        return (float)(x + y);
      }
      public float soustraction() {
        resultat (float)(x - y);
        System.out.println(resultat);
        return resultat;
      }
      public float multiplication() {
        resultat (float)x * (float)y;
        System.out.println(resultat);
        return resultat;
      }
      public float division() {
        if(y != 0){
          resultat = (float)x / (float)y;
          System.out.println(resultat);
          return resultat;
        }
        else
          return 0;
      }
    };

    obj.addition();
    obj.soustraction();
    obj.multiplication();
    obj.division();
  }
}

interface ICalcul {
  float addition();
  float soustraction();
  float multiplication();
  float division();
}

Une classe anonyme ne peut déclarer explicitement un constructeur, le compilateur Java fournissant automatiquement un constructeur anonyme pour ce genre de classe.

Une classe anonyme ne possède pas d'identificateur et est immédiatement utilisée lors de l'instanciation de la classe ou l'interface concernée.

Un paquetage (package) définit un espace de noms pour un groupe de classes le rendant unique par rapport à d'autres.

De même, il existe une hiérarchie de paquetages, java étant la principale, d'où descendent de nombreuses autres tels que awt, lang et rmi, contenant eux mêmes respectivement color, ref et server.

java
java.awt
java.awt.color
java.lang 
java.lang.ref
java.rmi
Java.rmi.server

Les différents composants d'une arborescence de paquetages sont séparés par un point.

A partir de chacun de ces espaces de noms, il est possible d'appeler les classes correspondantes.

java.awt.colorColorSpace
java.lang.ref.WeakReference
java.rmi.Naming

Les paquetages peuvent être importés et créés à l'aide d'instructions spécifiques, respectivement import et package.

L'instruction import permet d'importer une à plusieurs classes et interfaces d'un paquetage pour la classe courante.
Pour cela, il suffit de placer cette instruction au début du fichier source contenant la classe.

import NomClasse;
import java.nomPaquetage[.sousPaquetage].NomClasse;

import java.awt.image.ImageFilter;
// Importation de la classe imageFilter

Une étoile (*) placée dans la déclaration permet d'indiquer que toutes les classes et interfaces d'un paquetage sont mises à disposition de la classe en cours.

import java.awt.image.*;
// Fournit toutes les classes pour la création
 
// et la modifications des images.

Il faut importer explicitement les classes de chaque paquetage pour les besoins d'un fichier source courant, puisque l'étoile ne s'adresse qu'à des classes et non aux sous-paquetages.

import java.awt.*;
// Importe seulement les classes et interfaces du
 
// paquetage awt et non les autres sous-paquetages.
import java.awt.color.*;
import java.awt.font.*;
import java.awt.print.*;
// Importation explicite des classes et interfaces

// de trois paquetages descendants d'awt.

Par ailleurs, il est également possible de définir son propre paquetage en utilisant l'instruction package. La déclaration d'un paquetage personnalisé se place au tout début d'un fichier source avant les éventuelles instructions d'importation.

package nomPaquetage;

Si cette déclaration est omise, pendant le temps d'exécution, Java crée implicitement un paquetage sans nom par défaut contenant toutes les classes se trouvant dans le répertoire en cours, y compris des classes n'appartenant pas forcément à ce paquetage courant.

Le fait de mentionner un nom de paquetage permettra de créer automatiquement un répertoire portant le nom du paquetage, dans lequel le fichier .class, résultant de la compilation du fichier source (fichier.java), sera placé.

// Compilation
c:\>javac -d c:\classes c:\sources\fichier.java

// Résultat
c:\classes\paquetage\fichier.class

La classe Package représente un paquetage Java contenant un ensemble d'interfaces, de classes et d'exceptions.

Elle ne possède pas de constructeurs, mais peut être instanciée par l'intermédiaire de la méthode statique getPackage().

Package paquetage = Package.getPackage("javax.xml.parsers");

Une autre méthode dénommée getPackages() retourne tous les paquetages connus du chargeur de classe en cours, dans un tableau d'objets de type Package.

public class Paquetage {
  public static void main(String[] args) {
    Package[] paquetages = Package.getPackages();
    for(int i = 0; i < paquetages.length; i++){
      System.out.println("Le paquetage " + paquetages[i].getName());
    }
  }
}

Un objet Class dispose également d'une méthode permettant de renvoyer son propre paquetage d'appartenance, à partir de sa méthode d'instance getPackage()

Class obj = Class.forName("java.util.jar");
Package paquetage = obj.getPackage();

La classe Package est essentiellement composer de méthodes retournant des informations sur lui-même (get), et vérifiant des caractéristiques spécifiques (is).

Plusieurs informations relatives à l'implémentation et la spécification du paquetage, peuvent être obtenues sous la forme d'une chaîne de caractères, par les méthodes suivantes :

public class Paquetage {
    public static void main(String[] args) {
      if (args.length > 0){
        Package paquetage = Package.getPackage(args[0]);
        System.out.println(paquetage);
        if(paquetage != null){
          System.out.println("Distributeur implementation : " 
                                      + paquetage.getImplementationTitle());
          System.out.println("Version implementation : " 
                                      + paquetage.getImplementationVendor());
          System.out.println("Titre implementation : " 
                                      + paquetage.getImplementationVersion());
          System.out.println("Titre specification : " 
                                      + paquetage.getSpecificationTitle());
          System.out.println("Distributeur specification : " 
                                      + paquetage.getSpecificationVendor());
          System.out.println("Version specification : " 
                                      + paquetage.getSpecificationVersion());
        }
      }
    }
}

La méthode isCompatibleWith() permet de déterminer si la paquetage en cours est compatible avec le numéro de version de spécification spécifié en argument. Le numéro de version est composé de chiffres entiers séparés par des points ("."), comme par exemple 2.0 ou 1.3.6.

if (isCompatibleWith("2.5.1")){
    //Instructions...
}

Les méthodes isSealed() vérifient si le paquetage courant est scellé. En effet, les fichiers JAR et les paquetages peuvent être optionnellement scellés, de telle sorte qu'un paquetage puisse imposer une uniformité au sein d'une version. Un paquetage scellé dans un fichier JAR indique que toutes les classes définies dans ce paquetage doivent provenir du même fichier JAR. Dans le cas contraire, une exception SecurityException serait lancée.

if (paquetage.isSealed()){
    //Instructions...
}

Les paquetages (packages) Java contiennent un ensemble de classes possédant un rapport entre elles et chargées d'accomplir des opérations prédéfinies.

Par exemple, le paquetage java.awt propose de nombreuses classes destinées à élaborer des interfaces graphiques.

Il existe trois types de problèmes générateur d'erreurs dans le langage Java.

• Les problèmes de compilation.
• Les problèmes d'interprétation.
• Les problèmes relatifs aux applets.

Les problèmes de compilation se produisent lorsque le code source d'un programme Java est compilé.

Sous Unix, la première erreur javac: Command not found peut intervenir si la variable d'environnement PATH ne spécifie pas le chemin correct vers le compilateur Java. Dans ce cas, il suffit de modifier ce chemin par la commande setenv.

Les erreurs de syntaxe sont souvent dues à des fautes d'inattention ou de vocabulaire comme l'oubli d'un point-virgule à la fin d'une instruction ou la mauvaise orthographe d'une commande.

Les erreurs de sémantique sont provoquées par des irrégularités dans l'utilisation d'éléments d'un programme Java, tel qu'une variable non-initialisée.

Les problèmes d'interprétation se produisent lorsqu'un programme est soumis à l'interpréteur java.

Si une tentative d'interprétation d'un fichier .class est effectuée, l'interpréteur renverra une erreur indiquant qu'il ne peut trouver la classe appropriée.

Si la méthode main n'est pas présente dans une classe et que cette dernière est exécutée, une erreur sera lancée spécifiant que la méthode main n'est pas définie.

D'autres problèmes peuvent survenir lors de l'utilisation des appliquettes Java dans des pages HTML.

Plusieurs erreurs peuvent intervenir à cause d'une écriture incorrecte du balisage applet dans une page HTML, de difficultés à recharger une appliquette par l'afficheur Java du navigateur, de dysfonctionnement de l'applet sur le serveur HTTP, etc..

Les exceptions se produisent lorsque des situations anormales surviennent durant l'exécution d'un programme Java.

Les exceptions représentent un moyen efficace de détecter des problèmes éventuels dans une application Java.

Plus un compilateur Java sera sévère dans l'analyse d'un programme, c'est-à-dire dans sa capacité à générer des avertissements et des alertes, plus la fiabilité de l'application sera meilleure.

En Java, il existe deux classes intéressantes dérivées de la classe Throwable :

• la classe Error, d'où proviennent les erreurs système souvent irrécupérables représentées par les classes suivantes :
  • VirtualMachineError : indique de graves problèmes sur la machine virtuelle Java,
  • AWTError : indique une sérieuse erreur du système de gestion de l'interface utilisateur AWT (Abstract Window Toolkit),
  • ThreadDeath : indique l'arrêt inopportun d'un Thread,
  • LinkageError : indique des problèmes de liaisons entre des classes.
  Les exceptions provenant de la classe Error dépassent souvent le domaine de compétence d'un programmeur. Toutefois, certaines peuvent être gérées, à l'image d'une erreur du type OutOfMemoryError (plus de mémoire).
  
  
• la classe Exception, d'où sont issues les fameuses exceptions déclenchées par le compilateur.

Les exceptions sont donc de véritables objets créés suite à la détection d'une anomalie dans le déroulement du programme.

Contrairement à celles de la classe Error, les exceptions de la classe Exception peuvent et dans la plupart des cas, doivent être interceptées.

Il n'est pas nécessaire de gérer les exceptions de la classe RuntimeException. Ces dernières avec celles de la classe Error et de leurs sous-classes sont d'ailleurs communément appelées les exceptions non-contrôlées (unchecked).

En ce qui concerne toutes les autres, c'est-à-dire les exceptions contrôlées, il est impératif d'inclure un dispositif d'interception et de gestion, sans lequel Java ne pourra mener à son terme la compilation d'un programme.

Toutes les méthodes susceptibles de générer une exception doivent soit être comprises dans un bloc try, soit signaler au moyen de la commande throws cette particularité.

Si les exceptions contrôlées ne seraient pas interceptées, leur thread d'exécution s'interrromprait et la console Java afficherait un message d'erreur.

Le langage de programmation Java fournit un mécanisme permettant de gérer les exceptions lancées par le programme.

Lorsqu'une exception se produit, le traitement normal du programme s'interrompt et l'environnement d'exécution tente de trouver le gestionnaire d'exception chargé de gérer le type d'erreur en cours.

Le gestionnaire d'exception peut tenter de récupérer l'erreur si cela est possible, sinon il essayera de provoquer une sortie correcte du programme.

try{
  // Instructions...
}
catch (type_exception1 nom){
  // Instructions de traitement d'exception
}
...
catch (type_exceptionN nom){
  // Instructions de traitement d'exception
}
finally{
  // Instructions de fin...
}

L'instruction try contient un bloc d'instructions à l'intérieur duquel une exception pourrait se produire.

L'instruction catch doit être associée à try et contient un bloc d'instructions susceptible de gérer un type d'exception particulier.

L'instruction finally facultative, doit être associée à try et placée après catch. Elle contient un bloc d'instructions qui est exécuté dans tous les cas de figure.

Il est possible d'utiliser plusieurs instructions catch afin de capturer des exceptions de types différents.

Cette succession de blocs catch doit correspondre à un ordre précis afin de correspondre à la hiérarchie inverse des classes d'exception.

Ainsi, les types d'exception risquant de se produire dans les sous-classes inférieures d'une hiérarchie devront être traités en premier, suivi de ceux des classes supérieures.

Si une exception se produit dans le bloc try, alors la machine virtuelle Java recherchera le bloc catch le plus approprié à l'exception en cours.

try {
  // Bloc d'instructions...
}
catch (FileNotFoundException e) {
  // Gestion des exceptions de fichier non trouvé
}
catch (IOException e) {
  // Gestion des exceptions d'entrée/sortie
}
catch (Exception e) {
  // Gestion des exceptions
}

Par exemple, si une exception du type FileNotFoundException se produit dans le bloc try, le bloc catch (FileNotFoundException e) intercepterait et gérerait l'exception en cours.
Si une exception du type EOFException se produit, alors ce serait au tour du bloc catch (IOException e) de traiter cette exception puisqu'elle est provient d'une sous-classe de IOException.
Enfin, si une exception du type BadLocationException se produit, alors le dernier bloc catch prendrait en compte cette exception car celle-ci descend de la classe Exception.

Les instructions try... catch peuvent être imbriquées les unes dans les autres.

try {
  // Bloc try 1
  ...
  try {
  // Bloc try 2
  ...
  }
  catch (TypeException e) {
  ...
  }
  ...
}
catch (TypeException e) {
  ...
}

Dans ce cas, si une exception est lancée dans le second bloc try terminant de fait son exécution, son bloc catch est vérifié pour une éventuelle interception. S'il n'est pas en mesure de gérer l'exception, alors cette dernière est propagée dans le premier bloc try qui ensuite transmet l'exception à son bloc catch.

Le langage de programmation Java fournit un mécanisme permettant de gérer les exceptions lancées par le programme.

Lorsqu'une exception se produit, le traitement normal du programme s'interrompt et l'environnement d'exécution tente de trouver le gestionnaire d'exception chargé de gérer le type d'erreur en cours.

Le gestionnaire d'exception peut tenter de récupérer l'erreur si cela est possible, sinon il essayera de provoquer une sortie correcte du programme.

try{
  // Instructions...
}
catch (type_exception1 nom){
  // Instructions de traitement d'exception
}
...
catch (type_exceptionN nom){
  // Instructions de traitement d'exception
}
finally{
  // Instructions de fin...
}

public class RacineCarre {
  static public void main(String[] args) {
    int dividende = 9;
    int diviseur = 0;

    try {
      System.out.println("La division de " + dividende "/" + diviseur 
                          + " est égale à " + dividende/diviseur);
    }
    catch(ArithmeticException e) {
      System.out.println("Une exception s'est produite !rn" 
                                     + e.getMessage());
      System.out.println("rnAffichage de la pile :rn");
      e.printStackTrace();
    }
    finally {
      System.out.println("Je vous remercie d'avoir essayé !")); 
    }
  }
}

L'instruction try contient un bloc d'instructions à l'intérieur duquel une exception pourrait se produire.

L'instruction catch doit être associée à try et contient un bloc d'instructions susceptible de gérer un type d'exception particulier.

L'instruction finally facultative, doit être associée à try et placée après catch. Elle contient un bloc d'instructions qui est exécuté dans tous les cas de figure.

Il est possible d'utiliser plusieurs instructions catch afin de capturer des exceptions de types différents.

Cette succession de blocs catch doit correspondre à un ordre précis afin de correspondre à la hiérarchie inverse des classes d'exception.

Ainsi, les types d'exception risquant de se produire dans les sous-classes inférieures d'une hiérarchie devront être traités en premier, suivi de ceux des classes supérieures.

Si une exception se produit dans le bloc try, alors la machine virtuelle Java recherchera le bloc catch le plus approprié à l'exception en cours.

try {
  // Bloc d'instructions...
}
catch (FileNotFoundException e) {
  // Gestion des exceptions de fichier non trouvé
}
catch (IOException e) {
  // Gestion des exceptions d'entrée/sortie
}
catch (Exception e) {
  // Gestion des exceptions
}

Par exemple, si une exception du type FileNotFoundException se produit dans le bloc try, le bloc catch (FileNotFoundException e) intercepterait et gérerait l'exception en cours.
Si une exception du type EOFException se produit, alors ce serait au tour du bloc catch (IOException e) de traiter cette exception puisqu'elle est provient d'une sous-classe de IOException.
Enfin, si une exception du type BadLocationException se produit, alors le dernier bloc catch prendrait en compte cette exception car celle-ci descend de la classe Exception.

Les instructions try... catch peuvent être imbriquées les unes dans les autres.

try {
  // Bloc try 1
  ...
  try {
    // Bloc try 2
    ...
  }
  catch (TypeException e) {
    ...
  }
  ...
}
catch (TypeException e) {
  ...
}

Dans ce cas, si une exception est lancée dans le second bloc try terminant de fait son exécution, son bloc catch est vérifié pour une éventuelle interception. S'il n'est pas en mesure de gérer l'exception, alors cette dernière est propagée dans le premier bloc try qui ensuite transmet l'exception à son bloc catch.

L'omission du bloc catch est permise dans la mesure où le bloc try est suivi d'un bloc finally, mais les exceptions doivent être déclarées à partir de la méthode en cours.

Plusieurs méthodes des classes d'exceptions permettent de retourner des informations relatives à l'erreur en cours. Il s'agît de :

• getMessage() : retourne une chaîne de caractères représentant le message relatif à l'exception,
• toString() : retourne une courte description de l'exception. Si cette dernière a été créée avec un message d'erreur, le résultat serait la concaténation du nom de la classe, d'un deux-points suivi d'un espace et d'une chaîne de caractères provenant de getMessage(),
• printStackTrace() : retourne la trace de la pile au flux de sortie standard qui est la valeur du champ System.err. La première ligne de sortie contient le résultat produit par toString(). Les autres lignes représente les données au préalable enrgistrées par la méthode fillInStackTrace().
• fillInStackTrace() : Fills in the execution stack trace. This method enregistre les informations de l'exception courant à propos de l'état courant des piles pour le thread courant.

import java.io.*;

public class Ecrire {
  public static void main(String[] args) {
    try {
      FileWriter sortie = new FileWriter("titre");
      sortie.write("Un texte...");
      sortie.flush();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }
}

La génération d'une exception s'effectue par l'instanciation de la classe Exception ou de l'une de ses nombreuses dérivées et par l'utilisation du mot clé throw.

throw new ConstructeurClasseException();

// déclenchement d'une exception
throw new Exception();

// déclenchement d'une exception DataFormatException

// descendant de la classe Exception;
throw new DataFormatException("Mauvais format de données !");

// propagation d'une exception en cours
throw e;

L'expression new ConstructeurClasseException() permet d'allouer et d'initialiser un objet de la classe d'exception appropriée qui est ensuite lancé par throw.

Toutes les classes d'exception descendant de la classe Throwable, n'importe quel type d'exception (sous-classe Exception) et d'erreur (sous-classe Error) peut être lancé par la commande throw.
Néanmoins, il est préférable de se contenter des seules exceptions contrôlées.

En outre, une exception peut être déclenchée n'importe où dans une méthode.

Cependant, le déclenchement d'une exception dans une méthode nécessite de le signaler par l'intermédiaire du mot clé throws dans la déclaration de méthode, ou d'englober la méthode dans un bloc try.

Dans la déclaration d'une méthode methode, le mot clé throws permet de signaler le ou les exceptions qu'elle sera susceptible de lancer.

public int uneMethode() throws ClasseException {
  ...
}

La signalisation des exceptions est une obligation si :

• une méthode contient une ou plusieurs instructions throw chargées de déclencher des exceptions,
• la méthode ne dispose pas d'un mécanisme d'interception suffisant pour les capturer toutes.

Dans le cas des exceptions de types RuntimeException, Error et toutes leurs descendances, il n'est pas nécessaire de signaler le risque de génération d'exception.

La déclaration de signalisation d'une exception permet de construire des applications sûres où toutes les exceptions nécessitant un traitement particulier, seront soit gérées, soit intentionnellement ignorées lors du développement d'un programme java.

Les exceptions susceptibles de se produire par des méthodes appelées à partir d'une autre méthode doivent être impérativement signalées dans cette dernière, si aucune signalisation (throws) ou aucun mécanisme d'interception (try...catch) n'a été conçu dans les méthodes appelées.

Si l'on désire créer une nouvelle sorte d'exception, il suffit de faire hériter une nouvelle classe de la classe Exception, puis de définir cette exception personnalisée.

class MonException extends Exception {
  // Définition de mon exception...
  public MonException(String message) {
    super(message);
    ...
  }
  public String toString() {
    return "Un message";
    ...
  }
}

class EgalZeroException extends Exception {
  public String toString() {
    return "Le côté d'un triangle rectangle "
             + "ne peut être égal à zéro !";
  }
}

public class Hypothenuse {
  double BC;
  static void calculHypothenuse(double AB, double AC)
             throws EgalZeroException {
    if ((AB == 0) && (AC == 0))
      throw new EgalZeroException();
    else {
      BC = sqrt(power(AB, 2) + power(AC, 2));
      System.out.println("AB = " + AB + "rnAC = " 
                         + AC + "rn BC" + " BC");
  }

  public static void main(String[] args) {
    try {
      System.out.println(calculHypothenuse(15, 20.9));
    }
    catch (EgalZeroException e) {
      System.out.println ("Erreur " + e);
    }
  }
}

Le système de Garbage Collector (GC, littéralement ramasseur de déchets) permet de gérer automatiquement les ressources utilisées par les objets d'une application Java.

Le processus de GC détermine les objets inutilisés par un programme, pour ensuite les traiter de sorte à récupérer leur espace mémoire pour une éventuelle réutilisation.

Toutefois, il n'existe aucun moyen de contraindre le GC à accomplir un nettoyage de la mémoire à la demande.
Le processus de Garbage Collector n'est absolument pas déterminable.

En outre, le système GC n'assure en aucune façon que le programme ne devra pas à un moment donné faire face à une carence de ressources mémoires (out of memory).

Java s'occupe de la gestion automatique de l'allocation dynamique de la mémoire. Une zone mémoire est dynamiquement allouée à un objet lors de sa création.

Classe Variable_objet = new Classe();
//Variable_objet représente une référence 
//de l'instance de classe new Classe()

Lorsque cette zone mémoire n'est plus référencée par un objet du programme, elle est automatiquement libérée par le GC.

Variable_objet = null;
//Variable_objet ne référence 
//plus d'instance de classe

Plusieurs objets distincts d'un programme occupent un espace mémoire plus ou moins important sur un système informatique, en sachant que les ressources mémoires sont certainement limitées.
Un usage incontrôlé de la mémoire risque à terme de provoquer des conflits de ressources tels que :

• une libération intempestive d'une zone allouée (donc utilisée par un objet),
• une indisponibilité d'une zone désallouée (donc libérée par un objet).

Le système GC interdit l'utilisation d'une ressource déjà utilisée et évite dans la mesure du possible, les pertes de mémoires.

En outre, il existe deux types de perte de mémoire :

• les hard leaks (fuites mémoires graves) sont provoquées lorsqu'il n'existe pas de système de nettoyage, et partant, aucun référencement des zones mémoires inutilisées qui n'ont pu être libérées,
• les soft leaks (fuites mémoires légères) surviennent lorsqu'un programme possède des zones mémoires devenues inutilisables car elles n'ont pu être libérées correctement et deviennent, ainsi, irrécupérables pour le programme.

En ce qui concerne les fuites de mémoires légères (soft leaks), il suffit d'affecter la valeur null aux objets qui ne seront plus utilisés par le programme. Ensuite, le système GC détruira les références et libérera les ressources pour une utilisation ultérieure.

import java.io.*;
public class Execution {
  public static void main(String argv[]) {
    new Execution("fichier.bat");
  }

  public Execution(String commande) {
    try {
      String ligne;
      Process processus = Runtime.getRuntime().exec(commande);
      InputStreamReader flux_entree = 
                    new InputStreamReader(processus.getInputStream())
      BufferedReader entree = new BufferedReader();
      while ((ligne = entree.readLine()) != null) {
        System.out.println(ligne);
      }
      ligne = null;
      processus = null;
      flux_entree = null;
      entree = null;
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
}

fichier.bat
echo "Bonjour à tous et à toutes !"

Le système de Garbage Collector agît essentiellement sur les fuites mémoires graves (hard leaks) en s'occupant de :

1. la surveillance de l'utilisation des objets,
2. la détermination des objets devenus inutiles,
3. l'information des objets sur leur inutilisation,
4. la destruction des objets inutiles,
5. la récupération des ressources libérées.

La Machine Virtuelle Java (JVM) comptabilise en permanence le nombre de références désignant chaque objet d'un programme. Ainsi, lorsque le nombre de références est égal à zéro, cela signifie que l'objet n'est plus utilisé et par conséquent, que sa zone mémoire doit être libérée.

Le système de Garbage Collector accomplit ses opérations en tâche de fond à partir d'un thread indépendant de faible priorité et en exécution asynchrone.

Le GC conserve la trace de chacun des objets créés et utilisés dans un programme. Que les objets soient accessibles ou inaccessibles, le GC les prend tous en compte.

Lorsqu'une instance de classe en mémoire ne possède plus de lien avec le programme, c'est-à-dire, que plus aucune variable ne référence cet objet, alors ce dernier est jugé inutile. Devenu inaccessible, l'objet peut alors être soumis au traitement du GC, en l'occurrence,il appele, si elle existe, la méthode finalize() de l'objet en question pour accomplir un traitement de finalisation, puis s'il y a lieu opére sa destruction et récupère sa zone mémoire.

Cependant, le processus de Garbage Collector est indéterminable.
Il n'est absolument pas garanti sur tous les objets déréférencés, car le programme peut se terminer avant que le traitement n'ait même commencé.
En effet, étant donné la nature du mode d'exécution du système GC (thread indépendant et exécution asynchrone), il est impossible de prévoir quand le GC s'exécutera, et encore moins, quels objets inaccessibles il traitera.

public class GarbageCollector {
  ProcessusGarbage pG;
  int max;

  public static void main(String[] args) {
    int nb = 275;
    if(args.length > 0)
      nb = (new Integer(args[0])).intValue();
    GarbageCollector oGC = new GarbageCollector(n);
    oGC.executer();
  }

  public GarbageCollector(int nb) {
    max = nb;
  }

  void executer() {
    for(int i = 1; i < max; i++)
      pG = new ProcessusGarbage(i);
  }
}

class ProcessusGarbage {
  double[] tableau;
  int num_objet;

  public ProcessusGarbage(int nb) {
    num_objet = nb;
    tableau = new double[n];
    tableau[0] = 0;
    for(int i = 1; i < n; i++)
      tableau[i] = Math.pow(tableau[i - 1], 1.7E+308);
  }

  protected void finalize() {
    System.out.println("L'objet num" + num_objet 
                      + " a ete traite par le Garbage Collector.");
  }
}

Dans cet exemple, on pourra remarquer que tous les objets créés devenus inaccessibles ne sont pas traités par le GC.

La méthode finalize() est automatiquement appelée lorsque le système GC a déterminé qu'un objet est devenu inaccessible. C'est pourquoi, dans l'exemple précédent, une information à propos du traitement de l'objet a pu être affichée.

La méthode finalize() définie dans la classe Java.lang.Object, permet d'effectuer des opérations de finalisation en général une opération de nettoyage d'un objet avant que le système de Garbage Collector ne s'en charge ou que ce dernier ne peut accomplir, comme dans le cas d'un objet de système de fichier, ou encore de connexion réseau.

protected void finalize() throws Throwable

La méthode finalize() est automatiquement appelée par un thread spécialisé (Finalizer), si elle existe dans la classe de l'objet, avant que le collecteur de déchets n'entreprenne le recyclage de ce dernier.

Un objet déréférencé peut par l'intermédiaire de la méthode de finalisation redevenir atteignable, c'est-à-dire retrouver une référence dans le programme.

Subséquemment, le GC vérifie à nouveau l'accessibilité de l'objet par le programme et si celui-ci possède effectivement, une nouvelle référence, alors il abandonne le processus de récupération des ressources pour l'objet en cours.

La méthode finalize() n'est jamais appelée plus d'une fois pour un objet donné.

La méthode System.runFinalization() lance la méthode finalize() de n'importe quel objet inatteignable avant que le processus de Garbage Collector ne commence.

public static void runFinalization()

System.runFinalization();

Runtime.getRuntime().runFinalization();
//Equivalent à System.runFinalization();

L'appel de cette méthode incite la Machine Virtuelle Java (JVM) à effectuer des tentatives d'exécution des méthodes finalize() des objets qui ont été trouvés pour leur inaccessibilité, mais dont les méthodes de finalisation n'ont pas encore été lancées.

public class CollecteurDechets extends Thread {
  public CollecteurDechets() {
    super();
  }
  public void run() {
    long i = 0;
    while (true) {
      if (verifierPremier(i)) {
        NombrePremier objet = new NombrePremier(
                                       String.valueOf(i));
        if(i > Short.MAX_VALUE)
          break;
      }
      i++;
    }
  }
  public boolean verifierPremier(long nombre) {
    if (nombre < 0) {
      return false;
    }
    else if (nombre < 4) {
      return true;
    }
    else {
      for (int i = 4; i <= nombre / 2; i++) {
        if (nombre != i && nombre % i == 0) {
          return false;
        }
      }
    }
    return true;
  }

  public static void main(String[] args) {
    CollecteurDechets thread = new CollecteurDechets();
    thread.start();
    while (thread.isAlive()) {
      try {
        Thread.sleep(500);
      }
      catch (InterruptedException e) {
      }
    }
  }
}

public class NombrePremier {
  private String valeur;
  public NombrePremier(String valeur) {
    this.valeur = valeur;
  }
  public String getValeur() {
    return this.valeur;
  }
  public void setValeur(String valeur) {
    this.valeur = valeur;
  }
  protected void finalize() throws Throwable {
    System.out.println("Invocation de la méthode finalize()");
    System.out.println("Contenu de l'objet : " + valeur);
    System.out.println("Nom du thread courant : "
                       + Thread.currentThread().getName());
    this.valeur = null;
  }
}
/* Affiche
...
Invocation de la méthode finalize()
Contenu de l'objet : 34807
Finalizer
Invocation de la méthode finalize()
Contenu de l'objet : 34781
Finalizer
Invocation de la méthode finalize()
Contenu de l'objet : 34763
Finalizer
...
*/

Les méthodes Runtime.gc() et System.gc() définies dans la classe java.lang, permettent de suggérer l'exécution du nettoyage de la mémoire par le système de Garbage Collector.

public static void gc()
Runtime.gc();
System.gc();
Runtime.getRuntime().gc();
// Equivalent à System.gc();

L'appel de l'une de ces méthodes incite la Machine Virtuelle Java (JVM) à effectuer des tentatives de recyclage d'objets inutilisés afin de récupérer leurs zones mémoires de sorte à les rendre disponible pour une réutilisation ultérieure et rapide.

La JVM exécute le processus de recyclage automatiquement si nécessaire, dans un thread séparé, même si la méthode gc() n'a pas été invoquée explicitement.

Les méthodes Runtime.gc() et System.gc() ne garantissent pas l'exécution du recyclage de la mémoire, mais seulement qu'il sera probable.

Deux méthodes totalMemory et freeMemory permettent de connaître la quantité de mémoire disponible sur le système informatique, où est installé la Machine Virtuelle Java (JVM).

La méthode Runtime.totalMemory() retourne la taille totale de la mémoire dont dispose la Machine Virtuelle Java.

public long totalMemory()

long taille = Runtime.getRuntime().totalMemory();

La valeur de cette méthode peut varier en fonction de l'environnement hôte.

La méthode Runtime.freeMemory() retourne la quantité de mémoire libre du système.

public long freeMemory()

long taille = Runtime.getRuntime().freeMemory();

L'appel de la méthode gc() pour le nettoyage de la mémoire, peut entrainer une augmentation de la valeur retournée par freeMemory().

Le nombre retourné par totalMemory() ou freeMemory(), mesurant la quantité de mémoire disponible, est exprimé en octets (bytes). Son type est un entier long.

public class Memoire {
    public static void main(String[] args){
      System.out.print("Mémoire totale : ");
      System.out.print(Runtime.getRuntime().totalMemory() / 1000000d);
      System.out.println("Mo.");
      System.out.print("Mémoire disponible : ");
      System.out.print(Runtime.getRuntime().freeMemory() / 1000000d);
      System.out.println("Mo.");

      System.out.println("Manipulation d'un objet String");
      String chaine = new String("La chaîne n°0");
      for(int i = 1; i <= 1000; i++){
        chaine = chaine.replaceAll(String.valueOf(i -1), String.valueOf(i));
        if(i % 100 == 0) {
            System.out.print(chaine);
            System.out.print(" - Mémoire consommée : ");
            System.out.print((Runtime.getRuntime().totalMemory() 
                                - Runtime.getRuntime().freeMemory())/1000d);
            System.out.println("ko.");
        }
      }
      System.out.println("Manipulation d'un objet StringBuffer");
      StringBuffer chaine2 = new StringBuffer("La chaîne n°0.");
      for(int i = 1; i <= 1000; i++){
        String nb = String.valueOf(i - 1); 
        int ind = chaine2.indexOf(nb);
        chaine2.replace(ind, ind + nb.length(), String.valueOf(i));
        if(i % 100 == 0) {
            System.out.print(chaine2);
            System.out.print(" - Mémoire consommée : ");
            System.out.print((Runtime.getRuntime().totalMemory() 
                                - Runtime.getRuntime().freeMemory())/1000d);
            System.out.println("ko.");
        }
      }
      System.out.println();

      System.out.print("Mémoire totale : ");
      System.out.print(Runtime.getRuntime().totalMemory() / 1000000d);
      System.out.println("Mo.");
      System.out.print("Mémoire disponible : ");
      System.out.print(Runtime.getRuntime().freeMemory() / 1000000d);
      System.out.println("Mo.");
    }
  }