PARTIE II : INTRODUCTION À LA

PROGRAMAMTION
1. La programmation et langages de programmation
La programmation est définie comme le fait de donner des instructions à
un ordinateur.

Étant donné qu’un ordinateur ne comprend qu’un seul langage, qui est le
langage binaire, un être humain doit normalement utiliser le langage
binaire pour communiquer avec un ordinateur.

Les langages binaires, difficile à utiliser pour donner assez d’instructions, il

y a eu création de langages de programmation qui sont beaucoup plus
compréhensibles par un être humain pour donner des instructions à un
ordinateur.

Parmi ces langages nous avons : Java, C, C++, C#, Kotlin, Swift, Objective-
C et tant d’autres.

Après qu’un être humain ait donné ses instructions en utilisant un langage
de programmation, ses instructions sont ensuite converties à l’aide d’un
programme appelé compilateur en langage binaire pour une bonne
exécution par l’ordinateur.

2. Outils de développement

L’objectif de ce cours est de permettre à l’apprenant d’apprendre les

bases de la programmation en utilisant le langage de la programmation
java, pour ce faire un programmeur a besoin de certains outils pour
donner des instructions à un ordinateur.

Les outils les plus utilisés sont les suivant :

a) Éditeur :

Un éditeur, c’est un programme utilisé par le programmeur pour donner

des instructions à l’ordinateur, c’est le siège où les instructions sont
écrites en utilisant un langage de programmation.

Il existe plusieurs types des éditeurs utilisés pour écrire nos codes, parmi
eux nous avons :

Visual Studio Code, Sublime, Notepad++, Dreamweaver, etc…

b) Compilateur
Comme cité plus haut, nos instructions écrites par un langage de
programmation doivent être converties en binaire, le programme
responsable de cette conversion est le compilateur.

A cet effet, pour chaque langage de programmation que nous voudrions

utiliser, il nous faudra un compilateur pour la conversion des instructions
écrites en ce langage vers le langage binaire

c) Integrated Development Environment (IDE) :

Pour programmer il faut nécessairement la présence d’un éditeur et d’un

compilateur ainsi que d’autres programmes qui nous permettent de
programmer, alors, installer chaque programme séparément puis les
configurer pour les utiliser ensemble présentait un casse-tête , C’est ainsi
que les concepteurs de langages de programmations ont dû développer
les environnements de développement intégré qui sont en fait des
logiciels qui comprennent l’éditeur, le compilateur et tout autre
programmes nécessaires, intégrés dans un seul programme (IDE).

De nos jours, il existe plusieurs environnements de développement intégré

(IDE), adapté pour être utiliser avec des langages de programmation
appropriés.

Quelques exemples des IDEs sont :

No# Environnement deLangages supportés

Développement
Intégré
1. Netbeans Java, C, C++, PHP, Python
2. Eclipse C, C++, Java, Python, PHP
3. Pycharm Python
4. Android Studio Java, Kolin
5. Xcode Swift, Objective-C

N.B : Certains IDE peuvent supporter plusieurs langages de

programmations.

Pour notre Apprentissage du langage Java, nous allons utiliser l’IDE :

Netbeans
 3. Introduction du langage JAVA
3.1 Introduction

Java est un langage orienté objet à usage général, c’est-à-dire java peut
être utilisé pour développer plusieurs types d’applications telles que :

- Application Desktop
- Application Web
- Application Mobile

Exemple d’un programme en JAVA :

/* Notre premier programme en JAVA */

class PremierProgram {

public static void main(String args[]){

// Affichage du message
[Link](“Hello Word!”);
}
}

Le programme ci-dessus est surement l’un de programme le plus simple

que vous pouvez écrire en JAVA, cependant il démontre plusieurs aspects
du langage JAVA que nous allons voir par la suite.

3.2 La JDK (Java Developpement Kit)

La JDK, ou Java Development Kit, est un ensemble complet d'outils

nécessaires pour développer des applications en Java. Elle inclut le
compilateur, les bibliothèques, les outils de débogage, et plus encore. La
JDK est indispensable pour écrire, compiler et exécuter des programmes
Java.

Composants principaux de la JDK :

1. Java Compiler (javac) :

 Compilation : Le compilateur Java (javac) convertit le code

source (.java) en bytecode (.class) que la JVM (Java Virtual
Machine) peut exécuter.
 Syntaxe : Vérifie la syntaxe et les erreurs de compilation
avant l'exécution.

2. Java Runtime Environment (JRE) :

  JVM : La machine virtuelle Java (JVM) exécute le bytecode
Java.
 Bibliothèques de classes : Contient les classes standard
requises pour exécuter des programmes Java.

3. Bibliothèques standard :

 API : La JDK inclut une vaste bibliothèque de classes couvrant

des fonctionnalités de base telles que les collections, les E/S,
les réseaux, l'interface utilisateur, etc.

4. Outils de développement :

 java : Commande pour lancer l'exécution d'une application

Java.
 javadoc : Génère la documentation à partir des commentaires
dans le code source.
 jdb : Outil de débogage pour analyser et corriger les
programmes Java.
 javap : Désassembleur de classes pour analyser les
fichiers .class.

3.3 Types de données, variables

C’est pourquoi, qu’il est très nécessaire de maitriser et de comprendre

comment l’ordinateur comprend et manipule les données reçues.

1. Type de données

Le langage de programmation JAVA met à notre dispositions plusieurs

types de données que nous pouvons utiliser pour présenter nos données
(informations) à la machine.

Les types de donnés sont subdivisés en deux grandes parties : primitifs et

non primitifs.

Types de données

Primitifs Non Primitifs

Classes Arrays
 Numérique Non-Numérique

