Cours JAVA
Présenté par MANDIMBY Andriamitsiry
Année Universitaire 2023 – 2024
Sommaire
Introduction
• Java est un langage de programmation originellement proposé par
Sun Microsystems et maintenant par Oracle depuis son rachat de Sun
Microsystems en 2010.
• Java a été conçu avec deux objectifs principaux :
• Permettre aux développeurs d’écrire des logiciels indépendants de
l’environnement hardware d’exécution.
• Offrir un langage orienté objet avec une bibliothèque standard riche
Environement
• L’indépendance par rapport à l’environnement d’exécution est garantie par la
machine virtuelle Java (Java Virtual Machine ou JVM). En effet, Java est un langage
compilé mais le compilateur ne produit pas de code natif pour la machine, il produit
du bytecode : un jeu d’instructions compréhensibles par la JVM qu’elle va traduire en
code exécutable par la machine au moment de l’exécution.
• Il existe ainsi deux environnements Java qui peuvent être téléchargés et installés
depuis le site d’Oracle :
• JRE - Java Runtime Environment: cet environnement fournit uniquement les outils nécessaires
à l’exécution de programmes Java. Il fournit entre-autres la machine virtuelle Java.
• JDK - Java Development Kit: cet environnement fournit tous les outils nécessaires à l’exécution
mais aussi au développement de programmes Java. Il fournit entre-autres la machine virtuelle
Java et la compilateur.
Installation
• L’installation du JDK dépend de votre plate-forme : il est distribué sous la forme
d’un installeur pour Windows et MacOS, et sous la forme d’un package ou
d’une archive sous Linux.
• Téléchargement du JDK 11 pour Windows:
[Link]
[Link]
• Téléchargement de l’IDE Eclipse pour Windows:
[Link]
downloads/release/2019-09/R/eclipse-jee-2019-09-R-win32-x86_64.zip
• Configuration d’Eclipse
• Vérifier la version de Java utilisée par l’IDE et la modifier si nécessaire.
• Pour vérifier les versions de Java disponibles dans Eclipse, ouvrez les
préférences utilisateur, dans le menu Window ‣ Preferences. Dans la zone de
filtre en haut à gauche, saisissez « jre » (pour Java Runtime Environment) et
Structure fondamentale du
langage
• En Java une instruction (statement) décrivant les opérations que la machine doit
exécuter est délimitée par un point-virgule.
• Java est un langage fortement typé. Lorsque l’on déclare une variable un
paramètre ou un attribut, il est obligatoire de préciser son type.
• Java permet de structurer le code en bloc. Un bloc est délimité par des accolades.
• Un commentaire sur une ligne commence par // et continue jusqu’à la fin de la
ligne. Un commentaire sur plusieurs lignes commence par /* et se termine par */
• Il existe un type spécial de commentaires utilisé par l’utilitaire javadoc. Ces
commentaires servent à générer la documentation au format HTML de son code.
Ces commentaires, appelés commentaires javadoc, commencent par /**
• Le compilateur Java n’impose pas de formatage particulier du code.
Structure fondamentale du
langage (suite 1)
• Pour une bonne lisibilité et une bonne compréhension de son code
par ses pairs, les développeurs Java doivent respecter des
conventions de nommage.
Type Exemple
Packages [Link]
[Link].extra_utils
Classes et interfaces MyClass
SuppressionClientOperateur
Annotations @InjectIn
@EJB
Méthodes run() runFast()
getWidthInPixels()
Variables widthInPixels
clientsInscrits
total
Constantes LARGEUR_MAX
INSCRIPTIONS_PAR_ANNEE
Structure fondamentale du
langage (suite 2)
• Comme pour la plupart des langages de programmation, il n’est pas
possible d’utiliser comme nom dans un programme un mot-clé du
langage
Abstract , continue, for , new, switch, assert , default , if ,package
synchronized, boolean , do , goto , private , this, break
double, implements , protected, throw , byte, else , import ,
public , throws, case, enum, instanceof , return, transient,
catch , extends, int , short, try, char , final , interface,
static , void ,class, finally , long , strictfp , volatile, const ,
float, native , super , while ,_ (underscore) , true, false, null
Classe et Objet
• Java est langage orienté objet. Cela signifie que (presque) tout est un
objet. La définition d’un objet s’appelle une classe. Donc programmer
en Java revient à déclarer des classes, à instancier des objets à partir
des classes déclarées ou fournies et à effectuer des opérations sur ces
objets.
• En Java, une classe est déclarée dans son propre fichier qui doit
porter le même nom que la classe avec l’extension .java. Il nous faut
donc créer le fichier [Link] (créer directement dans un projet
sous Eclipse avec le menu File ‣ New ‣ Class.)
Anatomie de classe
• En Java une classe est déclarée par le mot-clé class suivi du nom de la
classe. Ensuite, on ouvre un bloc avec des accolades pour déclarer le
contenu de la classe. La déclaration d’une classe peut contenir :
declaration
Attributs représentent l’état interne d’un objet [portée] [type] [identifiant];
Méthodes représentent les opérations que l’on peut effectuer [portée] [type de retour] [identifiant] ([liste des
sur un objet de cette classe paramètres]) { [code] }
Constantes un moyen de nommer des valeurs particulières
utiles à la compréhension du code.
Enumérations listes figées d’objets
Classes internes Un classe peut contenir la déclaration d’autres
classes que l’on appelle alors classes internes (inner
classes)
La méthode main
• Si nous voulons utiliser notre classe dans un programme, il nous faut
déterminer un point d’entrée pour l’exécution du programme. Un point d’entrée
est représenté par la méthode main qui doit avoir la signature suivante :
public static void main(String[] args) {
}
• Une classe ne peut déclarer qu’une seule méthode main. En revanche, toutes
les classes peuvent déclarer une méthode main. Cela signifie qu’une application
Java peut avoir plusieurs points d’entrée (ce qui peut se révéler très pratique).
Voilà pourquoi la commande java attend comme paramètre le nom d’une classe
qui doit déclarer une méthode main.
Les types primitifs
Java n’est pas complètement un langage orienté objet dans la mesure
où il supporte ce que l’on nomme les types primitifs. Chaque type
primitif est représenté par un mot-clé et son occupation d’espace
mémoire: Anglais
Français Mot-clé Espace mémoire Classe associée au
type primitif
Booléen Boolean boolean indéterminé [Link]
Caractère Character char 2 octets (16 bits) [Link]
Entier Integer int 4 octets (32 bits) [Link]
Octet Byte byte 1 octet (8 bits) [Link]
Entier court Short integer short 2 octets (16 bits) [Link]
Entier long Long integer long 8 octets (64 bits) [Link]
Nombre à virgule Float number float 4 octets (32 bits [Link]
flottante IEEE 754 floating
point)
Nombre à virgule Double precision float double 8 octets (64 bits IEEE [Link]
flottante en double number 754 floating point)
précision
Les opérateurs
• L’opérateur d’affectation L’affectation est réalisée grâce à l’opérateur =
* Multiplication
• Les opérateurs arithmétiques / Division
% Reste de la division
+ Addition
- Soustraction
expr++ Incrément postfixé
• Les opérateurs arithmétiques unaires expr-- Décrément postfixé
++expr Incrément préfixé
--expr Décrément préfixé
+ Positif
- Négatif
• L’opérateur de concaténation de chaînes Les chaînes de caractères
peuvent être concaténées avec l’opérateur +. En Java, les chaînes de
caractères sont des objets de type String.
Les opérateurs (suite 1)
< Inférieur
• Les opérateurs relationnels
> Supérieur
Les opérateurs relationnels produisent un <= Inférieur ou égal
résultat booléen (true ou false) et permettent >= Supérieur ou égal
de comparer deux valeurs == Égal
!= Différent
• Les opérateurs logiques ! Négation
Les opérateurs logiques prennent des
&& Et logique
booléens comme opérandes et produisent un
résultat booléen (true ou false) : || Ou logique
• L’opérateur ternaire qui permet d’affecter une valeur suivant le
résultat d’une condition. exp
faux
booléenne ? valeur si vrai : valeur si
Les opérateurs (suite 2)
• Le transtypage (cast)
Il est parfois nécessaire de signifier que l’on désire passer d’un type vers
un autre au moment de l’affectation. Java étant un langage fortement
typé, il autorise par défaut uniquement les opérations de transtypage
qui sont sûres. i=
int 1;
long l= i; // Ok
short s = (short) l; // cast obligatoire
• L’opérateur . permet d’accéder aux attributs et aux méthodes d’une
classe ou d’un objet à partir d’une référence.
• L’opérateur , est utilisé comme séparateur des paramètres dans la
définition et l’appel des méthodes. Il peut également être utilisé en
tant qu’opérateur pour évaluer séquentiellement une instruction.
Les structures de contrôle
Comme la plupart des langages impératifs, Java propose un ensemble
de structures de contrôle.
• if-else : l’expression if permet d’exécuter un bloc d’instructions
uniquement si l’expression booléenne est évaluée à vrai : i % == if ( 2 0) {
// instructions à exécuter si i est pair
}
• L’expression if peut être optionnellement suivie d’une expression else
pour les cas où l’expression est évaluée à faux: i % == if ( 2 0) {
// instructions à exécuter si i est pair
} else {
// instructions à exécuter si i est impair
}
• L’expression else peut être suivie d’une nouvelle instruction if afin de
réaliser des choix multiples :
% ==
if (i 2 0) {
// instructions à exécuter si i pair
>
} else if (i 10) {
// instructions à exécuter si i est impair et supérieur à 10
} else {
// instructions à exécuter dans tous les autres cas
}
Les structures de contrôle (suite 1)
• Return est un mot clé permettant d’arrêter immédiatement le
traitement d’une méthode et de retourner la valeur de l’expression
spécifiée après ce mot-clé. Si la méthode ne retourne pas de valeur
(void), alors on utilise le mot-clé return seul. L’exécution d’un return
entraîne la fin d’une structure de contrôle. i % ==
if ( 2 0) { return 0; }
• L’expression while permet de définir un bloc d’instructions à répéter
tant que l’expression booléenne est évaluée à vrai. i % ==
while ( 2 0) {
// instructions à exécuter tant que i est pair
}
• Il existe une variante de la structure précédente, nommée do-while :
do {
// instructions à exécuter
} while (i % 2 == 0);
• Une expression for permet de réaliser une itération. Tant que cette
expression booléenne est évaluée à vrai, le bloc d’instructions est
exécuté et un incrément est appelé. i= i< ++i
for (int 0;
// instructions
10; ){
}
Les structures de contrôle (suite 2)
• for amélioré : Il existe une forme améliorée de l’expression for (souvent
appelée for-each) qui permet d’exprimer plus succinctement un parcours d’une
collection d’éléments for (int i : maCollection) { // instructions à exécuter }
Pour que cette expression compile, il faut que la variable désignant la short arrayOfShort [] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
collection à droite de : implémente le type Iterable ou qu’il s’agisse for (int k : arrayOfShort) {
[Link](k);
d’un tableau. Il faut également que la variable à gauche de : soit }
compatible pour l’assignation d’un élément de la collection.
• break-continue : pour les expressions while, do-while, for permettant de
réaliser des itérations, il est possible de contrôler le comportement à l’intérieur
de la boucle grâce aux mots-clés break et continue. break quitte la boucle sans
exécuter le reste des instructions.
• Libellé :Il est possible de mettre un libellé avant une expression for ou while. La
seule et unique raison d’utiliser un libellé est le cas d’une itération imbriquée
dans une autre itération. Par défaut, break et continue n’agissent que sur le
bloc d’itération dans lequel ils apparaissent. En utilisant un libellé, on peut
arrêter ou continuer sur une itération de niveau supérieur
switch (c) { case 'a': case 'e': case 'i': case 'o': case 'u': case 'y': // instruction pour un voyelle break; default: // instructions pour une
consonne }
Les tableaux
• Les tableaux représentent des collections de valeurs ou d’objets. En
Java, les tableaux sont eux-mêmes des objets. Donc une variable de
type tableau peut avoir la valeur null. Une variable de type tableau se
déclare en ajoutant des crochets à la suite du type : int[] tableau; ou
int tableau[];
