2024

Introduction en java
INFO 3 IFT TOAMASINA
JIMMY MENAVOARA
 PLAN DU COURS

Présentation générale du langage java

Les principes de la Poo
Le langage java
Présentation générale du langage java
Introduction
Java est un langage de programmation à usage général, évolué et orienté objet dont la syntaxe
est proche du C. Ses caractéristiques ainsi que la richesse de son écosystème et de sa
communauté lui ont permis d'être très largement utilisé pour le développement d'applications
de types très disparates. Java est notamment largement utilisé pour le développement
d'applications d'entreprises et mobiles.
Quelques chiffres et faits à propos de Java en 2011 :
• 97% des machines d'entreprises ont une JVM installée
• Java est téléchargé plus d’un milliard de fois chaque année
• Il y a plus de 9 millions de développeurs Java dans le monde
• Java est un des langages les plus utilisés dans le monde
• Tous les lecteurs de Blue-Ray utilisent Java
• Plus de 3 milliards d'appareils mobiles peuvent mettre en oeuvre Java
• Plus de 1,4 milliards de cartes à puce utilisant Java sont produites chaque année
En 2020, Java fête ses 25 ans.
Les caractéristiques
Java possède un certain nombre de caractéristiques qui ont largement contribué à son énorme
succès :
Java est interprété
La source est compilée en pseudo code ou bytecode puis exécuté par un interpréteur Java , la
Java Virtual Machine (JVM). Ce concept est à la base du slogan de Sun pour Java :
WORA (Write Once, Run Anywhere : écrire une fois, exécuter partout). En effet, le
bytecode, s'il ne contient pas de code spécifique à une plate-forme particulière peut être
éxécuté et obtenir quasiment les mêmes résultats sur toutes les machines disposant d'une
JVM.
Java est portable : il est indépendant de toute plate-forme

Il n'y a pas de compilation spécifique pour chaque plateforme. Le code reste indépendant de la
machine sur laquelle il s'exécute. Il est possible d'exécuter des programmes Java sur tous les
environnements qui possèdent une Java Virtual Machine.
Cette indépendance est assurée au niveau du code source grâce à Unicode et au niveau du
bytecode.
Java est orienté objet
Comme la plupart des langages récents, Java est orienté objet. Chaque fichier source contient
la définition d'une ou plusieurs classes qui sont utilisées les unes avec les autres pour former
une application. Java n'est pas complètement objet car il définit des types primitifs (entier,
caractère, flottant, booléen,).
Java est simple
Le choix de ses auteurs a été d'abandonner des éléments mal compris ou mal exploités des
autres langages tels que la notion de pointeurs (pour éviter les incidents en manipulant
directement la mémoire), l'héritage multiple et la surcharge des opérateurs, ...
Java est fortement typé
Toutes les variables sont typées et il n'existe pas de conversion automatique qui risquerait une
perte de données. Si une telle conversion doit être réalisée, le développeur doit obligatoirement
utiliser un cast ou une méthode statique fournie en standard pour la réaliser.
Java assure la gestion de la mémoire
L’allocation de la mémoire pour un objet est automatique à sa création et Java récupère
automatiquement la mémoire inutilisée grâce au garbage collector qui restitue les zones de
mémoire laissées libres suite à la destruction des objets.
Java est sûr
La sécurité fait partie intégrante du système d'exécution et du compilateur. Un programme Java
planté ne menace pas le système d'exploitation. Il ne peut pas y avoir d'accès direct à la
mémoire. L'accès au disque dur est réglementé dans une applet. Les applets fonctionnant sur le
Web sont soumises aux restrictions suivantes dans la version 1.0 de Java :
• Aucun programme ne peut ouvrir, lire, écrire ou effacer un fichier sur le
système de l'utilisateur
• Aucun programme ne peut lancer un autre programme sur le système de
l'utilisateur.
• Toute fenêtre créée par le programme est clairement identifiée comme
étant une fenêtre Java, ce qui interdit par exemple la création d'une fausse
fenêtre demandant un mot de passe.
• Les programmes ne peuvent pas se connecter à d'autres sites Web que celui
dont ils proviennent.

Java est économe

Le pseudo code a une taille relativement petite car les bibliothèques de classes requises ne sont
liées qu'à l'exécution.
Java est multitâche
Il permet l'utilisation de threads qui sont des unités d'exécutions isolées. La JVM, elle-même,
utilise plusieurs threads.
Il existe 2 types de programmes avec la version standard de Java : les applets et les applications.
Une application autonome (stand alone program) est une application qui s'exécute sous le
contrôle direct du système d'exploitation. Une applet est une application qui est chargée par un
navigateur et qui est exécutée sous le contrôle d'un plug in de ce dernier.
Les principales différences entre une applet et une application sont : les applets n'ont pas de
méthode main() : la méthode main() est appelée par la machine virtuelle pour exécuter une
application. Les applets ne peuvent pas être testées avec l'interpréteur. Elles doivent être testées
avec l'applet viewer ou doivent être intégrées à une page HTML, elle-même visualisée avec un
navigateur disposant d'un plug in Java.
Les logos de java
Java a connu deux logos au cours de son histoire :

Historique de java
Depuis sa première diffusion publique le 23 mai 1995, le langage et les plateformes Java
ont été marqués par de nombreux événements dont les principaux sont :
Années Evènements

1995 mai : premier lancement commercial du JDK

1.0

1996 janvier : JDK 1.0.1 septembre : lancement du

JDC

1997 Java Card 2.0 février : JDK 1.1

1998 décembre : lancement de J2SE 1.2 et du JCP

Personal Java 1.0

1999 décembre : lancement J2EE 1.2

2000 mai : J2SE 1.3

2001 J2EE 1.3

2002 février : J2SE 1.4

2003 J2EE 1.4

2004 septembre : J2SE 5.0

2005 Lancement du programme Java Champion

2006 mai : Java EE 5 décembre : Java SE 6.0

2007 Duke, la mascotte de Java est sous la licence

Free BSD

2008 décembre : Java FX 1.0

2009 février : JavaFX 1.1 juin : JavaFX 1.2

décembre : Java EE 6

2010 janvier : rachat de Sun Microsystems par

Oracle avril : JavaFX 1.3

2011 juillet : Java SE 7 octobre : JavaFX 2.0

2012 août : JavaFX 2.2

2013 juin : Java EE 7

2014 mars : Java SE 8, JavaFX 8

2017 septembre Java SE 9, Java EE 8

2018 mars : Java SE 10 septembre : Java SE 11

2019 mars : Java SE 12 septembre : Java SE 13,
Jakarta EE 8

2020 mars : Java SE 14 septembre : Java SE 15

décembre : Jakarta EE 9

2021 mars : Java SE 16 mai : Jakarta EE 9.1

septembre : Java SE 17

2022 mars : Java SE 18, Jakarta EE 10 septembre :

Java SE 19

2023 mars : Java SE 20 septembre : Java SE 21

Les principes de la Poo

Objet