Entier Flotant
Interface

Chaines caractères booléens

1.1. Les Numériques

 Les Entiers

Java prévoit plusieurs types de données pour représenter les nombres entiers :

Type Capacité Minimum Maximum

Byte 1 Octet -128 128
Short 2 Octets -32,768 32,767
Int 4 Octets -2, 147, 483, 648 2, 147, 483, 647
-9, 223, 372, 036, 854, 9, 223, 372, 036,
long 8 Octets
775,808 854,775,807

 Les flottants

Les types de données se trouvant dans la catégorie de flottant sont utilisés

pour représenter les nombres décimaux.

Type Capacité Nombre de chiffres après la

virgule
float 4 octets 7
Double 8 octets 15

Pour représenter les nombres décimaux, on utilise float ou double, le choix

de l’un par rapport à l’autre est fait sur base de la précision du nombre
qu’on veut avoir, c’est-à-dire le nombre de chiffre après la virgule. Float
peut contenir jusqu’à 7 chiffres après la virgule, et double peut contenir
jusqu’à 15 chiffres.

1.2. Les Non-Numériques

Pour la représentation de données non numériques, java prévoit deux

types de données :
Type Description
char Ce type de donnée est utilisé pour représenter un caractère
Ce type de donnée ne peut représenter que deux valeurs : true
boolean
ou false

 Les chaines de caractères

La classe String est utilisé pour stocker une chaine de caractères. Cette
classe contient plusieurs propriétés et méthodes nous permettant de créer
et manipuler notre chaine de caractères sans se soucier des problèmes
que l’on peut rencontrer en utilisant la chaine de caractères sous forme
des tableaux.

Syntaxe générale :

String identifiant = “Bonjour tout le monde”;

D’une manière générale, une chaine de caractères est créée comme

représenté ci-dessus. À noter que la chaine de caractères est toujours
placé entre guillemets.

Les tableaux ci-dessous présentes quelques méthodes utilisées pour

manipuler les chaines de caractères

Méthode Description
concate(String str) Compare la chaine de caractères avec une autre
chaine de caractères str
equalsIgnoreCase(Str Compare la chaine de caractères avec une autre
ing str) chaine de caractère sans tenir compte des
majuscules et minuscule
endsWith(String str) Vérifie si la chaine de caractères se termine par la
chaine de caractère spécifié
startsWith(String str) Vérifie si la chaine de caractères commence par la
chaine de chaine de caractères spécifié.
length() Retourne le nombre de caractères.
isEmpty(String str) Vérifie si une chaine de caractère est vide.

2. Les Variables

Une variable dans un programme est un identifiant qui représente un

espace dans la mémoire.

Pour bien manipuler nos données dans un programme, il est important que
nous puissions d’abord stocker ces données dans la mémoire à l’aide des
variables et des types de données
 2.1. Déclaration d’une variable

type de donnée nom_de_la_variable ;

La syntaxe nous montre comment on peut déclarer une variable dans un

programme en java.

2.2. Affectation d’une variable

La déclaration d’une variable est juste le fait de notifier au système que

nous aurons besoin d’un espace dans la mémoire pour stocker une valeur
quelconque par rapport au type de donnée présent dans la déclaration,
c’est-à-dire qu’à ce niveau les variables déclarées ne contiennent rien
comme valeurs, dans certains cas elles contiennent des valeurs par défaut
mais la plupart de cas elles ont une valeur nulle.

C’est ainsi, nous devons donner ou affecter des valeurs aux variables
déclarées.

Affectation d’une variable :

type de donnée Nom_de_variable = valeur ;

Le signe = est utilisé comme signe d’affectation, il sera utilisé pour

affecter des valeurs à une variable, à gauche du signe = nous avons le
nom de la variable et à droite nous avons la valeur qui doit être stocker
dans la variable.

Exemple :

float temperature ; // Déclaration

temperature = 25.5 ; // affectation

int age ; // Déclaration

age = 30 ; // Affectation

Nous pouvons aussi affecter une variable lors de sa déclaration :

float temperature = 25.5 ; // Affectation plus déclaration

double salaire = 13000.50 ;

3.4 Opérateurs et expressions

Le langage Java prévoit un ensemble riche en operateurs. Nous avons eu à
utiliser quelques-uns tels que : +, -, * , /.

Un operateur est un symbole utilisé pour faire des opérations

mathématiques ou logiques. Les opérateurs sont utilisés dans un
programme pour manipuler les données et les variables, ils font
généralement partie d’une expression mathématique ou logique.

Les types d’opérateurs sont :

 Operateurs arithmétiques
 Operateurs Logique
 Operateurs Relationnelles
 Operateurs d’affectations
 Operateurs d’incrémentation et de décrémentation
 Operateurs Conditionnelles

1. Opérateurs Arithmétiques

Opérateurs Description
+ Addition
- Subtraction
* Multiplication
/ Division
% Modulo (Le reste de la division)

2. Opérateurs Relationnelles
Opérateur Description
s
> Supérieure à
< Inferieure à
>= Supérieure ou égale à
<= Inferieure ou égale à
== Égale à
!= N’est pas égale à

3. Opérateurs Logique

Opérateur Description
s
&& && (Et) retourne « true » uniquement si chacune des
 opérandes a et b sont vraies.
|| || (Ou) retourne « true » si au moins une des deux opérandes a
et b est vraie.
! La négation inverse la vérité d’un opérande de « true » à
« false » ou vice versa.

4. Operateurs d’affectations

Opérateur Description
s
= Affectation

5. Operateurs d’incrémentation et décrémentation

OpérateursDescription
++ incrementation
-- décrementation
 3.5 Structure de contrôle

