COURS DE PROGRAMMATION JAVA

ULPGL/GOMA
FST
Promotion: L2 GEI 2025-2026

Par Msc. Ir. Daniella MUGHOLE

PLAN DU COURS
I. INTRODUCTION
II. NOTIONS DE BASE DE LA PROGRAMMATION JAVA
▪ Variables
▪ Operateurs
▪ Instructions conditionnelles
▪ Instructions itératives
▪ Tableaux
▪ Méthodes
III. PROGRAMMATION ORIENTEE OBJET
▪ Classes-objet
▪ Héritage
▪ Classes abstraites
▪ Interfaces
IV. INTERFACE GRAPHIQUE : JAVA SWING
 2. NOTIONS FONDAMENTALES
Structure d’un programme JAVA

Pour ce cours, on fera l’hypothèse que des notions algorithmiques de base sont acquises. Ainsi, on ne
va pas s’intéresser à l’implémentation d’algorithmes pour résoudre des problèmes particuliers et évaluer
leurs performances d’un point de vue théorique (déterminer le nombre d’opérations pour mener à bien
un calcul, ou bien évaluer les demandes en mémoire, etc.)
JAVA est un langage informatique .
Pour pouvoir écrire dans ce langage, il faut donc apprendre son vocabulaire et sa grammaire afin de
pouvoir communiquer avec la machine.
Le langage JAVA est un langage orienté objet. La plupart du temps, on manipulera des objets en leur
faisant faire des opérations. Un classe définit ce qu’un objet peut faire. Ceci deviendra plus clair dans la
suite du cours.
Le code JAVA s’écrit dans un fichier qui possède l’extension .java. Par convention, le nom d’une classe
est une chaîne de lettres (sans espace) qui commence toujours par une lettre majuscule, par exemple
MaPremiereClasse. Cette classe sera écrite dans le fichier [Link].
 2. NOTIONS FONDAMENTALES
JAVA est un langage, il possède donc une grammaire pour écrire des phrases dont la syntaxe est correcte.
La grammaire de JAVA est assez simple et est traduit par le compilateur. Le compilateur vérifie si toutes
les instructions ont un sens, par exemple si une variable utilisée a bien été déclarée, si une fonction est
appelée avec le bon nombre d’arguments et les bons types, etc.
Tous les programmes Java sont composés d’au moins une classe. Cette classe doit contenir une méthode
appelée main : ce sera le point d’entrée du programme.
La classe est définie par un mot clé class, précédé du mot clé public avec un nom (Bonjour) et que son
contenu est délimité par des accolades ({ }). Le code sources à exécuter s’écrit dans la méthode main:
 2. NOTIONS FONDAMENTALES
A. INSTRUCTIONS ET COMMENTAIRES
▪ Une instruction doit suivre la syntaxe du langage et toujours se terminer par un point-
virgule « ; »
▪ Un commentaire : est un texte qui va aider à expliquer le code. Un commentaire peut décrire le
code, ou bien justifier les instructions. Les commentaires sont ignorés par le compilateur.
Il existe trois formes de commentaires:
 2. NOTIONS FONDAMENTALES
Exemple: un programme qui permet de calculer et d’afficher la somme de deux entiers.

Commentaires de documentation

Commentaires sur plusieurs lignes

Commentaires sur une seule ligne

 2. NOTIONS FONDAMENTALES
B. IDENTIFICATEURS
Les identificateurs sont des noms symboliques permettant de référencer les éléments des programmes Java
comme variables, fonctions, classe, objet ....
Règles pour les identificateurs:
⁃ Un identificateur peut contenir des lettres, des chiffres ainsi que des symboles underscore « _ » et $
⁃ Un identificateur doit commencer par une lettre, un underscore ou un $.
⁃ Un identificateur ne doit pas commencer par un chiffre
⁃ Un identificateur ne doit pas contenir d’espace, des accents
⁃ De manière générale, l’identificateur d’une variable, d’une fonction, d’un objet commence par une
lettre minuscule et l’identificateur d’une classe commence par une lettre majuscule.
⁃ Lorsqu’un identificateur comprend plusieurs mots, chaque mot commence par une lettre majuscule ou
séparés par un tiret ou un underscore
⁃ Un identificateur doit avoir un sens (généralement il doit représenter sa fonction, son rôle)
⁃ Un identificateur doit être facile à mémoriser, et ne doit pas être un mot clé (if,switch,class,public,etc)
Exemple: ClasseDesPersonnes, nom, _total, calculPerimetre, nombre1, valeur-absolue, resultat_total, …