• Concept :
Une entité du monde réel (resp. virtuel) qui se caractérise par :
• Identité : propriété qui distingue chaque objet
• Etat : valeur de tous les attributs à un instant donné
• Comportement : caractérisé par les opérations qu’il peut exécuter

• Objet = données + méthodes

• Exemple :
Le point x = 2, y=5 ;
Classe

Concept :
• Abstraction d’un ensemble d’objets qui ont une structure identique et un même
comportement
• Sorte de moule pour créer des objets
• Une classe a un :
o Nom
o Des attributs //partie dynamique
o Des comportements //partie statique
Exemple :
Soit la classe Point qui représente un point. Sa description est comme suit :
• Nom : point
• Attributs : x, y
• Comportements : déplacer, afficher, getX, getY, setX, setY, etc, …
Encapsulation

• Protection d’accès aux données d’un objet. Il est impossible d’agir directement aux
données, il faut passer par les comportements ou méthodes
• Matérialisation à l’aide des modificateurs d’accès
Exemple :
Public class Point{
private int x ;
private int y ;

}
Héritage

• Définition d’une nouvelle classe à partir d’une classe existante

• Utilisation du mot clé « extends »
o class A extends B {…}
o la classe A hérite des membres publics et protégés de B
Héritage possible :
• si la classe B est visible par la classe A
➢ publique ou de même package
➢ si la classe B est non final : non dérivable ( ex : final class B{…} )

Polymorphisme

Méthode qui peut avoir plusieurs formes

Types de polymorphisme :
il y a deux types de polymorphismes :
• Polymorphisme statique :
Surcharge de méthode : même nom mais arguments différents
Détection de la bonne méthode à la compilation
• Polymorphisme dynamique :
Redéfinition de méthode : définition de la méthode de la classe de base dans la classe dérivée
mais avec un corps différent.
Détection de la bonne méthode à la compilation.
Par défaut, toutes méthodes peuvent être redéfinies.
Pour éviter la redéfinition, on utilise le prédicat final.
Virtualité : mauvaise performance
Le langage java

Les règles de base

• Java est sensible à la casse.
• Les blocs de code sont encadrés par des accolades. Chaque instruction se termine par
un point-virgule.
• Une instruction peut tenir sur plusieurs lignes.

Les mots réservés du langage java

Java 9 définit 54 mots réservés qui ne peuvent pas être utilisés comme identifiant.
Historiquement, les mots réservés (reserved words) peuvent être regroupés en deux catégories
:
• 51 mots clés (keywords) dont 3 ne sont pas utilisés
• 3 valeurs littérales (literals) : true, false et null

Les mots clés sont des mots réservés utilisés dans le code source Java en ayant un rôle particulier
dans la syntaxe du code.
Les mots clé const et goto sont réservés mais ne sont pas utilisés actuellement.
A partir de Java 9, le mot-clé _ (le caractère underscore) est non utilisé pour le moment mais il
est réservé pour une éventuelle utilisation future dans les déclarations de certaines variables.
A partir de Java 17, le mot-clé réservé strictfp est obsolète et ne devrait plus être utilisé dans le
code.
Plusieurs séquences sont fréquemment considérées à tort comme des mots clés du langage et
sont en fait des valeurs littérales :
• true et false : sont des valeurs littérales booléennes
• null qui est une valeur littérale
Différents types de mots-clés sont définis dans le langage Java en fonction de la version utilisée
:
• mot-clé réservé depuis Java 1.0
• mot-clé restreint (restricted keyword) à partir de Java 9
• identifiant restreint (restricted identifier) à partir de Java 10
mot-clé contextuel (contextual keyword) qui remplace les notions antérieures d'identifiant
restreint et de mot-clé restreint dans la JLS à partir de Java 17

Le langage Java définit plusieurs mots-clés contextuels (pour certains nommés initialement
mots-clés restreints ou identifiants restreints) depuis Java 9.

Les identifiants

Les identifiants (identifiers) sont utilisés pour nommer des éléments dans du code source Java
notamment les variables, les classes, les méthodes, les paramètres, les packages, les interfaces,
les énumérations, les étiquettes, les modules, ... Les identifiants permettent aux développeurs
d'utiliser un élément ailleurs dans le code.
Dans l'exemple ci-dessus, plusieurs identifiants sont utilisés dans le code source :
• MaClasse : est le nom d'une classe
• main : est le nom d'une méthode
• String : est le nom d'une classe du JDK
• args : est le nom d'un paramètre
• valeur : est le nom d'une variable locale
Les spécifications de Java imposent des règles strictes pour définir un identifiant valide.
Un identifiant est une séquence d'un ou plusieurs caractères (lettres et chiffres) dont le premier
est obligatoirement une lettre.
Exemple d’identifiants valides

_(jusqu’à java a a1 _$ mavariable

8)

MaVariable MAVARIABLE maVariable ma_variable mavariable1

ma1variable mavariable_ _mavariable ma$variable1 _maVariable

$maVariable ma_variable_initialisée

variable_avec_un_nom_tres_long_avec_chaque_mot_separe_par_un_underscore

Exemple d’identifiants invalides

Identifiant invalide Raison pour laquelle il est invalide

1aabbb Commence par un chiffre

aa-bb Contient un caractère moins

aa bb Contient un espace

_ Le caractère underscore est devenu un mot

clé en Java 9

aa*bb Contient un caractère *

()_ Contient des parenthèses

true Est une valeur littérale réservée

new Est un mot clé réservé du langage

aa+bb Contient un caractère +

 aa&bb Contient un caractère &

aa@bb Contient un caractère @

aa#bb Contient un caractère #

Remarque : il est important de prêter une attention particulière lors de l'utilisation d'un
identifiant pour que celui-ci soit suffisamment significatif dans la compréhension de ce qu'il
représente.
Les commentaires

Ils ne sont pas pris en compte par le compilateur donc ils ne sont pas inclus dans le pseudo code.
Ils ne se terminent pas par un caractère " ; ".

Il existe trois types de commentaires en java :

Types de commentaires Exemples

commentaire abrégé // commentaire sur une seule ligne

int N=1; // déclaration du compteur

commentaire multiligne /* commentaires ligne 1

commentaires ligne 2 */

commentaire de documentation automatique /**

* commentaire de la méthode
* @param val la valeur à traiter
* @since 1.0
* @return la valeur de retour
* @deprecated Utiliser la nouvelle méthode
XXX
*/

La déclaration et l’utilisation des variables

Une variable, identifié par un nom, permet d'accéder à une valeur. En Java, une variable est
obligatoirement typée statiquement à sa définition : une fois la variable définie, son type ne
peut pas changer.

La déclaration des variables

Une variable possède un nom, un type et une valeur. La déclaration d'une variable doit donc
contenir deux choses : un nom et le type de données qu'elle peut contenir. Une variable est
utilisable dans le bloc où elle est définie. La déclaration d'une variable permet de réserver la
mémoire pour en stocker la valeur.
Le type d'une variable peut être :
• soit un type élémentaire dit aussi type primitif déclaré sous la forme
type_élémentaire variable;
• soit une classe déclarée sous la forme classe variable ;
Rappel : les noms de variables en Java peuvent commencer par une lettre, par le caractère de
soulignement ou par le signe dollar. Le reste du nom peut comporter des lettres ou des nombres
mais jamais d'espace. Il est possible de définir plusieurs variables de même type en séparant
chacune d'elles par une virgule.