Le langage JAVA prévoit plusieurs structures nous permettant de poser

certaines conditions avant d’exécuter un groupe d’instructions
quelconque.

Il s’agit :
 IF
 IF – ELSE
 IF - ELSE IF ELSE

1. IF
if est la structure de condition la plus simple, elle est utilisée pour poser
une condition avant d’exécuter un groupe d’instructions.

La syntaxe générale est :

if(condition)
{

// block instruction

En se basant sur la syntaxe générale, le block d’instructions n’est exécuté

que lorsque la condition est vraie.

La condition est représentée par une expression qui aura comme résultat
Vrai ou Faux ou encore toute expression arithmétique.

Lorsqu’il s’agit d’une expression arithmétique, la condition est considérée

comme vraie lorsque le résultat de l’expression est un nombre supérieur à
0 et fausse au cas contraire.

2. IF – ELSE

If – else est utilisé pour exécuter un groupe d’instruction lorsque la

condition est vraie et un autre groupe d’instruction au cas où la condition
est fausse.

La syntaxe générale se présente comme suit :

if(condition)
{
// block instruction
}
else
{
// block instruction
}
L’exécution de If-Else se présente comme suit :

Entrée

FAUSSE VRAIE
condition

Block d’instruction à Block d’instruction à

exécuter lorsque la exécuter lorsque la
condition est fausse condition est vraie

Suite du
programme

Comme illustré ci – haut , l’exécution de if-else commence d’abord par

vérifier la condition spécifiée , lorsque la condition est vraie, les
instructions spécifiées dans le bloc de if sont exécutées. Au cas où la
condition est fausse, les instructions spécifiées dans le boc de else sont
exécutées.

3. IF – ELSE IF- ELSE

La structure if-else-if est une autre forme de condition qui nous permet de
faire la vérification de plusieurs conditions, jusqu’à ce que la condition soit
satisfaite.

La syntaxe générale de if – else if

if(condition){

// bloc d’instructions

} else if(condition){

// bloc d’instructions

} else if(condition){

// bloc d’instructions

…
}else{
// bloc d’instructions
}
L’exécution d’if-else-if se passe comme suite :

- La condition du premier if est vérifié, si la condition est vraie, son le

bloc d’instructions est exécuté, et le fil d’exécution est ramené
jusqu’à la suite du programme.

- Si la condition du premier if est fausse, la condition du else if

suivant est vérifiée, si elle est vraie, son bloc d’instruction est
exécuté et l’exécution est ramenée jusqu’à la suite du programme.
Au cas contraire la condition de else-if suivant est vérifiée.

- L’exécution continue de cette manière jusqu’à ce que toutes les

conditions des else if seront testées. Et si aucune condition n’est
vraie, le dernier bloc, le bloc de else est exécuté par défaut.

3.6 Les boucles

Un ordinateur est excellent lorsqu’il s’agit d’exécuter des tâches

répétitives, c’est ainsi le langage JAVA nous donne aussi la possibilité
d’exécuter certaines instructions plusieurs fois.

Dans une boucle, un bloc d’instructions est exécuté jusqu’à ce que la

condition pour sortir de la boucle est satisfaite.

Entré

Fausse

condition

Vraie

Corps de la boucle

Sortie
Le langage Java Prévoit trois types de boucles :

 While
 Do
 For

1. While

La plus simple de structures de boucle est la structure while.

La syntaxe générale se présente comme suit :

// Initialisation
while(verification de la condition){

// bloc d’instruction : corps de la boucle

}

Premièrement la condition est vérifiée, si la condition est vraie, alors le

bloc d’instruction est exécuté, après l’exécution du bloc d’instruction, la
condition est vérifiée encore une fois de plus, si la condition est toujours
vraie, le bloc d’instruction sera encore exécuté, ce processus continue
ainsi, jusqu’à ce que la condition sera fausse.

2. For

La boucle For est une autre forme de structures de boucles avec une
syntaxe beaucoup plus claire et concise nous permettant d’exécuter nos
boucles facilement.

La syntaxe générale :

for (initialization; condition; incrementation) {

// corps de la boucle
}

L’instruction For est constituée de trois parties essentielles :

- Initialisation : Il s’agit de déclarer et initialiser la variable qui jouera
le rôle du compteur, il nous permettra de tester la condition pour
savoir à quel moment nous sortirons de la boucle.
- Condition : Cette partie nous permet de tester la condition, aussi
longtemps que la condition est vraie, le bloc d’instructions sera
exécuté, une fois que cette condition devient fausse, nous sortons
de la boucle.
- Incrémentation : cette partie est utilisé pour modifier la valeur du
compteur.
 3. Do While

Do-While est une structure de boucle similaire à while, à la seule

différence do-while, vérifie la condition après avoir exécuté le corps de la
boucle.

La syntaxe générale de do-while se présente comme suit :

// Initialisation
do
{
// Corps de la boucle

}while(condition);

Quand l’exécution du programme atteint l’instruction do, le corps de la

boucle est exécuté, après l’exécution, la condition est vérifiée, si elle est
vraie, le corps de la boucle sera exécuté encore une fois de plus, au cas
contraire l’exécution s’arrête. Lorsque la condition est vraie, l’exécution
continue.
 3.7 Les Tableaux et Listes
1. Les Tableaux

Une variable ne peut stocker qu’une et une seule valeur à un temps

précis, même si la valeur d’une variable peut changer, une variable ne
contiendra qu’une seule valeur. Cependant il existe des situations où nous
avons besoin de stocker plusieurs valeurs similaires.

C’est pourquoi le langage JAVA prévoit une structure appelée tableau

(array en anglais) qui nous permet de stocker plusieurs valeurs sous un
même identifiant.

Un tableau est donc un ensemble d’éléments du même type de données

stocké de manière consécutive dans la mémoire

Salaire

1300 [0]

3200 [1]
800
[2]
1500
[3]
1000
[4]

La figure ci-dessus, représente la manière dont un tableau est organisé.

- L’identifiant salaire représente le nom du tableau, donc il s’agit ici

d’un tableau appelé salaire avec cinq éléments.

- Les valeurs se trouvant dans chaque case, 1300, 3200, 800, 1500,
1000 représentent les informations se trouvant dans le tableau, dans
notre contexte il s’agit de cinq salaires stockés.

- Le nombre se trouvant à droite du salaire, appelé indice, représente

la position d’une information dans le tableau, comme on peut le
constater, la position des éléments dans un tableau commence
toujours par 0.

2. Les listes

Contrairement aux tableaux, les listes sont des structures de données

dynamiques qui permettent de stocker des éléments de manière flexible.
Alors que les tableaux ont une taille fixe dès leur création, les listes
peuvent changer de taille à tout moment, en permettant l'ajout ou la
suppression d'éléments sans avoir à redimensionner manuellement la
structure.

Prenons l'exemple d'une liste qui stocke des noms d'employés :

List<String> employes = new ArrayList<>();

[Link]("Alice");
[Link]("Bob");
[Link]("Charlie");

Ici, employes est une liste de type ArrayList, une implémentation courante
de la collection List en Java. À la différence d'un tableau, vous pouvez
ajouter autant d'éléments que vous le souhaitez sans avoir à définir une
taille fixe dès le départ.

Caractéristiques des Listes :

1. Flexibilité : Les listes permettent d'ajouter ou de supprimer des

éléments à n'importe quelle position, offrant une grande flexibilité
dans la gestion des données.
2. Manipulation Facilitée : Les listes en Java offrent une API riche
avec des méthodes pour trier, filtrer, et manipuler les éléments de
manière pratique.
3. Accès Indexé : Comme les tableaux, les listes permettent
également d'accéder aux éléments via un indice. Par exemple,
[Link](0) retournera "Alice".
4. Types de Listes en Java :
- ArrayList : Basée sur un tableau dynamique, idéale pour les
opérations d'accès rapide.
- LinkedList : Basée sur une chaîne de nœuds, idéale pour les
opérations fréquentes d'ajout et de suppression
- ObservableList : Une liste qui peut informer
automatiquement les observateurs lorsqu'un élément est
ajouté, supprimé ou modifié, couramment utilisée dans les
applications JavaFX pour des interfaces dynamiques.

2.1. Les ArrayList

Une ArrayList est une des implémentations les plus couramment utilisées
de l'interface List en Java. Contrairement aux tableaux traditionnels, une
ArrayList offre une flexibilité remarquable grâce à sa capacité à
redimensionner dynamiquement, ce qui en fait un choix idéal pour les
scénarios où la taille des données peut varier.
Caractéristiques des ArrayList :

 Taille Dynamique :

Contrairement à un tableau dont la taille est fixe, une ArrayList peut

grandir ou rétrécir à mesure que vous ajoutez ou supprimez des éléments.
La gestion de la taille est automatisée par la classe ArrayList elle-même,
ce qui simplifie grandement le code.

Exemple:

ArrayList<String> noms = new ArrayList<>();

[Link]("Alice");
[Link]("Bob");
[Link]("Charlie");

Dans cet exemple, la ArrayList "noms" commence vide et s'agrandit

automatiquement au fur et à mesure que des noms sont ajoutés.

 Accès Rapide aux Éléments :

Les éléments dans une ArrayList sont stockés de manière contiguë en

mémoire, ce qui permet un accès rapide (en temps constant, O(1)) aux
éléments via leur index. Cela en fait une structure de choix pour les
scénarios où les éléments doivent être fréquemment accédés ou modifiés
par leur position.

Exemple :

String nom = [Link](0); // Accède à "Alice", le premier

élément de la liste

 Manipulation Facile :

L’ArrayList fournit de nombreuses méthodes pratiques pour manipuler les

données, comme add(), remove(), set(), et contains(), ce qui permet une
manipulation flexible des éléments.

Exemple :

[Link]("Bob"); // Supprime "Bob" de la liste

[Link](0, "David"); // Remplace "Alice" par "David" au
premier indice
 2.2. Les ObservableList

Une ObservableList est une extension spéciale des listes classiques en

Java, utilisée principalement dans le cadre d'applications JavaFX pour les
interfaces graphiques. Ce type de liste est conçu pour informer
automatiquement les observateurs de tout changement, tel que l'ajout, la
suppression ou la modification d'un élément dans la liste. Cela en fait un
outil essentiel pour créer des interfaces utilisateur réactives et
dynamiques.

Caractéristiques des ObservableList :

 Utilisation en JavaFX :

ObservableList est couramment utilisée dans les applications JavaFX pour

créer des interfaces utilisateur réactives. Par exemple, si vous avez une
liste de noms affichée dans une interface, et que vous ajoutez un nom à la
ObservableList, la vue liée à cette liste se mettra à jour automatiquement.

Exemple :

ObservableList<String> noms = [Link]();

[Link]("Alice");
[Link]("Bob");

 Manipulation Facile :

L’ObservableList fournit de nombreuses méthodes pratiques pour

manipuler les données, comme add(), remove(), setItems(), et contains(),
ce qui permet une manipulation flexible des éléments.

2.3. Les HashMap

Un HashMap est une structure de données qui permet de stocker des

paires clé-valeur, ce qui le différencie des tableaux et listes où les
éléments sont stockés simplement dans un ordre linéaire.

 Utilisation d'un HashMap

HashMap<String, Integer> ages = new HashMap<>();

[Link]("Alice", 30);
[Link]("Bob", 25);

Dans cet exemple, ages est un HashMap où les noms des personnes sont
utilisés comme clés pour accéder à leurs âges respectifs.
Caractéristiques des HashMap :

1. Associations Clé-Valeur : Contrairement aux listes et tableaux, un

HashMap permet d'associer chaque élément (valeur) à une clé
unique. Par exemple, dans notre cas, "Alice" est la clé qui permet
d'accéder à la valeur 30.
2. Accès Rapide : Grâce à la structure de hachage, les opérations
d'insertion, suppression, et recherche de valeurs sont généralement
très rapides (en temps constant, O(1)).
3. Non-Ordonné : Les éléments dans un HashMap ne sont pas stockés
dans un ordre particulier, contrairement aux listes où l'ordre
d'insertion est maintenu.

 Manipulation Facile :

Le HashMap fournit de nombreuses méthodes pratiques pour manipuler

les données, comme put(), remove(), setItems(), et get(), isEmpty() ce qui
permet une manipulation flexible des éléments.
4. Introduction à JavaFX

JavaFX est une bibliothèque graphique pour Java qui permet de créer des
applications riches en fonctionnalités et interactives. Elle est souvent
utilisée pour développer des applications de bureau modernes avec des
interfaces utilisateur sophistiquées.

Principales caractéristiques de JavaFX :

- Interface utilisateur riche

- Styles et thèmes
- Responsive Design
- Animations et effets

4.1. La création d’un projet JavaFX sur NetBeans :

Pour créer un nouveau projet JavaFx depuis Netbeans, il suffit de cliquer

sur le menu fichier>new project.

4.1.1. Paramétrer son projet

Sur l’interface ci-dessous, il nous ait demandé de placer le nom du projet

ainsi que le nom de notre première interface.

La convention de nommage courante est le PascalCase. En PascalCase,

chaque mot commence par une majuscule et aussi utilisé pour les noms
de classes, d'interfaces, et de projets.
Exemple : GestionFormation, GestionPharmacie,
InventoryManagementSystem, etc…

4.2. Le Modèle MVC (Model-View-Controller)

Le modèle MVC (Model-View-Controller) est une architecture de

conception utilisée pour séparer les préoccupations dans une application
logicielle. Il divise une application en trois composants principaux : le
Modèle, la Vue et le Contrôleur.

 Model (Modèle) : Représente les données de l'application et la

logique métier. Le modèle gère les données et les règles de
l'application.

 View (Vue) : Représente l'interface utilisateur. La vue affiche les

données du modèle et envoie les commandes de l'utilisateur au
contrôleur.

 Controller (Contrôleur) : Gère l'interaction entre la vue et le

modèle. Le contrôleur reçoit les entrées de l'utilisateur, les traite, et
met à jour le modèle et la vue en conséquence.
4.3. Organisation d’un projet JavaFx en MVC

Organiser un projet JavaFX de manière structurée et logique est essentiel

pour la maintenabilité et la scalabilité de l'application.

Voici une organisation typique pour un projet JavaFX, en mettant en avant

les conventions et les meilleures pratiques :

MyJavaFXApp/
├── Source Packages/
│ ├── controllers/
│ │ ├── [Link]
│ │ └── [Link]
│ ├── css/
│ │ ├── [Link]
│ ├── images/
│ │ ├── [Link]
│ │ └── autres_images.png
│ ├── models/
│ │ ├── [Link]
│ │ └── [Link]
│ ├── myjavafxapp/
│ │ ├── [Link]
│ ├── ui/
│ │ └── [Link]
│ ├── rapports/
│ │ └── [Link]
└── Libraries

Description des dossiers et fichiers :

1. Source Packages/
Ce dossier contient tous les packages source de votre application.

2. controllers/ :
Contient les classes contrôleurs de votre application JavaFX.
- [Link] : Contrôleur principal pour l'interface
principale.
- [Link] : Un autre contrôleur pour une autre
interface ou composant.

3. css/ :
Contient les fichiers CSS pour le style des composants JavaFX
- [Link] : Fichier de style principal pour votre application.

4. images/ :
Contient les ressources d'images utilisées dans l'application.
 - [Link] et autres_images.png : Images utilisées dans les
interfaces de l'application.

5. models/ :
Contient les classes de modèle qui représentent les données de
l'application.
- [Link] : Classe modèle pour les utilisateurs.
- [Link] : Classe modèle pour les autres modèles
par la suite.

6. myjavafxapp/ :
Contient le point d'entrée principal de l'application.
- [Link] : Classe principale qui lance l'application
JavaFX.

7. ui/ :
Contient les fichiers FXML qui définissent la structure des interfaces
utilisateur.
- [Link] : Fichier FXML principal pour l'interface
utilisateur.

8. rapports/ :
Contient les fichiers de rapports, les rapports générés par l'application.
- [Link] : Fichier de définition de rapport
(JasperReports).

9. Libraries :
Contient les dépendances et bibliothèques utilisées par le projet.

4.4. Création des interfaces avec Scene Builder

Scene Builder est un outil visuel développé par Gluon pour concevoir
des interfaces utilisateur en JavaFX. Il permet aux développeurs de créer
et de modifier des fichiers FXML, qui définissent la structure et l'apparence
des interfaces graphiques JavaFX, sans écrire de code manuel. L'interface
glisser-déposer de Scene Builder facilite la création d'interfaces complexes
et réactives.

4.4.1. Installation de Scene Builder

1. Téléchargement :

 Rendez-vous sur le site officiel de Gluon : Gluon Scene Builder.

 Téléchargez la version de Scene Builder appropriée pour votre
système d'exploitation.

2. Installation :
  Suivez les instructions d'installation fournies sur le site de
Gluon pour votre système d'exploitation.

4.4.2. Utilisation de Scene Builder

1. Création d'un nouveau fichier FXML (Vue) et de son

Contrôleur :

 Dans votre projet JavaFX, créez un nouveau fichier FXML,

nommez l’interface en utilisant la norme PascalCase

 Cochez l’utilisation d’un contrôleur pour l’interface et

actualisez le chemin du package où sera logé le contrôleur.
2. Conception de l'interface avec Scene Builder :

 Utilisez l'interface glisser-déposer pour ajouter des

composants (boutons, labels, textes, etc.) à votre interface.
 Configurez les propriétés de chaque composant via le panneau
de propriétés.
 3. Différents composants de Scene Builder :

Les composants sont souvent utilisés ensemble pour créer des interfaces
interactives. Ils sont tous personnalisables avec des styles et peuvent être
configurés dans Scene Builder avec des actions ou des propriétés
spécifiques pour correspondre aux besoins de l'application.

1. Conteneurs (Containers)

 AnchorPane : Conteneur flexible qui permet de positionner les

éléments à des distances précises des bords du conteneur.
 VBox et HBox : Permettent d'organiser les éléments en lignes
(HBox) ou en colonnes (VBox).
 GridPane : Utilisé pour organiser les éléments en grille, idéal pour
des dispositions tabulaires.
 BorderPane : Divise l'interface en cinq zones (haut, bas, gauche,
droite, et centre).
 TabPane : Permet de créer une interface avec des onglets.
 SplitPane : Divise l'interface en sections redimensionnables.