NB: Java est un langage sensible à la casse ce qui signifie qu’il y a une différence entre les majuscules et
les minuscules.
Exemple: A est différent de a , Nombre est différent de nombre.
 2. NOTIONS FONDAMENTALES
C. VARIABLES ET TYPES
Une variable est un élément qui stocke des informations de toute sorte en mémoire : des lettres, des
chiffres, des résultats de calcul, des tableaux, des renseignements fournis par l'utilisateur. Vous ne pourrez
pas programmer sans variables. Avant de pouvoir être utilisée, une variable doit préalablement être
déclarée cad définir son identificateur et son type.
- L’identificateur est le nom de la variable
- Le type définit le genre d'informations qui sera enregistré ainsi que les opérations qui pourront être
effectuées sur ces informations. Il existe un certain nombre de types prédéfinis mais il est
également possible de créer ses propres types.

Syntaxe:

Exemple: int age; , double resultat; , String prenom; , float quotient;

Comme toute instruction dans java, la déclaration d’une variable se termine toujours par un point-virgule.
Dans certains langages, on n’a pas besoin d’explicitement déclarer le type de chaque variable ou les
variables peuvent changer de type. Il n’en est pas ainsi pour java. Pour ces raisons, on dit que le langage
java est fortement typé.
 2. NOTIONS FONDAMENTALES
Il y a plusieurs variantes pour déclarer des variables :
i. Déclaration simple : <type> <nom> ;
Elle permet de déclarer une variable en indiquant tout d’abord son type puis son nom. Avec java , il n’y a pas
de valeur par défaut, toute variable doit donc être initialisée avant toute utilisation. En utilisant cette variante
de déclaration, il faudra dans le code initialisée la variable.
Exemple: int nombre;
char choix;
ii. Déclaration avec affectation : <type> <nom> = <valeur(correspondant au type)>, <une autre
variable>, <une expression> ;
On affecte une valeur à une variable avec le signe d’égalité (=). On peut aussi déclarer une variable et
l’initialiser en une seule instruction. Pour l’initialisation, on a le choix entre donner directement une valeur (de
même type), utiliser la valeur d’une autre variable, utiliser une expression dont l’évaluation aura le bon type.
Exemple: int valeur = 5; double impot = 5673.976; byte cote = valeur; int perimetre = cote * 4;
iii. Déclaration multiple : <type> <nom1>, <nom2>, : : :, <nomk> ;
On peut déclarer plusieurs variables qui ont le même type dans la même instruction sans les initialiser.
Exemple: float quotient, resultat, note; int a,b,age,k;
iv. Déclaration multiple avec affection partielle : <type> <nom1>, <nom2> = <valeur selon le
type>,…<nomk> ;
Exemple: char choix, genre = ‘M’; int nombre, k = 8, longueur = 5, hauteur;
 2. NOTIONS FONDAMENTALES
▪ Une variable qui ne doit pas changer de valeur est déclarée avec le mot clé final. C’est donc une
constante
Exemple: final double Pi=3.14; final int nombreMoisAnnee = 12;
▪ Les variables ont une visibilité (portée) et une durée de vie qui dépendent du contexte dans lequel elles
sont déclarées.
▪ Le type d'une variable peut être soit un type primitif, soit un type référence (c'est-à-dire le nom d'une
classe ou d'un tableau)
Exemple:

i. Types primitifs
Java fournit huit types primitifs que peuvent prendre des variables. Lorsqu’une variable est déclarée
à l’aide d’un de ces types, un espace (de taille correspondant au type) est automatiquement réservé en
mémoire.
Les types primitifs sont: boolean, char, byte, short, long, int(interger), float, double
 2. NOTIONS FONDAMENTALES
Dans le tableau suivant, on indique la taille mémoire en bits occupée par la variable.
 2. NOTIONS FONDAMENTALES
Représentation en mémoire d’une variable
De manière interne, la zone mémoire allouée à une variable est identifiée par une adresse. Cette adresse est
complètement cachée au programmeur : l'accès à la zone mémoire s'effectue en utilisant le nom de la
variable.
 2. NOTIONS FONDAMENTALES