Pour les objets, il est nécessaire en plus de la déclaration de la variable de créer un objet avant
de pouvoir l'utiliser. Il faut réserver de la mémoire pour la création d'un objet ( remarque : un
tableau est un objet en Java ) avec l'instruction new. La libération de la mémoire se fait
automatiquement grâce au garbage collector.

Il est possible en une seule instruction de faire la déclaration et l'affectation d'une valeur à une
variable ou plusieurs variables.

Les types élémentaires

Les types élémentaires ont une taille identique quel que soit la plate-forme d'exécution : c'est
un des éléments qui permet à Java d'être indépendant de la plate-forme sur laquelle le code
s'exécute.
Les types élémentaires commencent tous par une minuscule.

Le format des types élémentaires

Le format des entiers :
Il existe plusieurs formats pour les nombres entiers : les types byte, short, int et long peuvent
être codés en décimal, hexadécimal ou octal. Pour un nombre hexadécimal, il suffit de préfixer
sa valeur par 0x. Pour un nombre octal, le nombre doit commencer par un zéro. Le suffixe l ou
L permet de spécifier que c'est un entier long.
Le format des nombres décimaux :
Il existe plusieurs formats pour les nombres décimaux. Les types float et double stockent des
nombres flottants : pour être reconnus comme tels ils doivent posséder soit un point, un
exposant ou l'un des suffixes f, F, d, D. Il est possible de préciser des nombres qui n'ont pas la
partie entière ou pas de partie décimale.
Le format des caractères :
Un caractère est codé sur 16 bits car il est conforme à la norme Unicode. Il doit être entouré par
des apostrophes. Une valeur de type char peut être considérée comme un entier non négatif de
0 à 65535. Cependant la conversion implicite par affectation n'est pas possible.
Initialisation des variables