2. Contrôles de saisie de texte (Text Controls)

 TextField : Zone de texte à une seule ligne pour la saisie.

 TextArea : Zone de texte multilignes pour les commentaires ou des
textes plus longs.
  PasswordField : Champ de texte pour la saisie sécurisée de mots
de passe.

3. Boutons et Sélecteurs (Buttons and Selectors)

 Button : Bouton standard pour déclencher des actions.

 ToggleButton : Bouton à bascule qui reste enfoncé ou non, selon
l'état.
 CheckBox : Case à cocher pour une sélection binaire (oui/non).
 RadioButton : Bouton de sélection dans un groupe d'options.
 ComboBox : Liste déroulante pour choisir une option.
 ChoiceBox : Autre liste déroulante, plus simple que ComboBox.

4. Contrôles de sélection de date et de nombre

 DatePicker : Permet à l'utilisateur de sélectionner une date.

 Slider : Contrôle pour sélectionner une valeur numérique dans une
plage.
 Spinner : Permet d'augmenter ou de diminuer une valeur
numérique.

5. Tableaux et Listes

 TableView : Tableau qui affiche des données tabulaires.

 ListView : Liste simple pour afficher des éléments.
 TreeView : Affiche les données sous forme d'arborescence
hiérarchique.
 TreeTableView : Combinaison de TableView et TreeView, utile pour