➢ Booléen (boolean)
• Ne peuvent prendre que deux valeurs : true ou false
• Ne peuvent pas être interprétés comme des valeurs numériques [0, 1]
• Valeurs littérales (valeurs qui figurent directement dans le code): true => vrai et false => faux
➢ Caractère (char)
• Caractères Unicode (codage normalisé sur 16 bits): un seul caractère
• le nombre 15 comprend deux caractères donc ne peut pas être une valeur de type char
• Peuvent être traités comme des entiers (non-signés)
• Valeurs littérales entre apostrophes : 'A' (attention : "A" n'est pas de type char),
• l’espace est un caractère (" ")
➢ Entiers signés (byte, short, int, long):
• Valeurs littérales (int par défaut) : notation habituelle
• Suffixe l ou L pour type long (L est préférable)
• Préfixe 0 (zéro) pour valeur octale (base 8)
• Préfixe 0b ou 0B pour valeur binaire (base 2)
• Préfixe 0x ou 0X pour valeur hexadécimale (base 16)
 2. NOTIONS FONDAMENTALES
Exemple:

➢ Nombres en virgule flottante (float, double)

• Précision : - float : env. 6 chiffres significatifs-
- double : env. 15 chiffres significatifs
• Valeurs littérales (double par défaut)
• Suffixe f ou F pour type float
• Suffixe d ou D pour type double (rarement nécessaire)
• Notation exponentielle avec e ou E suivi de l'exposant
• Valeurs spéciales : infini, -infini, zéro négatif, NaN (Not a Number)
Exemple:
 2. NOTIONS FONDAMENTALES
ii. Types références
En plus des huit types primitifs, Java définit deux autres catégories de types de données :
- les classes
- les tableaux
qui seront étudiés en détail plus tard.
➢ Les classes et les tableaux sont des types généralement composites (représentant des valeurs multiples).
➢ Ils sont collectivement nommés : Types "Référence"(on parle également parfois de types non-
primitifs).
➢ Pour une variable de type référence, la case mémoire ne contient pas directement les valeurs de la
variable mais une référence (une sorte de pointeur) vers une autre zone mémoire contenant les valeurs

➢ Les chaînes de caractères ne font pas partie des types primitifs

➢ Les chaînes de caractères font partie des types référence (ce sont des objets de la classe String)
➢ Syntaxe particulière (simplifiée) pour les valeurs littérales :
• Texte entre guillemets (" ")
• Peuvent contenir des séquences d'échappement identiques à celles définies pour les types char
• Ne peuvent pas s'étendre sur plusieurs lignes
 2. NOTIONS FONDAMENTALES
• Concaténation (mise bout à bout) avec l'opérateur « + »
• Conversions possibles : du type primitif vers String
Exemple: String prenom = ‘’Alice‘’; String pays = ‘’Guinee equatoriale‘’;
iii. Conversion des types ou casting
On a dit que chaque variable avait un type et qu’une variable ne pouvait pas changer de type. Cependant, on
peut utiliser une variable d’un type pour initialiser une variable d’un autre type commensurable.
On déclare avec affectation une première variable et on va l’utiliser pour initialiser une seconde variable.
Si les variables ont le même type, il n’y a pas de problème, mais JAVA nous permet d’utiliser des types
commensurables. Mis à part le type booléen, tous les types primitifs peuvent être convertis entre eux.
➢ Conversion implicite(automatique): si le <type1> est « moins fort » que le <type2> : le <type2> va
utiliser toute l’information du <type1> sans perte. Par exemple si le <type1> est un int et le <type2> est
un double, le double utilisera la valeur de l’entier (et la partie après la virgule est initialisé à zéro).
Exemple:

Dans certains cas il y a une perte éventuelle de précision lors du passage en virgule flottante.
 2. NOTIONS FONDAMENTALES
➢ Conversion restrictive explicite (par transtypage / casting): sous la responsabilité du programmeur.
La conversion doit devenir explicite si le <type1> est « strictement plus fort »que le <type2> : il faut
indiquer au compilateur d’effectuer la conversion. Pour forcer la conversion, il faut indiquer le type cible de la
conversion entre parenthèses comme suit :

Exemple:

La valeur du type « plus fort » est tronquée pour pouvoir prendre le type « plus faible ». Par exemple, pour
convertir un double ou un float en un int, JAVA tronque la partie derrière la virgule. Dans les exemples ci-
dessous valeurEntiere sera égale à 3 et i sera 23.
 2. NOTIONS FONDAMENTALES
➢ Conversion types primitifs vers String (chaines des caractères):Il est possible de convertir des
valeurs de types primitifs en chaînes de caractères (String) et inversement en utilisant des fonctions
(méthodes) disponibles dans des classes appelées Wrappers.

D'autres fonctions de conversion sont également disponibles dans la classe String, notamment la méthode
valueOf() qui permet de convertir en String les valeurs de tous les types primitifs.
 2. NOTIONS FONDAMENTALES
Exemple:

j est donc une variable de type String contenant la chaîne de caractères 12

Attention : Ne pas confondre les littéraux de type caractère ou chaîne de caractères avec les littéraux
numériques.
Par exemple '4', "4" et 4 : Le premier est un caractère (type char), le deuxième une chaîne de caractères (type
String) et le troisième est une valeur numérique entière (type int).
 2. NOTIONS FONDAMENTALES
D. OPÉRATEURS
Les opérateurs sont des éléments syntaxiques qui effectuent certaines opérations en utilisant
les valeurs de leurs opérandes (paramètres de l'opération).

On distingue:
 2. NOTIONS FONDAMENTALES
i. Précédence et Associativité
 2. NOTIONS FONDAMENTALES
ii. Operateurs arithmétiques
Ils effectuent des opérations arithmétiques et retournent des résultats numériques. Le type du résultat
dépend du type des opérandes. Si nécessaire, une conversion implicite (automatique) des opérandes est
effectuée avant l'opération.
• « + » : permet d'additionner deux variables numériques (mais aussi de concaténer des chaînes de
caractères.
• « - » : permet de soustraire deux variables numériques.
• « * »: permet de multiplier deux variables numériques.
• « / »: permet de diviser deux variables numériques.
• « % »: permet de renvoyer le reste de la division entière de deux variables de type numérique ; cet
opérateur s'appelle le modulo.
• « ^ »: permet d’éléver à une puissance
Exemple:
 2. NOTIONS FONDAMENTALES
iii. Operateurs relationnels
Effectuent des opérations de comparaison et retournent des résultats booléens

iv. Operateurs logiques

Ils effectuent des opérations logiques et retournent des résultats booléens.
 2. NOTIONS FONDAMENTALES
Les tableaux suivants contiennent les différents opérateurs de JAVA . Les tableaux inclus la priorité de
l’opérateur pour que les expressions ne soient pas ambigües. On peut ajouter des parenthèses pour qu’une
expression complexe soit plus lisible.

- L’incrémentation: On ajoute automatiquement 1 à

la variable
identificateur++;
- La décrémentation: On retranche automatiquement 1
à la variable
identificateur- -;
 2. NOTIONS FONDAMENTALES
▪ Enregistre dans l'opérande de gauche (variable) la valeur de l'opérande de droite (valeur de
l'expression)
▪ Le type de la variable (opérande de gauche) doit être compatible avec le type de l'expression de droite
(si nécessaire, conversion automatique)
▪ Le type et valeur de retour d'une expression d'affectation correspondent au type de la variable et,
respectivement, à sa valeur après affectation
▪ Attention : Ne pas confondre l'opérateur d'affectation (=) avec celui d'égalité (= =). L’affectation
signifie "prend pour valeur" et non pas "est égal à ".

Exemple:

• Combinaison de l'affectation avec un opérateur arithmétique

• Le type de l'opérande de gauche (variable) doit être compatible avec le type de l'expression de droite
 2. NOTIONS FONDAMENTALES
Les opérateurs combinés:

Exemple:

L’affectation d’une variable peut être fait à l’aide d’une expression. Pour certaines expressions très
utilisées (incrémente un entier d’une unité par exemple), JAVA propose des raccourcis :
▪ ++x incrémente x de 1 puis utilise sa valeur pour l’expression
▪ x++ utilise la valeur de x pour l’expression puis incrémente x
▪ i += 5 est le raccourci de i = i+5
Exemple:

Après l’exécution de la ligne 1, i vaut 3 et j vaut 2. Après l’exécution de la ligne 3, i et j valent 3.

Une erreur très classique est l’utilisation du symbole = à la place de == pour l’égalité. Pour JAVA ,
l’expression i=k a bien un sens car c’est l’affectation de la variable i avec le contenu de la variable j.
 2. NOTIONS FONDAMENTALES
▪ Il existe un opérateur conditionnel ternaire qui affecte la valeur d’une variable en fonction d’un test :

Si le test (une expression booléenne) someCondition est vérifié, alors la variable result prend la valeur
value1, sinon elle prend la valeur value2.
Exemple: absX prend pour valeur celle de la valeur absolue de x.

▪ Le transtypage explicite peut être vu comme un opérateur unaire qui a une priorité haute. Lors des
opérations de transtypage explicite, il faut bien faire attention à la portée du transtypage, i.e. sur quelle
expression porte le transtypage.

La valeur de y après l’exécution de la ligne 2 sera 4 car la conversion porte simplement sur x, et donc la
multiplication s’opère entre int. La valeur de z après exécution sera 5 car la conversion porte sur le résultat
de la multiplication entre un double et un int, qui est un double.
SESSION DES TPS