En Java, toute variable appartenant à un objet (définie comme étant un attribut de l'objet) est
initialisée avec une valeur par défaut en accord avec son type au moment de la création. Cette
initialisation ne s'applique pas aux variables locales des méthodes de la classe.
Les valeurs par défaut lors de l'initialisation automatique des variables d'instances sont :

Type Valeur par défaut

boolean false

byte, short, int, long 0

float, double 0.0

char \u000

L’affectation

Le signe ( = ) est l'opérateur d'affectation et s'utilise avec une expression de la forme variable =
expression. L'opération d'affectation est associative de droite à gauche : il renvoie la valeur
affectée ce qui permet d'écrire :
x = y = z = 0;
Il existe des opérateurs qui permettent de simplifier l'écriture d'une opération d'affectation
associée à un opérateur mathématique :

Opérateur Exemple Signification

= a = 10 équivalent à : a = 10

+= a += 10 équivalent à : a = a + 10

-= a -= 10 équivalent à : a = a - 10

*= a *= 10 équivalent à : a = a * 10

/= a/=10 équivalent à : a = a / 10
 %= a %= 10 Reste de la division

^= a^=10 équivalent à : a = a ^ 10

<<= a<<=10 équivalent à : a = a << 10 a

est complété par des zéros à
droite

>>= a>>=10 équivalent à : a = a >> 10 a

est complété par des zéros à
gauche

>>>= a>>>=10 équivalent à : a = a >>> 10

décalage à gauche non signé

Les comparaisons

Java propose des opérateurs pour toutes les comparaisons :

Opérateur Exemple Signification

> a > 10 strictement supérieur

< a < 10 strictement inférieur

>= a >= 10 supérieur ou égal

<= a <= 10 inférieur ou égal

== a == 10 Egalité

!= a != 10 diffèrent de

& a&b ET binaire

^ a^b OU exclusif binaire

| a|b OU binaire

&& a && b ET logique (pour expressions

booléennes) : l'évaluation de
l'expression cesse dès qu'elle
devient fausse

|| a || b OU logique (pour
expressions booléennes) :
l'évaluation de l'expression
 cesse dès qu'elle devient
vraie

?: a?b:c opérateur conditionnel :

renvoie la valeur b ou c selon
l'évaluation de l'expression a
(si a alors b sinon c) : b et c
doivent retourner le même
type
Les opérateurs sont exécutés dans l'ordre suivant à l'intérieur d'une expression qui est analysée
de gauche à droite :
• incréments et décréments
• multiplication, division et reste de division (modulo)
• addition et soustraction
• comparaison
• le signe = d'affectation d'une valeur à une variable
L'usage des parenthèses permet de modifier cet ordre de priorité.
Les opérations arithmétiques

Les opérateurs arithmétiques se notent + (addition), - (soustraction), * (multiplication), /

(division) et % (reste de la division). Ils peuvent se combiner à l'opérateur d'affectation.
L’arithmétique entière :
Pour les types numériques entiers, Java met en œuvre une sorte de mécanisme de conversion
implicite vers le type int appelé promotion entière. Ce mécanisme fait partie des règles mises
en place pour renforcer la sécurité du code.

Les opérandes et le résultat de l'opération sont convertis en type int. Le résultat est
affecté dans un type short : il y a donc risque de perte d'informations et donc une erreur est
émise à la compilation. Cette promotion évite un débordement de capacité sans que le
programmeur soit pleinement conscient du risque : il est nécessaire, pour régler le problème,
d'utiliser une conversion explicite ou cast.
Il est nécessaire de mettre l'opération entre parenthèses pour que ce soit son résultat qui soit
converti car le cast a une priorité plus forte que les opérateurs arithmétiques.
La division par zéro pour les types entiers lève l'exception ArithmeticException.

L’arithmétique en virgule flottante :

Avec des valeurs float ou double, la division par zéro ne produit pas d'exception mais le résultat
est indiqué par une valeur spéciale qui peut prendre trois états :
• indéfini : Float.NaN ou Double.NaN (not a number)
• indéfini positif : Float.POSITIVE_INFINITY ou Double.POSITIVE_INFINITY, + ∞
• indéfini négatif : Float.NEGATIVE_INFINITY ou Double.NEGATIVE_INFINITY, - ∞
Conformément à la norme IEEE754, ces valeurs spéciales représentent le résultat d'une
expression invalide NaN, une valeur supérieure au plafond du type pour infini positif ou négatif.

X Y X/Y X%Y

Valeur finie 0 +∞ NaN

Valeur finie +/- ∞ 0 x

0 0 NaN NaN

+/- ∞ Valeur finie +/- ∞ NaN

+/- ∞ +/- ∞ NaN NaN

L’incrémentation et la décrémentation ;

Les opérateurs d'incrémentation et de décrémentation sont : n++, ++n, n- - et - -n.

Si l'opérateur est placé avant la variable (préfixé), la modification de la valeur est immédiate
sinon la modification n'a lieu qu'à l'issue de l'exécution de la ligne d'instruction (postfixé)
L'opérateur ++ renvoie la valeur avant incrémentation s'il est postfixé, après incrémentation s'il
est préfixé.
La priorité des opérateurs
Java définit les priorités dans les opérateurs comme suit ( du plus prioritaire au moins prioritaire
):

les opérateurs postfix expr++, expr--

les opérateurs unaires ++expr, –expr , +expr ,-expr ,˜ , !

les opérateurs de multiplication, division et * / %

modulo

les opérateurs d'addition et soustraction +-

les opérateurs de décalage <<, >>, >>>

les opérateurs de comparaison < ,>, <=, >= ,instanceof

les opérateurs d'égalité = = , !=

l'opérateur ET &

l'opérateur OU |

l'opérateur ET logique &&

l'opérateur OU logique ||

l'opérateur ternaire ?:

les opérateurs d'assignement =, +=, -=, *=, /=, %=, ^=, |=, <<=, >>=, >>>=
l'opérateur arrow ->
Les structures de contrôles

Comme la quasi-totalité des langages de développement orientés objets, Java propose un

ensemble d'instructions qui permettent d'organiser et de structurer les traitements. L'usage de
ces instructions est similaire à celui rencontré avec leur équivalent dans d’autres langages.
Les boucles :
Les boucles permettent d'exécuter plusieurs fois un bloc de code selon une condition ou le
parcours des éléments d'un tableau ou d'un Iterable. Java propose plusieurs types de boucles :
• while(condition)
• do ... while(condition)
• for
• for améliorée (depuis Java 1.5)
Les boucles while :
Une boucle while permet d'exécuter l'instruction ou le bloc de code qui la suit tant que la
condition booléenne est évaluée à vraie. La condition est évaluée en début de chaque itération.
La syntaxe générale est de la forme :

Si avant l'instruction while, le booléen est false, alors le code de la boucle ne sera jamais
exécuté.
Attention : ne pas mettre de ; après les parenthèses de la condition sinon cela produira une
boucle infinie qui consomme énormément de CPU uniquement pour tester la condition.

Les boucles do…while :

Une boucle do ... while permet d'exécuter l'instruction ou le bloc de code qui la suit tant que la
condition booléenne est évaluée à vraie.
La syntaxe générale est de la forme :

La condition est évaluée en fin de chaque itération : la boucle est donc exécutée au moins une
fois quelle que soit la valeur du booléen lors de la première itération.
Les boucles for :
La boucle for permet de réaliser une boucle dont la définition est composée de plusieurs parties
optionnelles. La syntaxe générale est :

for ( initialisation; condition; modification ) {

...
}

Attention : comme toutes les parties sont optionnelles, il est facile de faire une boucle infinie
qui va consommer 100% de CPU jusqu'à ce que la JVM soit tuée.

L'initialisation, la condition et la modification de l'index sont optionnelles.

Dans l'initialisation, on peut déclarer une variable qui servira d'index. La variable incrémentée
peut être définie dans la partie initialisation et qui sera dans ce cas locale à la boucle : elle ne
sera donc accessible que dans le bloc de code de l'instruction for.
Il est possible d'inclure plusieurs traitements dans l'initialisation et la modification de la boucle
: chacun des traitements doit être séparé par une virgule.

Les boucles for améliorés :

Java 1.5 propose une nouvelle syntaxe pour les boucles for : les boucles for améliorées pour
faciliter le parcours intégral des implémentations de l'interface Iterator et des tableaux.
L'itération sur les éléments d'une collection est verbeuse avec la déclaration d'un objet de type
Iterator.

La nouvelle forme de l'instruction for, spécifiée dans la JSR 201, permet de simplifier l'écriture
du code pour réaliser une telle itération et laisse le soin au compilateur de générer le bytecode
nécessaire.
L'utilisation de la syntaxe de l'instruction for améliorée peut être renforcée en combinaison avec
les génériques, ce qui évite l'utilisation d'un cast.

La syntaxe de l'instruction for améliorée peut aussi être utilisée pour parcourir tous les éléments
d'un tableau.

Cela permet d'éviter la déclaration et la gestion dans le code d'une variable contenant l'index
courant lors du parcours du tableau.
Les branchements conditionnels

Les instructions de branchements conditionnels permettent l'exécution d'un bloc de code selon
le résultat de l'évaluation d'une condition.
L’instruction if :
L'instruction if permet d'exécuter l'instruction ou le bloc de code qui la suit si l'évaluation de la
condition booléenne est vraie.
Il est possible d'utiliser une instruction optionnelle else qui précise une instruction ou un bloc
de code à exécuter si l'évaluation de la condition booléenne est fausse. La syntaxe générale est
de la forme :
if (boolean) {
...
} else if (boolean) {
...
} else {
...
}

L’opérateur ternaire :
L'opérateur ternaire est un raccourci syntaxique pour une instruction if/else qui renvoie
simplement une valeur selon l'évaluation de la condition.
La syntaxe générale est de la forme :

( condition ) ? valeur-vraie : valeur-fausse

L’instruction switch :
L'instruction switch permet d'exécuter du code selon l'évaluation de la valeur d'une expression.
La syntaxe historique générale est de la forme :
switch (expression) {
case valeur1 :
instr11;
instr12;
break;
case valeur2 :
case valeur3 :
...
break;
case valeur4 :
...
break;
default :
...
}

Si une instruction case ne contient pas de break alors les traitements associés au case suivant
sont exécutés : cette fonctionnalité se nomme le fall through. Cela permet d'exécuter les mêmes
instructions pour plusieurs valeurs.
Avant Java 7, on ne peut utiliser l'instruction switch qu'avec des types primitifs d'une taille
maximum de 32 bits (byte, short, int, char) ou une énumération. L'utilisation d'une chaîne de
caractères dans une instruction switch provoquait une erreur à la compilation "Incompatible
Types. Require int instead of String".
A partir de Java SE 7, il est possible d'utiliser un objet de type String dans l'expression fournie
à l'instruction switch.
L'instruction switch compare la valeur de la chaîne de caractères avec la valeur fournie à chaque
instruction case comme si elle utilisait la méthode String.equals(). Dans les faits, le compilateur
utilise la méthode String.hashCode() pour faire la comparaison. Le compilateur va ainsi générer
un code qui est plus optimisé que le code équivalent avec des instructions if/else.
Important : il est nécessaire de vérifier que la chaîne de caractères évaluée par l'instruction
switch ne soit pas null sinon une exception de type NullPointerException est levée.
Le test réalisé par l'instruction switch est sensible à la casse : il faut donc en tenir compte si un
test ne l'est pas.

A partir de Java 14, l'instruction switch a été revue en profondeur pour proposer 4 formes
syntaxiques, une utilisation comme instruction ou comme une expression, la possibilité de gérer
plusieurs valeurs dans un case. Ces nouvelles possibilités sont détaillées dans une section
suivante.
Il est possible d'imbriquer des instructions switch même si cela n'est pas recommandé pour des
raisons de lisibilité.
Pour certains cas d'usage, l'instruction switch peut être remplacée avantageusement par une
utilisation du polymorphisme.
Les débranchements

Le langage Java propose plusieurs instructions pour réaliser des débranchements :

• break
• continue
• return
Les deux premières instructions peuvent être utilisées avec une étiquette.
Remarque : l'instruction goto est un mot clé réservé du langage Java mais non utilisé.
Attention : l'utilisation des débranchements est à utiliser avec parcimonie car elle peut
contribuer à dégrader la lecture et la maintenabilité du code et induire des bugs subtils.
L’instruction break :
L'instruction break permet de quitter immédiatement une boucle ou un branchement. Elle est
utilisable dans tous les contrôles de flot.
La syntaxe est de la forme
break;
L'instruction break est utilisée pour mettre fin à une boucle dès qu'une instruction Break est
exécutée dans une boucle, l'itération courante de la boucle s'arrête immédiatement et le contrôle
revient à l'instruction suivant la boucle.

Remarque : l'instruction break, lorsqu'elle est utilisée à l'intérieur d'un ensemble de boucles
imbriquées, n'interrompt que la boucle la plus interne.
L’instruction continue :
L'instruction continue s'utilise dans une boucle pour passer directement à l'itération suivante.
La syntaxe est de la forme :
continue;
L'instruction continue peut être utilisée à l'intérieur des structures de contrôle de type boucles.
À l'intérieur de la boucle, lorsqu'une instruction continue est rencontrée, le contrôle saute
directement au début de la boucle pour aller à l'itération suivante : cela met immédiatement fin
à l'exécution des instructions de l'itération en cours.
L'instruction continue est utilisée pour sauter une condition particulière et poursuivre
l'exécution à la prochaine itération.
L'instruction continue est utilisable avec toutes les types de boucle en Java :
Dans le cas d'une boucle for, le mot clé continue force le contrôle à sauter immédiatement à
l'instruction d'incrémentation.
• dans le cas d'une boucle while ou do-while, le contrôle saute immédiatement à l'expression
booléenne
• dans le cas d'une boucle for améliorée, le contrôle saute à l'élément suivant
Exemple avec une boucle for :
Exemple avec une boucle while :

Exemple avec une boucle do-while :

Il est possible d'utiliser une instruction continue dans des boucles imbriquées. L'instruction
continue permet d'ignorer le reste des traitements de l'itération en cours. Dans le cas de boucles
imbriquées, elle passe à l'itération suivante de la boucle la plus interne.
Exemple avec une boucle for améliorée

L’instruction return :
L'instruction return est utilisée pour sortir immédiatement de l'exécution d'une méthode et
retourner le contrôle à l'appelant.
Elle peut être utilisée dans une méthode avec ou sans valeur de retour.
Pour les méthodes qui définissent un type de retour, l'instruction return doit être immédiatement
suivie de la valeur de retour.
Dans une telle méthode, toutes les branches de sortie de la méthode doivent avoir une
instruction return qui fournit la valeur retournée pour la branche.

Pour régler l'erreur, il faut utiliser une instruction return dans la branche else de l'instruction if.

L'instruction return peut être utilisée à différents endroits dans une méthode, mais il faut
toujours s'assurer qu'elle doit être la dernière instruction à être exécutée dans une méthode. Si
ce n'est pas le cas, une erreur est émise par le compilateur.
L'instruction return ne doit pas nécessairement être la dernière instruction d'une méthode, mais
elle doit être la dernière instruction à être exécutée dans une méthode.
Dans une méthode qui ne retourne pas de valeur, il est possible d'utiliser une instruction return
pour arrêter immédiatement les traitements de la méthode.

Les tableaux

Les tableaux permettent de stocker un ensemble fini d'éléments d'un type particulier. L'accès à
un élément particulier se fait grâce à son indice. Le premier élément d'un tableau possède
l'indice 0.
Même si leur déclaration est spécifique, ce sont des objets : ils sont donc dérivés de la classe
Object. Il est possible d'utiliser les méthodes héritées telles que equals() ou getClass().
La déclaration et l’allocation des tableaux :
La déclaration d'un tableau à une dimension requiert un type, le nom de la variable permettant
de faire référence au tableau et une paire de crochets. Java permet de placer les crochets sur le
type ou sur le nom de la variable dans la déclaration.
L'allocation de la mémoire et donc l'obtention d'une référence pour accéder au tableau se fait
en utilisation l'opérateur new, suivi d'une paire de crochets qui doit contenir le nombre
maximum d'éléments que peut contenir le tableau.
La déclaration et l'allocation peut se faire sur une même ligne ou sur des lignes distinctes.

Pour passer un tableau à une méthode, il suffit de déclarer le paramètre dans la signature de la
méthode.

Les tableaux sont toujours transmis par référence puisque ce sont des objets.
Java ne supporte pas directement les tableaux à plusieurs dimensions : il faut déclarer un tableau
de tableau en utilisant une paire de crochet pour chaque dimension.

L’initialisation explicite d’un tableau :

La taille du tableau n'est pas obligatoire si le tableau est initialisé à sa création.

Le nombre d'éléments de chaque ligne peut ne pas être identique :

Le parcours d’un tableau :

La variable length retourne le nombre d'éléments du tableau. Il est alors possible d'utiliser une
boucle pour itérer sur chacun des éléments du tableau.

Un accès a un élément d'un tableau qui dépasse sa capacité, lève une exception du type
java.lang.arrayIndexOutOfBoundsException.
A partir de Java 5, le parcours de l'intégralité des éléments d'un tableau peut être réalisé en
utilisant la version améliorée de l'instruction for. La syntaxe générale est de la forme :
for ( type element_courant : type[] ) {
// code à exécuter sur l'élément courant identifié par la variable element_courant
}
Les conversions de types
Lors de la déclaration, il est possible d’utiliser un cast :

La conversion peut entrainer une perte d'informations.

Il n'existe pas en Java de fonction pour convertir : les conversions de type se font par des
méthodes. La bibliothèque de classes API fournit une série de classes qui contiennent des
méthodes de manipulation et de conversion de types élémentaires.

Classe Rôle

String pour les chaînes de caractères Unicode

Integer pour les valeurs entières (integer)

Long pour les entiers longs signés (long)

Float pour les nombres à virgule flottante (float)

Double pour les nombres à virgule flottante en double

précision (double)

Les classes portent le même nom que le type élémentaire sur lequel elles reposent avec la
première lettre en majuscule.
Ces classes contiennent généralement plusieurs constructeurs ou des méthodes statiques pour
obtenir des instances.

La conversion d'un entier int en chaîne de caractères String

Des surcharges de la méthode valueOf() sont également définies pour des arguments de type
boolean, long, float, double et char.
La conversion d'une chaîne de caractères String en entier int

La conversion d'un entier int en entier long

L'autoboxing et l'unboxing

L'autoboxing permet de transformer automatiquement une variable de type primitif en un objet

du type du wrapper correspondant. L'unboxing est l'opération inverse. Cette nouvelle
fonctionnalité est spécifiée dans la JSR 201 et intégrée dans Java 1.5.
Par exemple, jusqu'à la version 1.4 de Java pour ajouter des entiers dans une collection, il était
nécessaire d'encapsuler chaque valeur dans un objet de type Integer.
Avec Java 1.5, l'encapsulation de la valeur dans un objet n'est plus obligatoire car elle sera
réalisée automatiquement par le compilateur.

Le concept de classe

Une classe est le support de l'encapsulation : c'est un ensemble de données et de fonctions

regroupées dans une même entité. Une classe est une description abstraite d'un objet. Les
fonctions qui opèrent sur les données sont appelées des méthodes. Instancier une classe consiste
à créer un objet sur son modèle. Entre classe et objet il y a, en quelque sorte, le même rapport
qu'entre type et variable.
Java est un langage orienté objet : tout appartient à une classe sauf les variables de types
primitives.
Pour accéder à une classe il faut en déclarer une instance de classe ou objet.
Une classe comporte sa déclaration, des variables et les définitions de ses méthodes.
Une classe se compose de deux parties : un en-tête et un corps. Le corps peut être divisé en 2
sections : la déclaration des données et des constantes et la définition des méthodes. Les
méthodes et les données sont pourvues d'attributs de visibilité qui gèrent leur accessibilité par
les composants hors de la classe.
La syntaxe de déclaration d'une classe :

La syntaxe de déclaration d'une classe est la suivante :

modificateurs class nom_de_classe [extends classe_mere] [implements interfaces] { ... }
Les modificateurs de classe (ClassModifiers) sont :

Modificateurs Rôle

abstract la classe contient une ou des méthodes

abstraites, qui n'ont pas de définition
explicite. Une classe déclarée abstract ne peut
pas être instanciée : il faut définir une classe
qui hérite de cette classe et qui implémente
les méthodes nécessaires pour ne plus être
abstraite.
 final la classe ne peut pas être modifiée, sa
redéfinition grâce à l'héritage est interdite.
Les classes déclarées final ne peuvent donc
pas avoir de classes filles.

private la classe n'est accessible qu'à partir du fichier

où elle est définie

public La classe est accessible partout

Les modificateurs abstract et final ainsi que public et private sont mutuellement exclusifs.
Marquer une classe comme final peut permettre au compilateur et à la JVM de réaliser quelques
petites optimisations.
Le mot clé extends permet de spécifier une super-classe éventuelle : ce mot clé permet de
préciser la classe mère dans une relation d'héritage.
Le mot clé implements permet de spécifier une ou des interfaces que la classe implémente. Cela
permet de récupérer quelques avantages de l'héritage multiple.
L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre
d'abord la méthode A puis la méthode B, B peut être appelée sans problème dans A.
Les objets
Les objets contiennent des attributs et des méthodes. Les attributs sont des variables ou des
objets nécessaires au fonctionnement de l'objet. En Java, une application est un objet. La classe
est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une
classe, le code est le même, seules les données sont différentes à chaque objet.

La création d'un objet : instancier une classe

Il est nécessaire de définir la déclaration d'une variable ayant le type de l'objet désiré. La
déclaration est de la forme :
nom_de_classe nom_de_variable

L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable.

Exemple :
m = new MaClasse() ;
Il est possible de tout réunir en une seule déclaration :
Exemple :
MaClasse m = new MaClasse() ;

Chaque instance d'une classe nécessite sa propre variable. Plusieurs variables peuvent désigner
un même objet.
En Java, tous les objets sont instanciés par allocation dynamique. Dans l'exemple, la variable
m contient une référence sur l'objet instancié (contient l'adresse de l'objet qu'elle désigne :
attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement
sur cette adresse comme en C).
Si m2 désigne un objet de type MaClasse, l'instruction m2 = m ne définit pas un nouvel objet
mais m et m2 désignent tous les deux le même objet.
L'opérateur new est un opérateur de haute priorité qui permet d'instancier des objets et d'appeler
une méthode particulière de cet objet : le constructeur. Il fait appel à la machine virtuelle pour
obtenir l'espace mémoire nécessaire à la représentation de l'objet puis appelle le constructeur
pour initialiser l'objet dans l'emplacement obtenu. Il renvoie une valeur qui référence l'objet
instancié.
Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire, il lève l'exception
OutOfMemoryError.