afficher des données tabulaires hiérarchiques.

6. Multimédia et Images

 ImageView : Affiche une image à partir d'un fichier ou d'une URL.

 MediaView : Affiche des fichiers multimédias (audio/vidéo) dans
l'application.

7. Texte et Étiquettes

 Label : Affiche du texte non éditable.

 Tooltip : Affiche un message lorsque l'utilisateur survole un
élément.
 Hyperlink : Lien cliquable, souvent utilisé pour ouvrir une page
web.
 Text : Affiche du texte, avec des options de style.

8. Menus

 MenuBar : Barre de menus standard.

 Menu : Élément de menu avec des sous-options.
 MenuItem : Option de menu qui déclenche une action.
  ContextMenu : Menu contextuel, qui apparaît lors d'un clic droit.

4. Configuration du contrôleur :

 Vérifiez ou associez le contrôleur Java à votre interface en

spécifiant le contrôleur dans l'attribut fx:controller de la balise
racine de votre fichier FXML.

5. Identification des composants :

 Pour chaque composant interactif, vous pouvez définir des

identifiants fx:id et des méthodes de gestion d'événements
(comme onAction pour un bouton)

4.5. Récupération des données depuis une interface graphique

Dans une application JavaFX, il est souvent nécessaire de récupérer des

données saisies par l'utilisateur via l'interface graphique pour les traiter ou
les stocker.
Supposons que nous ayons une interface graphique simple
([Link]) où l'utilisateur peut entrer son nom et son âge, puis
soumettre ces informations en cliquant sur un bouton.

Le contrôleur associé à cette interface graphique

([Link]) contient la logique pour récupérer les
données saisies par l'utilisateur.

4.5.1. Déclaration des champs FXML dans le contrôleur de

l’interface

Les champs @FXML annotés permettent de lier les éléments de l'interface

graphique définis dans le fichier FXML aux variables du contrôleur.

Par exemple, nameField est lié au champ de texte où l'utilisateur saisit son
nom, et ageField est lié au champ de texte où l'utilisateur saisit son âge.

public class Projet implements Initializable {

@FXML
private TextField nameField;

@FXML
private TextField ageField;

@Override
public void initialize(URL url, ResourceBundle rb) {
// TODO
}

Les annotations @FXML indiquent que les champs nameField et ageField

sont liés aux éléments de l'interface utilisateur définis dans le fichier FXML
associé à cette classe.

La méthode initialize est héritée de l'interface Initializable et est

automatiquement appelée par JavaFX après le chargement du fichier FXML
et l'initialisation de tous les éléments marqués @FXML.
4.5.2. Méthodes et Gestion des événements

1. Méthodes

Une méthode est un bloc de code qui exécute une action ou effectue un
calcul spécifique. Elle est définie dans une classe et peut être appelée (ou
"invoquée") pour réutiliser le code qu’elle contient. Les méthodes
permettent d'organiser le code en unités logiques et de réduire la
duplication de code.

Une méthode est définie avec une syntaxe qui inclut le type de retour, le
nom de la méthode, et, éventuellement, des paramètres d’entrée. Par
exemple :

public int addition(int a, int b) {

return a + b;
}