La durée de vie d’un objet

Les objets ne sont pas des éléments statiques et leur durée de vie ne correspond pas forcément
à la durée d'exécution du programme.
La durée de vie d'un objet passe par trois étapes :
• la déclaration de l'objet et l'instanciation grâce à l'opérateur new.
Exemple :
nom_de_classe nom_d_objet = new nom_de_classe( ... );

• l'utilisation de l'objet en appelant ses méthodes

• la suppression de l'objet : elle est automatique en Java grâce à la machine virtuelle. La
restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire
(garbage collector). Il n'existe pas d'instruction delete comme en C++.
Les références et la comparaison d'objets
Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers
cet objet. Lorsque l'on écrit c1 = c2 (c1 et c2 sont des objets), on copie la référence de l'objet
c2 dans c1. c1 et c2 font référence au même objet : ils pointent sur le même objet. L'opérateur
== compare ces références. Deux objets avec des propriétés identiques sont deux objets
distincts :
Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'une méthode à
cet effet : la méthode equals() héritée de Object.
Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de
la classe Object dont toutes les classes héritent.
Exemple :
(obj1.getClass().equals(obj2.getClass())

Le littéral nul
Le littéral null est utilisable partout où il est possible d'utiliser une référenc à un objet. Il
n'appartient pas à une classe mais il peut être utilisé à la place d'un objet de n'importe quel type
ou comme paramètre. null ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel
de méthodes et aucune classe ne peut en hériter.
Le fait d'affecter null une variable référençant un objet pourra permettre au ramasse-miettes de
libérer la mémoire allouée à l'objet si aucune autre référence n'existe encore sur lui.
Les variables de classe
Elles ne sont définies qu'une seule fois quel que soit le nombre d'objets instanciés de la classe.
Leur déclaration est accompagnée du mot clé static.

L'appartenance des variables de classe à une classe entière et non à un objet spécifique permet
de remplacer le nom de la variable par le nom de la classe.

Ce type de variable est utile pour, par exemple, compter le nombre d'instanciations de la classe.

La variable this
Cette variable sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. this
est un objet qui est égal à l'instance de l'objet dans lequel il est utilisé.
Il est préférable de préfixer la variable d'instance par le mot clé this.

Cette référence est habituellement implicite :

This est aussi utilisé quand l'objet doit appeler une méthode en se passant lui-même en
paramètre de l'appel.

L'opérateur instanceof
L'opérateur instanceof permet de déterminer la classe de l'objet qui lui est passé en paramètre.
La syntaxe est objet instanceof classe.

Dans le cas ci-dessus, même si o est une instance de MaClasse, il n'est pas permis d'appeler une
méthode de MaClasse car o est de type Objet.

Pour résoudre le problème, il faut utiliser la technique du casting (conversion).

Les modificateurs d’accès
Ils s'appliquent aux classes, aux méthodes et aux attributs.
Ils ne peuvent pas être utilisés pour qualifier des variables locales : seules les variables
d'instances et de classes peuvent en profiter.
Ils assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de
données par les autres objets.
Les mots clés qui gèrent la visibilité des entités
De nombreux langages orientés objet introduisent des attributs de visibilité pour réglementer
l'accès aux classes et aux objets, aux méthodes et aux données.
En plus de la valeur par défaut, il existe 3 modificateurs explicites qui peuvent être utilisés pour
définir les attributs de visibilité des entités (classes, méthodes ou attributs) : public, private et
protected. Leur utilisation permet de définir des niveaux de protection différents (présentés dans
un ordre croissant de niveau de protection offert) :

Modificateur Rôle

public Une variable, méthode ou classe déclarée

public est visible par tous les autres objets.
Depuis la version 1.0, une seule classe public
est permise par fichier et son nom doit
correspondre à celui du fichier. Dans la
philosophie orientée objet aucune donnée
d'une classe ne devrait être déclarée publique
: il est préférable d'écrire des méthodes pour
la consulter et la modifier

par défaut : package-private Il n'existe pas de mot clé pour définir ce

niveau, qui est le niveau par défaut
lorsqu'aucun modificateur n'est précisé. Cette
déclaration permet à une entité (classe,
méthode ou variable) d'être visible par toutes
les classes se trouvant dans le même package.

protected Si une méthode ou une variable est déclarée

protected, seules les méthodes présentes dans
le même package que cette classe ou ses
sous-classes pourront y accéder. On ne peut
pas qualifier une classe avec protected.
 private C'est le niveau de protection le plus fort. Les
composants ne sont visibles qu'à l'intérieur de
la classe : ils ne peuvent être modifiés que par
des méthodes définies dans la classe et
prévues à cet effet. Les méthodes déclarées
private ne peuvent pas être en même temps
déclarées abstract car elles ne peuvent pas
être redéfinies dans les classes filles.

Le mot clé static

Le mot clé static s'applique aux variables et aux méthodes.
Les variables d'instance sont des variables propres à un objet. Il est possible de définir une
variable de classe qui est partagée entre toutes les instances d'une même classe : elle n'existe
donc qu'une seule fois en mémoire. Une telle variable permet de stocker une constante ou une
valeur modifiée tour à tour par les instances de la classe. Elle se définit avec le mot clé static.

Il est aussi possible par exemple de mémoriser les valeurs min et max d'un ensemble d'objets
de même classe. Une méthode static est une méthode qui n'agit pas sur des variables d'instance
mais uniquement sur des variables de classe. Ces méthodes peuvent être utilisées sans instancier
un objet de la classe. Les méthodes ainsi définies peuvent être appelées avec la notation
classe.methode() au lieu de objet.methode() : la première forme est fortement recommandée
pour éviter toute confusion. Il n'est pas possible d'appeler une méthode d'instance ou d'accéder
à une variable d'instance à partir d'une méthode de classe statique.
Le mot clé final
Le mot clé final s'applique aux variables de classe ou d'instance ou locales, aux méthodes, aux
paramètres d'une méthode et aux classes. Il permet de rendre l'entité sur laquelle il s'applique
non modifiable une fois qu'elle est déclarée pour une méthode ou une classe et initialisée pour
une variable.
Une variable qualifiée de final signifie que la valeur de la variable ne peut plus être modifiée
une fois que celle-ci est initialisée.
Une fois la variable déclarée final initialisée, il n'est plus possible de modifier sa valeur. Une
vérification est opérée par le compilateur.

Les constantes sont qualifiées avec les modificateurs final et static.

Une méthode déclarée final ne peut pas être redéfinie dans une sous-classe. Une méthode
possédant le modificateur final pourra être optimisée par le compilateur car il est garanti qu'elle
ne sera pas sous-classée.
Lorsque le modificateur final est ajouté à une classe, il est interdit de créer une classe qui en
hérite.
Pour une méthode ou une classe, on renonce à l'héritage mais ceci peut s'avérer nécessaire pour
des questions de sécurité ou de performance. Le test de validité de l'appel d'une méthode est
bien souvent repoussé à l'exécution, en fonction du type de l'objet appelé (c'est la notion de
polymorphisme qui sera détaillée ultérieurement). Ces tests ont un coût en termes de
performance.
Quatre types de variables sont implicitement déclarés final :
• un champ d'une interface
• une variable locale déclarée comme ressource d'une instruction try-with-resources
• un paramètre d'exception d'une clause multi-catch
• un champ correspondant à un composant d'un record
Remarque : un unique paramètre d'exception d'une clause catch n'est jamais déclaré final
implicitement, mais peut être effectivement final.
Le mot clé abstract
Le mot clé abstract s'applique aux méthodes et aux classes.
Abstract indique que la classe ne pourra être instanciée telle quelle. De plus, toutes les méthodes
de cette classe abstract ne sont pas implémentées et devront être redéfinies par des méthodes
complètes dans ses sous-classes.
Abstract permet de créer une classe qui sera une sorte de moule. Toutes les classes dérivées
pourront profiter des méthodes héritées et n'auront à implémenter que les méthodes déclarées
abstract.

Une méthode abstraite est une méthode déclarée avec le modificateur abstract et sans corps.
Elle correspond à une méthode dont on veut forcer l'implémentation dans une sous-classe.
L'abstraction permet une validation du codage : une sous-classe sans le modificateur abstract et
sans définition explicite d'une ou des méthodes abstraites génère une erreur de compilation.
Une classe est automatiquement abstraite dès qu'une de ses méthodes est déclarée abstraite. Il
est possible de définir une classe abstraite sans méthodes abstraites.
Les variables d'instances
Une variable d'instance nécessite simplement une déclaration de la variable dans le corps de la
classe.

Chaque instance de la classe a accès à sa propre occurrence de la variable.

Les variables de classes

Les variables de classes sont définies avec le mot clé static.
Les constantes
Les constantes sont définies avec le mot clé final : leur valeur ne peut pas être modifiée une fois
qu'elles sont initialisées.

Les méthodes
Les méthodes sont des fonctions qui implémentent les traitements de la classe.
La syntaxe de la déclaration
La syntaxe de la déclaration d'une méthode est :
modificateurs type_retourné nom_méthode ( arg1, ... ) {... } // définition des variables locales
et du bloc d'instructions.
Le type retourné peut être élémentaire ou correspondre à un objet. Si la méthode ne retourne
rien, alors on utilise void.
Le type et le nombre d'arguments déclarés doivent correspondre au type et au nombre
d'arguments transmis. Il n'est pas possible d'indiquer des valeurs par défaut dans les paramètres.
Les arguments sont passés par valeur : la méthode fait une copie de la variable qui lui est locale.
Lorsqu'un objet est transmis comme argument à une méthode, cette dernière reçoit une
référence qui désigne son emplacement mémoire d'origine et qui est une copie de la variable. Il
est possible de modifier l'objet grâce à ses méthodes mais il n'est pas possible de remplacer la
référence contenue dans la variable passée en paramètre : ce changement n'aura lieu que
localement à la méthode.
Les modificateurs de méthodes sont :

Modificateur Rôle

public la méthode est accessible aux méthodes des

autres classes

private l'usage de la méthode est réservé aux autres

méthodes de la même classe

protected la méthode ne peut être invoquée que par des

méthodes de la classe ou de ses sous-classes

final la méthode ne peut être modifiée

(redéfinition lors de l'héritage interdite)

static la méthode appartient simultanément à tous

les objets de la classe (comme une constante
déclarée à l'intérieur de la classe). Il est
inutile d'instancier la classe pour appeler la
 méthode mais la méthode ne peut pas
manipuler de variable d'instance. Elle ne peut
utiliser que des variables de classes.

synchronized la méthode fait partie d'un thread. Lorsqu'elle

est appelée, elle barre l'accès à son instance.
L'instance est à nouveau libérée à la fin de
son exécution.

native le code source de la méthode est écrit dans un

autre langage

Sans modificateur, la méthode peut être appelée par toutes autres méthodes des classes du
package auquel appartient la classe.
La valeur de retour de la méthode doit être transmise par l'instruction return. Elle indique la
valeur que prend la méthode et termine celle-ci : toutes les instructions qui suivent return sont
donc ignorées.

Il est possible d'inclure une instruction return dans une méthode de type void : cela permet de
quitter la méthode.
La méthode main() de la classe principale d'une application doit être déclarée de la façon
suivante : public static void main (String args[]) { ... }

Cette déclaration de la méthode main() est imposée par la machine virtuelle pour reconnaitre le
point d'entrée d'une application. Si la déclaration de la méthode main() diffère, une exception
sera levée lors de la tentative d'exécution par la machine virtuelle.
Si la méthode retourne un tableau alors les caractères [] peuvent être précisés après le type de
retour ou après la liste des paramètres :

Les constructeurs
La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode
particulière appelée constructeur pour que les variables aient une valeur de départ. Elle n'est
systématiquement invoquée que lors de la création d'un objet.
Le constructeur suit la définition des autres méthodes excepté que son nom doit obligatoirement
correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y
avoir d'instruction return dans un constructeur. On peut surcharger un constructeur.
La définition d'un constructeur est facultative. Si aucun constructeur n'est explicitement défini
dans la classe, le compilateur va créer un constructeur par défaut sans argument. Dès qu'un
constructeur est explicitement défini, le compilateur considère que le programmeur prend en
charge la création des constructeurs et que le mécanisme par défaut, qui correspond à un
constructeur sans paramètres, n'est pas mis en oeuvre. Si on souhaite maintenir ce mécanisme,
il faut définir explicitement un constructeur sans paramètres en plus des autres constructeurs.
Il existe plusieurs manières de définir un constructeur :

1. le constructeur simple :
ce type de constructeur ne nécessite pas de définition explicite : son existence découle
automatiquement de la définition de la classe.
 2. le constructeur avec initialisation fixe : il permet de créer un constructeur par
défaut.

3. le constructeur avec initialisation des variables : pour spécifier les valeurs de

données à initialiser on peut les passer en paramètres au constructeur.

L’héritage
L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution.
Elle définit une relation entre deux classes :
• une classe mère ou super-classe
• une classe fille ou sous-classe qui hérite de sa classe mère
Le principe de l’héritage
Grâce à l'héritage, les objets d'une classe fille ont accès aux données et aux méthodes de la
classe parente et peuvent les étendre. Les sous-classes peuvent redéfinir les variables et les
méthodes héritées. Pour les variables, il suffit de les redéclarer sous le même nom avec un type
différent. Les méthodes sont redéfinies avec le même nom, les mêmes types et le même nombre
d'arguments, sinon il s'agit d'une surcharge.
L'héritage successif de classes permet de définir une hiérarchie de classe qui se compose de
super-classes et de sous-classes. Une classe qui hérite d'une autre est une sous-classe et celle
dont elle hérite est une super-classe. Une classe peut avoir plusieurs sous-classes. Une classe
ne peut avoir qu'une seule classe mère : il n'y a pas d'héritage multiple en Java.
Object est la classe parente de toutes les classes en Java. Toutes les variables et méthodes
contenues dans Object sont accessibles à partir de n'importe quelle classe car par héritages
successifs toutes les classes héritent d'Object.
La mise en œuvre de l'héritage
On utilise le mot clé extends pour indiquer qu'une classe hérite d'une autre. En l'absence de ce
mot réservé associé à une classe, le compilateur considère la classe Object comme classe mère.
Pour invoquer une méthode d'une classe mère, il suffit d'indiquer la méthode préfixée par super.
Pour appeler le constructeur de la classe mère, il suffit d'écrire super(paramètres) avec les
paramètres adéquats.
Le lien entre une classe fille et une classe mère est géré par la plate-forme : une évolution des
règles de gestion de la classe mère conduit à modifier automatiquement la classe fille dès que
cette dernière est recompilée.
En Java, il est obligatoire dans un constructeur d'une classe fille de faire appel explicitement ou
implicitement au constructeur de la classe mère.

Les packages
En Java, il existe un moyen de regrouper des classes voisines ou qui couvrent un même domaine
: ce sont les packages.
La définition d’un package
Pour réaliser un package, on écrit un nombre quelconque de classes dans plusieurs fichiers d'un
même répertoire et au début de chaque fichier on met la directive ci-dessous où nom-du-
package doit être composé des répertoires séparés par un caractère point : package nom-du
package;
La hiérarchie d'un package se retrouve dans l'arborescence du disque dur puisque chaque
package est dans un répertoire nommé du nom du package.
D'une façon générale, l'instruction package associe toutes les classes qui sont définies dans un
fichier source à un même package.
Le mot clé package doit être la première instruction dans un fichier source et il ne doit être
présent qu'une seule fois dans le fichier source (une classe ne peut pas appartenir à plusieurs
packages).
Les importations
Pour pouvoir utiliser un type en Java, il faut utiliser le nom pleinement qualifié du type qui
inclue le nom du package avec la notation utilisant un point.
Afin de réduire la verbosité lors de l'utilisation de type, il est possible d'utiliser les imports. Ils
utilisent le mot clé import qui définit un alias du nom pleinement qualifié d'un type vers
simplement le nom du type.
Il y a deux manières d'utiliser les imports :
• Préciser un nom de classe ou d'interface qui sera l'unique entité importée
• Ou indiquer un package suivi d'un point et d'un caractère * indiquant toutes les
classes et interfaces définies dans le package

Exemple Rôle

import nomPackage.*; toutes les classes du package sont

importées

import nomPackage.nomClasse; appel à une seule classe : l'avantage de

cette notation est de réduire le temps de
compilation