 public : Modificateur d'accès, qui rend cette méthode accessible

depuis d'autres classes.
 int : Type de retour de la méthode (ici, la méthode renvoie un
entier).
 addition : Nom de la méthode, utilisé pour l'appeler.
 int a, int b : Paramètres d’entrée, utilisés pour passer des valeurs à la
méthode.

Une méthode peut retourner un type spécifique comme int, double,

String, etc. Le type de retour est spécifié avant le nom de la méthode. Si
une méthode ne retourne rien, elle utilise le mot-clé void.

2. Gestion des événements

La méthode enregistrer(ActionEvent event) est associée à l'événement onAction

du bouton. Lorsque l'utilisateur clique sur ce bouton, cette méthode est
appelée. Le paramètre ActionEvent event fournit des informations sur
l'événement déclencheur.

@FXML
private void enregistrer(ActionEvent event)
{
String name = [Link]();
String age = [Link]();
}

Pour associer la Méthode dans Scene Builder :

 Ouvrir le fichier FXML dans Scene Builder.

  Sélectionner le bouton dans l'interface.
 Dans le panneau Code de Scene Builder, trouver la section On
Action.
 Entrer le nom exact de la méthode.

Cette action associe la méthode enregistrer() à l'événement onAction du

bouton. Désormais, lorsque l'utilisateur clique sur le bouton, cette
méthode sera automatiquement appelée.

4.5.3. Récupération des données

Il est crucial de savoir comment récupérer les données saisies ou

sélectionnées par l'utilisateur à partir des différents éléments de l'interface
graphique. Deux méthodes sont couramment utilisées pour cette tâche
sont getText() et getValue().

 Utilisation de la méthode getText()

La méthode getText() est principalement utilisée avec des composants d'interface utilisateur
qui acceptent des entrées textuelles, comme les TextField, TextArea, etc.

@FXML
private TextField nameField;

@FXML
private void handleSubmit(ActionEvent event) {
String name = [Link]();
[Link]("Name: " + name);
}

Dans cet exemple, [Link]() récupère le texte actuellement saisi

dans le champ de texte nameField.

 Utilisation de la méthode getValue()

La méthode getValue() est utilisée avec des composants JavaFX qui

contiennent des valeurs spécifiques autres que du texte, comme des
éléments sélectionnés dans une ComboBox, des dates dans un DatePicker, etc.

@FXML
private ComboBox<String> optionsComboBox;

@FXML
private void handleSubmit(ActionEvent event) {
String selectedOption = [Link]();
[Link]("Selected Option: " + selectedOption);
}
Dans cet exemple, [Link]() renvoie l'élément
actuellement sélectionné dans la ComboBox.
5. La Programmation Orientée Objet avec Java

La programmation orienté objet est un ensemble des concepts utilisés

pour structurer nos codes et ainsi nous permettre de résoudre les
problèmes de la vie réel beaucoup plus facilement.

Contrairement A la programmation procédural (ou modulaire) où un

problème donné est scindé en sous problème représentés sous forme de
fonctions pour résoudre le problème, la programmation orienté objet elle,
scinde le problème en plusieurs objets.

Dans la programmation orienté objet nous entendrons parler des concepts

suivants :

 Classe : Ensemble d’information encapsulé dans une classe. La

classe en programmation orientée objet prévoit l’architecture des
données. Une classe est constitué des propriétés et des fonctions
appelées pour manipuler les propriétés.
 Objet : Instance d’une classe.
 Héritage : La capacité qu’a une classe d’hériter les propriétés et les
méthodes d’une autre classe

 Polymorphisme : de son origine polymorphisme veut dire :

« plusieurs formes » C’est la capacité qu’a un élément d’avoir plus
d’une signification par rapport au contexte

Le langage Java, est un langage purement orienté objet, c’est ainsi que
toutes opérations se passe dans une classe. Java prend en charge la
majorité des concepts trouvés en programmation orienté objet.

4.1. Une Classe

Une classe est un type de donné non primitif c.à.d. créé par le
programmeur lui-même. Le programmeur crée une classe en spécifiant
l’architecture de la classe (propriétés et méthodes). Après avoir défini la
classe, nous pouvons alors créer des variables qui auront comme type la
classe créée, et les variables créées en utilisant une classe comme type de
donnée sont alors connu comme les objets de cette classe.

Syntaxe générale

class Identifiant {

// liste des proprietés

// liste des methodes

}
Exemple :

Admettons que nous voulons représenter un employé dans notre

programme, nous savons qu’un employé peut avoir les propriétés
suivantes :

- Matricule
- Nom
- Sexe
- Post nom
- Prénom
- Age

Tels sont les quelques propriétés que nous pouvons utiliser pour
représenter un employé.

Dans un programme, les propriétés d’une classe sont représentées sous

formes des variables et ces propriétés sont manipulées par les méthodes.
Les méthodes alors des fonctions que nous utilisons pour manipuler nos
codes.

Par rapport à nos propriétés, nous pouvons avoir les méthodes suivantes :

- Augmentation du Salaire
- Réduction de du Salaire
- Affichage des informations de l’employé

Notre exemple peut être représenté dans une classe de la manière

suivante :

class Employee {

String matricule;
String nom;
String prenom;
String postnom;
char sexe;
int age;
double salaire;

public void augmentationSalaire(double pourcentage){

double montantAAugmenter = ([Link] / 100) * pourcentage;

[Link] += montantAugmenter

public void reduireSalaire (double pourcentage){

double montantAReduire = ([Link] / 100) * pourcentage;

[Link] -= montantAReduire
4.2. Objet

Dans la programmation orientée objet, un objet est une instance d'une

classe. Il représente une entité qui regroupe des données (attributs) et des
comportements (méthodes). En Java, la création d'un objet se fait en
utilisant le mot-clé new, suivi du nom du constructeur de la classe.

// Déclaration d'une classe

class Personne {
String nom;
int age;

public void sePresenter() {

[Link]("Bonjour, je m'appelle " + nom + " et
j'ai " + age + " ans.");
}
}

Création d’un objet de la classe personne :

Personne personne1 = new Personne();

[Link] = "Alice";
[Link] = 30;
[Link](); // Affiche : Bonjour, je m'appelle Alice
et j'ai 30 ans.

4.3. Constructeur

Le constructeur est une méthode spéciale utilisée pour initialiser les

objets. Un constructeur porte toujours le même nom que la classe et n'a
pas de type de retour. Il est automatiquement appelé lors de la création
d'un objet. Java permet de définir plusieurs constructeurs pour une classe
(surcharge de constructeur), chacun ayant un ensemble de paramètres
différent.

class Personne {
String nom;
int age;
 // Constructeur par défaut
Personne() {
[Link] = "Inconnu";
[Link] = 0;
}

// Constructeur avec paramètres

Personne(String nom, int age) {
[Link] = nom;
[Link] = age;
}
}

Utilisation des constructeurs :

Personne personne1 = new Personne(); // constructeur par défaut

Personne personne2 = new Personne("Bob", 25); //constructeur avec
paramètres

4.4. Les Accesseurs

Les accesseurs sont des méthodes qui permettent de consulter ou de

modifier les attributs privés d'une classe. Les méthodes getter récupèrent
la valeur d'un attribut, tandis que les méthodes setter modifient la valeur
d'un attribut. Cela permet de contrôler l'accès aux données d'une classe.

class Personne {
String nom;
int age;

// Constructeur
Personne(String nom, int age) {
[Link] = nom;
[Link] = age;
}

// Getter pour nom

public String getNom() {
return nom;
}

// Setter pour nom

public void setNom(String nom) {
[Link] = nom;
}

// Getter pour age

public int getAge() {
return age;
}
 // Setter pour age
public void setAge(int age) {
if(age >= 0) {
[Link] = age;
}
}
}

Utilisation des accesseurs :

Personne personne1 = new Personne("Charlie", 28);

[Link]([Link]()); // Affiche : Charlie
[Link]("David");
[Link]([Link]()); // Affiche : David

4.5. Encapsulation

L'encapsulation est un des principes fondamentaux de la programmation

orientée objet. Elle consiste à regrouper les données (attributs) et les
méthodes qui manipulent ces données au sein d'une même classe, tout en
restreignant l'accès direct aux données internes depuis l'extérieur de cette
classe. Cela garantit que les données sont protégées et ne peuvent être
modifiées que de manière contrôlée.

En Java, l'encapsulation est souvent mise en œuvre en rendant les

attributs d'une classe privés (private) et en fournissant des méthodes
publiques (les accesseurs : getters et setters) pour y accéder et les
modifier. Cette approche permet de protéger l'intégrité des données et
d'ajouter des validations ou des logiques spécifiques lors de la
modification des attributs.

class CompteBancaire {
// Attributs privés : encapulation des données
private double solde;

// Constructeur
public CompteBancaire(double soldeInitial) {
if (soldeInitial >= 0) {
[Link] = soldeInitial;
} else {
[Link] = 0;
[Link]("Solde invalide. Solde mis à 0.");
}
}

// Méthode getter pour accéder au solde

public double getSolde() {
return solde;
}
 // Méthode pour déposer de l'argent
public void deposer(double montant) {
if (montant > 0) {
solde += montant;
}
}

// Méthode pour retirer de l'argent

public boolean retirer(double montant) {
if (montant > 0 && montant <= solde) {
solde -= montant;
return true;
}
return false;
}
}

Utilisation de l'encapsulation à l’aide aux méthodes getters et Setters :

CompteBancaire compte = new CompteBancaire(1000);

[Link](500);
[Link]("Solde après dépôt : " + [Link]());

// Affiche : 1500

boolean retrait = [Link](200);

[Link]("Retrait réussi ? " + retrait);
// Affiche : true
[Link]("Solde après retrait : " + [Link]());

// Affiche : 1300
Table des matières
PARTIE II : INTRODUCTION À LA PROGRAMAMTION.................................1
1. La programmation et langages de programmation..................................1
2. Outils de développement......................................................................................1
3. Introduction du langage JAVA.............................................................................3
4. La Programmation Orientée Objet avec Java.............................................18
4.1. Une Classe.............................................................................................................................18
4.2. Objet..........................................................................................................................................20
4.3. Constructeur.........................................................................................................................20
4.4. Les Accesseurs....................................................................................................................21
5. Introduction à JavaFX............................................................................................24
5.1. La création d’un projet JavaFX sur NetBeans :.................................................24
5.2. Le Modèle MVC (Model-View-Controller)..............................................................25
5.3. Organisation d’un projet JavaFx en MVC.............................................................26
5.4. Création des interfaces avec Scene Builder.......................................................27
5.5. Récupération des données depuis une interface graphique....................30