Cours de Java G3 IG JOUR ISP 2020 SMM

Institut Département d’Informatique
Supérieur
Pédagogique
LANGAGE DE PROGRAMMATION JAVA

TROISIEME GRADUAT
Introduction
Java est un langage très utilisé, notamment par un grand nombre de

programmeurs professionnels, ce qui en fait un langage incontournable
actuellement.
Voici les caractéristiques de Java en quelques mots :
- Java est un langage de programmation moderne développé par Sun
Microsystems (aujourd'hui racheté par Oracle). Il ne faut surtout pas le
confondre avec JavaScript (langage de scripts utilisé principalement sur les
sites web), car Java n'a rien à voir.
- Une de ses plus grandes forces est son excellente portabilité : une fois votre
programme créé, il fonctionnera automatiquement sous Windows, Mac,
Linux, etc.
- Java est aujourd’hui le premier langage objet enseigné dans les écoles et
Universités en raison de sa rigueur et de sa richesse fonctionnelle.
- La communauté des développeurs Java représente plusieurs millions de
personnes et est plus importante en nombre que la communauté des
développeurs C++ (pourtant une référence).
On peut faire de nombreuses sortes de programmes avec Java :

- des applications, sous forme de fenêtre ou de console ;
- des applets, qui sont des programmes Java incorporés à des pages web ;
- des applications pour appareils mobiles, avec J2ME ;
- et bien d'autres ! J2EE, JMF, J3D pour la 3D...
Comme vous le voyez, Java permet de réaliser une très grande quantité
d'applications différentes ! Mais... comment apprendre un langage si vaste
qui offre autant de possibilités ?
Heureusement, ce cours est là pour tout vous apprendre de Java à partir de
zéro
Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

1
Contenu du cours
Chapitre 1 : Environnement de développement Intégré Java
Chapitre 2 : Les bases du langage Java
Chapitre 3 : Classes et Objets
Chapitre 4 : Accès aux bases de données et Création des programmes

d’installation Java
Bibliographie
- Claude DELANNOY, Programmer en Java, 5e Edition, Ed. EYROLLES,

Paris, 2008.
- David FLANAGAN, Java in a Nutshell, 3ème Edition, Ed. O’REILLY, Paris
2000
- Hugues BERSINI, L’Orienté Objet, 3e Edition, Ed. Eyrolles, Paris, 2007
- Laura LEMAY et Rogers CADENHEAD, Le Programmeur Java 2, Campus
Press, Paris, 1998
- Michel Divay, La Programmation Objet en Java, Dunod, Paris, 2006
- Thierry GROUSSARD, Java 6 : Les fondamentaux du langage Java, Ed.
ENI, Paris, 2008.

2
Chapitre I : Environnement de développement Intégré Java
La nécessité de faciliter et d’automatiser le processus de

développement de logiciel a permis la création de divers Environnements
de Développements Intégrés (EDI ou IDE en anglais Integrated
Development Environment).
Actuellement, il y a plusieurs environnements intégrés(IDE) qui
permettent de développer les applications Java. Mais les plus utilisés dans le
domaine scientifique sont l’Eclipse et le NetBeans.
1.1. L’Eclipse
Souvent utilisé pour le développement des applications
mobiles(Androïd), l’utilisation d’eclipse ne nécessite pas une installation
définitive du logiciel sur le Pc. Il s’installe temporairement pendant le temps
de son exploitation.
1.2. NetBeans
NetBeans est un outil de développement Open Source très
puissant et particulièrement bien construit et adapté pour créer des
applications ou encore des produits complexes.
Pour plus d’informations sur NetBeans en français, nous vous
recommandons le site Web suivant : http://www.netbeans.org/index_fr.html
Dans le domaine de la programmation avec Java, il y a plus
de 50 IDE’s disponibles, par exemple :

3
1.3. L’installation de NetBeans
L’espace disque requis est au minimum de 300 Mo. Si d’autres
composants sont installés, nous pouvons atteindre plus de 350 Mo. Nous
pouvons évidemment installer netbeans-7.3.1 séparément, mais il nous
faudra au moins une machine virtuelle Java avant de commencer
l’installation. L’outil jdk-7u9-windows-i586 doit être préalablement installé. Il
est donc préférable de procéder tout d’abord à l’installation ci-décrite
(installation des outils incluant Java) et aux vérifications nécessaires.
NetBeans est un outil de développement permettant d’éditer du
code et de le compiler. Des débogueurs (Java et autres) y sont intégrés,
lesquels permettent de faire du pas à pas dans le code source pendant
l’exécution afin de s’assurer du bon déroulement du programme ou encore
d’examiner le contenu des variables.
1.4. Prise en main de NetBeans
1.4.1. Création d’un projet
Pour créer un nouveau projet, on va dans le menu File, en choisissant : New
Project. Dans la fenêtre New Project, choisissez Java Application. Ensuite
cliquez sur Next. Dans la fenêtre New Java Application, nommez le projet et
cliquez sur Finish. Le projet s’ouvre avec sa classe principale portant le
même nom que le projet et contenant la méthode principale main considerée
comme le point d’entrée de l’application. Chaque fois que l’application sera
executée, c’est cette classe qui va s’exécuter en première position à moins
que vous changiez l’ordre d’exécution de l’application.
1.4.2. Ajout d’une fenêtre dans le projet
Le projet initial se compose uniquement d’un fichier. Il s’agit par
défaut de la classe principale. Nous allons pouvoir ajouter d’autres éléments.
Pour cela, utilisez-le sous menu New File dans le menu File. Les fichiers
permettant d’obtenir des éléments graphiques sont dans Swing GUI Forms. Il
y a de nombreux types différents. Nous utiliserons la fenêtre JFrameForm.
Choisissez ensuite un nom adapté par exemple G3_Info.

4
1.4.3. Compilation et Exécution d’un programme Java
Une application Java est un programme autonome semblable à
tout programme informatique, qui nécessite l’utilisation d’un
compilateur quand ce dernier n’est pas encore empaqueter.
Pour exécuter un programme Java sur la plateforme NetBeans, il
vous suffit juste de cliquer sur le bouton se trouvant sur la partie
supérieure de l’interface de NetBeans. Cette opération compile et
exécute en même temps le code de l’application et affiche un message
d’erreur en cas d’un problème.
I.4.4. Travailler avec plusieurs fenêtres
Lors de la construction d’une application qui possède plusieurs
fenêtres, on doit donner la possibilité de faire appel à une fenêtre à partir
d’une autre.
Exemple de l’appel d’une fenêtre dénommée G3_Informat: Sélectionnez
l’événement clic du bouton de commande se trouvant sur cette fenêtre pour
mettre le code suivant : new G3_Informat().setVisible(true); // Appel de la 2e
fenêtre
this.setVisible(false); // Disparition de la fenêtre appelant.
NB : Toute instruction en java se termine par un point-virgule ( ; )
I.4.5. La fenêtre de démarrage du projet

Pour définir une fenêtre, comme fenêtre de démarrage de l’application
(main). Il faudra le configurer à partir de l’option suivante :
, vous déroulez et cliquez sur Customize…, en suite

cliquez sur le Browse… de Main Class, sélectionnez alors la classe que vous
désirez qu’elle s’exécute en premier lieu et cliquez sur Select Main Class puis
OK.
I.4.6. Ajout des Contrôles
Il existe de nombreux composants susceptibles d’intervenir dans
une interface graphique.

5
Certains sont des conteneurs, c’est-à-dire qu’ils sont destinés à
contenir d’autres composants ; c’est notamment le cas des fenêtres (JFrame)
et des panneaux (JPanel). En revanche, certains composants ne peuvent pas
en contenir d’autres ; c’est le cas des boutons.
Ils sont souvent nommés contrôles ou encore composants
atomiques.
Pour ajouter un contrôle à un conteneur, Il suffit de cliquer à
partir de la palette sur le composant et le placer sur la fenêtre. On peut
l’afficher à partir du menu Windows (Fenêtre).
- Les étiquettes
Un composant de type JLabel permet d’afficher dans un conteneur un texte
(d’une seule ligne) non modifiable par l’utilisateur, mais que le programme
peut faire évoluer. C’est dans la catégorie Swing Controls qu’on trouve ce
composant sur la palette.
- Les champs de texte
Un champ de texte (on dit aussi une boîte de saisie) est une zone
rectangulaire (avec bordure) dans laquelle l’utilisateur peut entrer ou
modifier un texte (d’une seule ligne). Il s’obtient en cliquant sur le bouton
Text Field de la palette. Nous avons les zones de texte multi lignes qui
permettent la saisie de plusieurs lignes. Pour en avoir, c’est à partir de la
commande Text Area se trouvant à côté du bouton Text Field. Les deux
héritent les méthodes de la classe TextComponent telles que : getText() et
setText().
- Les boutons
Un bouton (Button : de la classe java.swing.JButton) est un composant qui
permet de lancer un événement à partir d’un clic. Pour modifier le texte se
trouvant sur le bouton, il suffit de faire un clic droit et cliquez sur Edit Text.
Pour définir un événement, c’est à partir de Events du menu contextuel,
Action puis ActionPerformed.
TD 1 : Ecrire un programme Java (avec NetBeans) qui permet à un utilisateur
de saisir un message dans une zone de texte et ensuite affiche sur un
label(Etiquette) ce même message précédé de la phrase suivante : «Le

6
message que vous avez saisi est :» cela après avoir cliqué sur le bouton de
commande Afficher le message
Astuce : Ajoutez sur la fenêtre une zone de texte où sera saisi le message,
un bouton de commande sur lequel vous écrivez Afficher le message
(propriété Text) ainsi que 2 labels : le 1èr aura le texte Tapez votre message
ici et le second n’aura pas de texte initialement mais il servira d’afficher le
message qui sera saisi.
Faites un clic droit sur le bouton de commande, sélectionner Evénements sur

la liste déroulante, ensuite cliquez sur Mouse pour enfin choisir l’option
mouseClicked [jButton1MouseClicked] qui correspond à l’événement clic sur
ce bouton. Voici l’extrait de code à saisir :
String texte; // Déclaration de la variable Texte
texte=jTextField1.getText(); //Affectation à la variable le contenu de la zone
texte jTextField1
jLabel1.setText("Le message que vous avez saisi est : "+texte); // Affichage du
message sur le label
jTextField1.setText(""); // Mise à blanc de la zone de texte jTextField1
}
- Les cases à cocher
La case à cocher permet à l’utilisateur d’effectuer un choix de type oui/non.
Sa vocation est de faire d’un groupe de boutons dans lequel plus d’une seule
option peut être sélectionnée à la fois. Elle est instanciée grâce à la classe

7
JCheckBox, dont le constructeur requiert obligatoirement un libellé qui sera
toujours affiché à côté de la case pour en préciser le rôle.
- Les boutons radio
Comme la case à cocher, le bouton radio permet d’exprimer un choix de type
oui/non. Mais sa vocation est de faire partie d’un groupe de boutons dans
lequel une seule option peut être sélectionnée à la fois. Autrement dit, le
choix d’une option du groupe entraîne automatiquement la désactivation de
l’option choisie précédemment. En Java, c’est la classe JRadioButton qui vous
permet d’instancier un tel objet. Comme celui d’une case à cocher, son
constructeur requiert obligatoirement un libellé qui sera toujours affiché à
côté de la case pour en préciser le rôle :
- JRadioButtonbRouge = new JRadioButton ("Rouge") ;
- JRadioButtonbVert = new JRadioButton ("Vert") ;
Cependant, si l’on se contente d’ajouter (par add) de tels objets à un
conteneur, on obtient des composants qui, exception faite de leur aspect, se
comporteront exactement comme des cases à cocher. Pour obtenir la
désactivation automatique d’autres boutons radio d’un même groupe, il faut
de plus :
- Créer un objet de type ButtonGroup, par exemple :
ButtonGroup groupe = new ButtonGroup() ;
- associer chacun des boutons voulus à ce groupe à l’aide de la méthode
add : groupe.add(bRouge) ; groupe.add(bVert) ou soit à l’aide de la
propriété ButtonGroup, en sélectionnant le groupe
- Les boîtes combo
La boîte de liste combinée (ou liste combinée, ou encore boîte combo) associe
un champ de texte (par défaut non éditable) et une boîte de liste à sélection
simple. Tant que le composant n’est pas sélectionné, seul le champ de texte
s’affiche, comme ici :
Extrait du code d’un programme utilisant un combobox pour y ajouter les

éléments. String chaine=jTextField1.getText();
jComboBox1.addItem(chaine);
jTextField1.setText(null);

8
Chapitre II : Les Bases du Langage Java
Nous traitons Java d'abord comme un langage de programmation

classique. Nous aborderons les objets ultérieurement.
Dans un programme on trouve deux choses : des données et les
instructions qui les manipulent.
DONNEES
INSTRUCTIONS
2.1. Les données de Java
Java utilise les types de données suivants: les nombres entiers, les
nombres réels, les caractères et chaînes de caractères, les booléens et les
objets.
2.1.1. Les types de données prédéfinis

9
2.1.2. Notation des données littérales
2.1.3. Déclaration des données

Un programme manipule des données caractérisées par un nom
et un type. Ces données sont stockées en mémoire. Au moment de la
traduction du programme, le compilateur affecte à chaque donnée un
emplacement en mémoire caractérisé par une adresse et une taille. Il le fait
en s'aidant des déclarations faites par le programmeur.
1. Déclaration des constantes
Déclarer une constante c’est réserver une zone dans la mémoire
vive tout en y stockant une donnée d’un type précis, qui ne variera pas
pendant l’exécution du programme. Le nom d’une constante est
habituellement en majuscule.
La syntaxe de déclaration est la suivante :
final type nom=valeur; //définit constante nom=valeur
Exemple : final float PI=3.141592F;
2. Déclaration des variables
Une variable est identifiée par un nom et se rapporte à un type
de données. Le nom d'une variable Java a n caractères, le premier
alphabétique, les autres alphabétiques ou numériques. Java fait la différence
entre majuscules et minuscules. Ainsi les variables FIN et fin sont
différentes.

10
Déclarer une variable c’est réserver une zone dans la mémoire
vive (RAM) pour y stocker une donnée d’un type précis. Cette donnée est
susceptible de varier pendant l’exécution du programme. Cette zone
mémoire ainsi déclarée est une variable et aura un nom donné par le
programmeur. Aucune variable ne peut être utilisée sans avoir été déclarée.
Déclarée une seule fois, une variable peut être utilisée plusieurs fois.
Les variables peuvent être initialisées lors de leur déclaration. La
syntaxe de déclaration d'une ou plusieurs variables est :
identificateur_de_type variable1, variable2,..., variablen;
Où identificateur_de_type est un type prédéfini ou bien un type objet défini
par le programmeur.
2.1.4. Les conversions entre nombres et chaînes de caractères

Pour convertir un nombre en une chaîne de caractère, il suffit de
le concaténer à une chaîne de caractères. Voici la syntaxe : "" + nombre.
Exemple : String s= "" + 10 ; // Cette valeur peut représenter par une
variable de type numérique.
La conversion est fréquente dans les programmes Java surtout
lors de la lecture des données externes. La syntaxe pour convertir une chaîne
de caractères en une valeur numérique dépend du type numérique auquel la
chaîne est convertie :
chaine -> int : Integer.parseInt(chaine)
chaîne -> long : Long.parseLong(chaine)
chaîne -> double Double.valueOf(chaine).doubleValue() ou
Double.parseDouble(chaine)
chaîne ->floatFloat.valueOf(chaine).floatValue() ou Float.parseFloat(chaine).
Nota : Il arrive que l’exécution d’une instruction échoue parce que toutes les
conditions ne sont pas réunies. Dans ce cas, Java lance un message d’erreur
appelé exception qui interrompt brusquement le programme en s’affichant à
l’écran dans la fenêtre de commandes. Au lieu de laisser l’exception
apparaître à l’écran et interrompre ainsi l’exécution du programme peut être
écrite de telle sorte que l’exception puisse être interceptée et gérée
autrement.

11
La syntaxe de la gestion des exceptions est la suivante :
try{
instructions susceptibles de générer l’exception
}catch(Exception e){
gestion de l’exception s’il y en a
} finally{ //Optionnel
instructions à exécuter qu’il y ait eu exception ou pas.
}
2.1.5. Les tableaux de données
Un tableau Java est un objet permettant de rassembler sous un
même identificateur des données de même type. C'est une structure interne
pouvant stocker plusieurs données de même type.
On distingue : les tableaux unidimensionnels ou vecteurs, les
tableaux binaires ou matrices, les tableaux ternaires (vecteur de matrices ou
matrice de vecteurs), les tableaux quaternaires (matrice de matrices),… mais
dans le cadre de notre cours, nous nous limiterons aux vecteurs et aux
matrices.
Sa déclaration est la suivante :
Type Tableau [ ]=new Type[n] ou Type [] Tableau=new Type[n]
Les deux syntaxes sont légales. n est le nombre de données que
peut contenir le tableau. La syntaxe Tableau[i] désigne la donnée n° i où i
appartient à l'intervalle [0, n-1].
Un tableau à deux dimensions pourra être déclaré comme suit :
Type Tableau[][]=new Type[n][p] ou Type[][] Tableau=new Type[n][p]
La syntaxe Tableau[i] désigne la donnée n° i de Tableau où i
appartient à l'intervalle [0,n-1]. Tableau[i] est lui-même un tableau :
Tableau[i][j] désigne la donnée n° j de Tableau[i] où j appartient à l'intervalle
[0,p-1].
Un tableau est un objet possédant l'attribut length : c'est la taille
du tableau.

12
2.2. Les instructions élémentaires de Java
On distingue :
1. les instructions élémentaires exécutées par l'ordinateur.
2. les instructions de contrôle du déroulement du programme.
Les instructions élémentaires apparaissent clairement lorsqu'on
considère la structure d'un micro-ordinateur et de ses périphériques.
1. lecture d'informations provenant du clavier

2. traitement d'informations
3. écriture d'informations à l'écran
4. lecture d'informations provenant d'un fichier disque
5. écriture d'informations dans un fichier disque
2.2.1. Ecriture sur écran

Pour afficher ou écrire sur écran, on utilise deux instructions. La
première est celle qui affiche sous le mode console et la deuxième est celle
qui affiche dans une boite de message.
1. Affichage sous le mode console
La syntaxe de l'instruction d'écriture sur l'écran est la suivante :
System.out.println(expression) ou System.err.println(expression)
Où expression est tout type de donnée qui puisse être converti en chaîne de
caractères pour être affiché à l'écran.
2. Affichage dans une fenêtre graphique
L’affichage d’un message dans une boite de message se fait
JOptionPane.showMessageDialog().

13
Cette instruction affiche dans une boîte de message le paramètre
précisé dans les parenthèses. L’utilisation de cette instruction nécessite une
importation préalable de la classe JOptionPane avec l’instruction: import
javax.swing.JOptionPane ou simplement import javax.swing.*.
La méthode showMessageDialog () de la classe JOptionPane reçoit
quatre arguments qui se suivent en ordre : 1la position de la boîte de
message à l’écran. Le mot clé null signifie que la boîte sera au centre de
l’écran ; 2 le paramètre à afficher ; 3 un texte qui sera affiché dans la barre de
titre de la boîte de message et 4
l'une des constantes de JOptionPane
suivantes indiquant le type de message et l’icône correspondante :
JOptionPane.PLAIN_MESSAGE ;
JOptionPane.INFORMATION_MESSAGE ;
JOptionPane.ERROR_MESSAGE ;
JOptionPane.WARNING_MESSAGE.
3. Les caractères d’échappement

Les chaines de caractères à afficher peuvent contenir des
caractères d’échappement suivants :
\n Nouvelle ligne
\t Tabulation
\\ Barre renversée
\’ Guillemet simple
\’’ Double guillemet
2.2.2. Lecture de données tapées au clavier
1. Utilisation de l'objet Scanner

Pour que Java puisse lire ce que vous tapez au clavier, vous allez
devoir utiliser un objet de type Scanner :
Scanner sc = new Scanner (System.in);
Nous devons importer la classe Scanner se trouvant dans la
bibliothèque java.util. Maintenant, voici l'instruction pour permettre à Java
de récupérer ce que vous avez saisi et ensuite de l'afficher :
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
System.out.println("Voici le mot saisi :"+str);

14
De façon générale, retenez que pour récupérer une donnée du
type de la variable, il vous suffit d'appeler next<Type de variable
commençant par une majuscule>
Voici quelques exemples:
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
double d = sc.nextDouble();
long l = sc.nextLong();
byte b = sc.nextByte();
Attention : il y a un type de variable primitive qui n'est pas pris en compte
par la classe Scanner ; il s'agit des variables de type char.
Voici comment on pourrait récupérer un caractère :
System.out.println("Saisissez une lettre :");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
charcarac = str.charAt(0);
System.out.println("Vous avez saisi le caractère : " + carac);
2. Lecture à l’aide de la boîte de saisie
La lecture d’une ligne de texte peut se faire à travers une boîte de
dialogue que crée la méthode showInputDialog() de la classe JOptionPane :
String ligne = JOptionPane.showInputDialog("Entrer texte :") ;
En Java les flux de données provenant du clavier sont toujours
considérés comme de chaine de caractère. C’est au programmeur de le
convertir au type qui lui sera utile.
Exemple : Ecrire un programme qui lit en entrée le capital, le taux et le
nombre de jours et restitue en sortie l’intérêt simple correspondant, sachant
que la formule : capital*taux*nombre de jours/360.
import javax.swing.* ;
public class Calcul_Interet {
public static void main(String[] args){
//Déclaration et affectation des variables
double capital = 0, taux = 0;
int jours = 0;
String c, t, j ;

15
//Lecture de données dans des boîtes de dialogue
c = JOptionPane.showInputDialog(“Capital”);
t = JOptionPane.showInputDialog(“Taux”);
j = JOptionPane.showInputDialog(“Nombre de jours”);
//Gestion des exceptions et conversion des données.
try{
capital = Double.parseDouble(c);
taux = Double.parseDouble(t);
jours = Integer.parseInt(j) ;
}catch(Exception e){
JOptionPane.showMessageDialog(null, “Erreur : ” + e,
“ERREUR”, JOptionPane.ERROR_MESSAGE);
System.exit(0);
}
// Calcul de l’intérêt
JOptionPane.showMessageDialog(null,
“Intérêt = ” + (capital * taux * jours / 360),
“RESULTAT”, JOptionPane.PLAIN_MESSAGE);
System.exit(1);
}
}
2.2.3. 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 le ";". Il existe
deux types de commentaire en Java :
Type de commentaires Exemple

commentaire abrégé // commentaire sur une seule ligne int n=1;
// déclaration du compteur
commentaire multi ligne /*commentairesligne1
commentairesligne2*/
2.2.4. Les Opérateurs
Sont de symboles spéciaux du langage, permettant l’exécution
d'opérations sur le contenu de certains éléments en général des variables.
 Les opérateurs arithmétiques :
Opérateur Signification Exemple
+ Addition A + B
- Soustraction A - B
* Multiplication A * B
/ Division entière A / B
% Modulo ou reste de la A % B

16
division
-- Décrémentation A --
++ Incrémentation A ++
+= Assignation additive A + = B
-= Assignation soustractive A - = B
*= Assignation multiplicative A *= B
/= Assignation divisionnelle A /= B
 L’opérateur d’affectation
Le signe = est l'opérateur d'affectation et s'utilise avec une
expression de la forme variable = expression ou variable = valeur.
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
é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
Il existe diverses fonctions mathématiques :

double sqrt(double x) racine carrée
double cos(double x) Cosinus
double sin(double x) Sinus
double tan(double x) Tangente
double pow(double x, double y) x à la puissance y (x>0)
double exp(double x) Exponentielle
double log(double x) Logarithme népérien
double abs(double x) valeur absolue, etc...

17
Toutes ces fonctions sont définies dans une classe Java appelée
Math. Lorsqu'on les utilise, il faut les préfixer avec le nom de la classe où
elles sont définies. Ainsi on écrira : double x, y=4; x=Math.sqrt(y);
 Les opérateurs d’incrémentation
Les opérateurs d'incrémentation et de décrémentation sont : n++
++n et n-- --n.
Si l'opérateur est placé avant la variable (préfixé), la modification
de la valeur est immédiate si non la modification n'a lieu qu'à l'issu 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é.
 Les opérateurs bit à bit
Ces opérateurs effectuent des opérations uniquement sur des
entiers (byte, short, int).
Opérateurs Opérations réalisées Exemples Résultats
| Ou binaire 10 | 7 15
^ Ou exclusif 10^7 13
>> Décalage vers la droite 10>>1 5

(division par 2)
<< Décalage vers la gauche 10<<1 20
(division par 2)
 Les opérateurs relationnels
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
ET logique (pour expressions booléennes) :
&& a&&b l'évaluation de l'expression cesse dès qu'elle
devient fausse

18
OU logique (pour expressions booléennes) :
|| a||b l'évaluation de l'expression cesse dès
qu'elle devient vraie.
opérateur conditionnel : renvoie la valeur b ou c

?: a?b: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 Booléens

Opérateurs Opérations réalisées Exemples Résultats
& Et logique if (test1) Vraie si test1 et test2 sont
&(test2) vrais
| Ou logique if (test1) | Vraie si test1 ou test2 est
(test2) vrai
^ Ou exclusif if (test1) ^ Vraie si test1 ou test2 est
(test2) vrai mais faux s’ils sont
simultanément vraies
! Négation if ( !test1) Inverse le résultat du test
&& Et logique If(test1) Vraie si test1 et test2 sont

&& (test2) vrais. Mais test2 ne sera
évalué que si test1 est vrai
|| Ou logique If(test1) || Vraie si test1 ou test2 sont
(test1) vrais. Mais test2 ne sera
évalué que si test1 est faux
2.3. Les instructions de contrôle du déroulement du programme

2.3.1. Arrêt
La méthode exit définie dans la classe System permet d'arrêter
l'exécution d'un programme.
Syntaxe : voidexit (int status) : action arrête le processus en cours
et rend la valeur status au processus père.
Exemple : System.exit(0); //pour arrêter le programme avec une valeur d'état
à 0.
2.3.2. Les Structures de Contrôle

Un programme est une suite logique d’instructions élémentaires
exécutables séquentiellement par l’ordinateur.
Les structures de contrôle permettent de modifier l’ordre
séquentiel d’exécution des instructions d’un programme.

19
On distingue :
- les structures conditionnelles (if, if…else, switch, opérateur conditionnel) et
- les structures répétitives (for, while, do…while).
1. Les structures conditionnelles
 La structure if
Syntaxe : if (condition) instruction ;
L’instruction qui suit immédiatement la condition est exécutée si la
condition (une expression booléenne) est vraie (satisfaite). Si la condition
n’est pas satisfaite l’instruction venant immédiatement après la condition ne
sera pas exécutée, l’exécution du programme se poursuivra à l’instruction
suivant celle qui vient immédiatement après la condition.
Exemple : Ecrire un programme qui accorde une réduction de 20% sur un prix
total dépassant 10000.
public class Reduction{
public static void main(String[] arg){
double quantité = 0;
double prix = 0;
double net = 0;
try{
quantité = Double.parseDouble(JOptionPane.showInputDialog("Entrer la quantité"));
prix = Double.parseDouble(JOptionPane.showInputDialog("Entrer le prix unitaire"));
} catch(Exception e){
JOptionPane.showMessageDialog(null, "Données invalides","ERREUR",
JOptionPane.ERROR_MESSAGE);
System.exit(1);
}
net = quantité * prix ;
if (net > 10000) net = net - (net * 0.2);
JOptionPane.showMessageDialog(null, "Net à payer = " + net,"Résultat",
JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}

20
Plusieurs instructions peuvent être soumises à une condition. Dans ce cas,
elles constituent un bloc exécutable comme une seule instruction. Elles
doivent s’insérer dans les accolades sous la syntaxe suivante :
if (condition) {
instruction ;
…
instruction ;
}
 La structure if…else
Syntaxe : if (condition) instruction ;
else instruction ;
Si la condition est satisfaite, l’instruction venant directement après la
condition est exécutée et l’exécution se poursuit après l’instruction suivant la
clause else. Si la condition n’est pas satisfaite, c’est plutôt celle qui suit la
clause else qui s’exécute et l’exécution du programme se poursuit à
l’instruction suivante.
Un programme qui accorde 10% de réduction si le prix total est inférieur à
10000 et une réduction de 20% si le prix total est supérieur ou égal à 10000.
if (net > 10000) net -= (net * 0.2);
else net -= (net * 0.1);
S’il y a plusieurs instructions à exécuter, elles doivent se renfermer dans les
accolades dans une syntaxe suivante :
if (condition){
instruction ;
…
instruction ;
} else {
instruction ;
…
instruction ;
}
Exemple : Même problème qu’à l’exemple précédent, mais le programme doit
informer l’utilisateur sur le taux appliqué.
importjavax.swing.JOptionPane;
public class Reduction {
public static void main (String [] args) {
double pu=0, qte=0, net=0;

21
String info="le taux appliqué a été de ";
try{
pu=Double.parseDouble(JOptionPane.showInputDialog("entrer le prix unitaire"));
qte=Double.parseDouble(JOptionPane.showInputDialog("entrer la quantité"));
}
catch (Exception e){
System.exit(0);
}
net=pu*qte;
if(net>=10000){
net=net-net*0.2;
info=info+"20%";
}
else{
net=net-net*0.1;
info=info+"10%";
}
JOptionPane.showMessageDialog(null,"le net à payer est de "+net+"\n"+info);
System.exit(1);
}
}
On peut imbriquer plusieurs structures if comme dans l’exemple suivant.
Exemple : Ecrire un programme qui lit un entier compris entre 1 et 7 et
affiche le jour de la semaine correspondant :
Integer entier;
String jour;
entier =Integer.parseInt(txtnbre.getText());
if (entier == 1) jour = "Lundi";
else if (entier == 2) jour = "Mardi";
else if (entier == 3) jour = "Mercredi";
else if (entier == 4) jour = "Jeudi";
else if (entier == 5) jour = "Vendredi";
else if (entier == 6) jour = "Samedi";
else if (entier == 7) jour = "Dimanche";
else jour = "Il fallait taper un entier\ncompris" +" entre 1 et 7 inclus";
JOptionPane.showMessageDialog(null,jour,"Résultat",JOptionPane.INFORMATION_MES
SAGE);
 La Structure switch
Syntaxe : switch (expression entière){
case valeur1 :
instruction ;

22
…
instruction ;
break ;
case valeur2 :
instruction ;
…
instruction ;
break ;
…
default :
instruction
…
instruction
}
Où valeur1, valeur2,… sont les différentes valeurs de l’expression entière. La
structure switch permet d’évaluer une expression entière. A chaque valeur de
l’expression entière, précédée par un case, correspond une suite
d’instructions dont la dernière est break. A l’occurrence de cette instruction
break, l’exécution du programme s’interrompt et se poursuit après l’accolade
de fermeture de la structure switch. Si aucune des valeurs précisées dans les
clauses case ne correspond à la valeur de l’expression entière, alors les
instructions venant après la clause default seront exécutées et l’exécution du
programme se poursuivra après la structure switch.
Une syntaxe suivante :
…
case valeur1 : case valeur 2 :
instructions ;
…
Instructions ;
break ;
break : signifie que les instructions qui suivent les deux clauses case
correspondent aux deux valeurs, valeur1 et valeur2 à la fois.
 L’opérateur conditionnel ? :
L'expression expr_cond ? expr1 : expr2 est évaluée de la façon
suivante :
1. l'expression expr_cond est évaluée. C'est une expression conditionnelle à
valeur vrai ou faux;
2. Si elle est vraie, la valeur de l'expression est celle de expr1. expr2 n'est pas
évaluée.

23
3. Si elle est fausse, c'est l'inverse qui se produit : la valeur de l'expression est
celle d’expr2, expr1 n'est pas évaluée.
Exemple : i= (j>4? j+1:j-1); // affectera à la variable i : j+1 si j >4, j-1 sinon
C'est la même chose que d'écrire : if(j>4) i=j+1; else i=j-1; mais c'est plus
concis. Le programme Reduction2 vu antérieurement peut être réécrit comme
suit : net -= net > 10000 ? (net * 0.2) : (net * 0.1);
2. Les structures répétitives
Les structures répétitives permettent l’exécution répétitive des
instructions tant qu’une condition donnée demeure vraie. Ces structures sont
aussi appelées boucles.
 La boucle for
Syntaxe : for (initialisation ; condition ; incrément/décrément) {
instruction ;
…
instruction ;
}
Où initialisation = initialisation de la variable contrôlant la boucle, Condition
= condition de la continuité de la boucle, Incrément/décrément :
incrémentation ou décrémentation de la variable contrôlant la boucle.
Exemple : un programme qui calcule le factoriel d’un nombre entier positif.
Le factoriel de 4 nous donnera : 4*3*2*1 = 24.
public class Factoriel{
public static void main(String arg[]){
int nombre = 0;
long facto = 1;
try{
nombre = Integer.parseInt(JOptionPane.showInputDialog("CALCUL DU
FACTORIEL\n" +"Entrer un entier positif"));
JOptionPane.showMessageDialog(null,"Donnéeinvalide","ERREUR",
System.exit(0);
}
for (int i = nombre; i>0; i--){
facto *= i;
}
JOptionPane.showMessageDialog(null, "Le factoriel de " + nombre +" est\n" +
facto,"RESULTAT", JOptionPane.PLAIN_MESSAGE);
System.exit(0);
}}

24
 La boucle while
Syntaxe : while (condition) {
instruction ;
…
instruction ;
}
L’exécution des instructions de la boucle sera répétée tant que la condition
précisée entre parenthèses demeure vraie.
Exemple : le calcul du factoriel implémenté dans l’exemple précédent peut
s’inscrire autrement en utilisant la boucle while.
importjavax.swing.*;
public class Factoriel2{
int nombre = 0;
long facto= 1;
try{
nombre = Integer.parseInt(
JOptionPane.showInputDialog("CALCUL DU FACTORIEL\n" +"Entrer un
entier positif :"));
JOptionPane.showMessageDialog(null,"Donnéeinvalide","ERREUR",
System.exit(0);
}
int i = nombre;
while(i>0){
facto *= i;
i-- ;
}
JOptionPane.showMessageDialog(null, "Le factoriel de " + nombre +
" est\n" + facto,"RESULTAT", JOptionPane.PLAIN_MESSAGE);
System.exit(0);
}
}
Attention, le factoriel de 26 n’est pas ce qu’affiche le programme. En effet, la
variable facto est du type long (entier long). Le type long (entier) étant codé
sur 8 octets, il ne peut représenter que le rang de valeur allant de -264-1 à +
264-1-1. Lors des calculs, si une variable dépasse la borne supérieure, alors le
processeur poursuit le travail en bouclant, c’est-à-dire il va à la borne
inférieure, vice versa.
 La boucle do…while
Syntaxe : do {
instruction ;

25
…
instruction ;
} while (condition) ;
La particularité de cette boucle est que les instructions de la boucle sont
exécutées une fois avant que n’intervienne le test sur la condition.
Exemple : Nous avons vu à l’exemple précédent que la taille de la variable
facto ne permettait pas de trouver le factoriel de 26. L’implémentation
actuelle utilise la boucle do…while et calcule le factoriel pour tout nombre
compris entre 1 et 25. En dehors de cet intervalle le factoriel est égal au
nombre entré.
importjavax.swing.*;
public class Factoriel3 {
public static void main (String arg[]){
int nombre = 0;
long facto= 1;
try{
nombre= Integer.parseInt(JOptionPane.showInputDialog("CALCUL DU FACTORIEL\n"
+"Entrer un entier positif"));
JOptionPane.showMessageDialog(null,"Donnée invalide","ERREUR",
System.exit(0);
}
int i = nombre;
do {
facto *= i;
i-- ;
}while(i>0 && i<26);
JOptionPane.showMessageDialog(null, "Le factoriel de " + nombre +" est\n" +
facto,"RESULTAT", JOptionPane.PLAIN_MESSAGE);
System.exit(0);
}
}
2.4. La Manipulation des chaines des caractères

Java dispose d’une classe standard nommée String, permettant
de manipuler des chaînes de caractères, c’est-à-dire des suites de caractères.
A chaque fonctionnalité correspond une méthode définie dans la classe
String.
 Longueur d’une chaîne : length
La méthode length permet d’obtenir la longueur d’une chaîne,
c’est-à-dire le nombre de caractères qu’elle contient.
String ch = "bonjour" ;
int n = ch.length() ; // n contient 7

26
 Accès aux caractères d’une chaîne : charAt
La méthode charAt de la classe String permet d’accéder à un

caractère de rang donné d’une chaîne (le premier caractère porte le rang 0).
Ainsi, avec : String ch = "bonjour" ; // ch.charAt(0) correspond au

caractère ’b’, ch.charAt(2) correspond au caractère ’n’.
 Modification de la casse d’une chaine
Les méthodes toUppercase() et toLowercase() permettent respectivement

d’obtenir une chaine toute en majuscule ou toute en minuscule.
 Extraction de sous-chaine
La méthode substring permet de créer une nouvelle chaîne en
extrayant d’une autre chaîne.
String ch = "anticonstitutionnellement" ;
String ch1 = ch.substring (4, 16) ; // ch1 contient "constitution"
 Remplacement des caractères
La méthode replace crée une chaîne en remplaçant toutes les

occurrences d’un caractère donné par un autre.
String ch = "bonjour" ;
String ch1 = ch.replace(’o’, ’a’) ;
 Suppression des séparateurs de début et de fin
La méthode trim crée une nouvelle chaîne en supprimant les

éventuels séparateurs de début et de fin (espace, tabulations, fin de ligne).
 Comparaison de deux chaines

On utilise la méthode equals pour comparer deux chaines de caractères. On
peut aussi utiliser les opérateurs == et != pour la comparaison.
String texte1 = "Informatique" ;
String texte2 = "InfoCentre" ;
if (texte1.equals(texte2)){
…
}
 Recherche dans une chaine

27
La méthode indexOf permet de rechercher, à partir du début
d’une chaîne ou d’une position donnée : la première occurrence d’un
caractère donné, et la première occurrence d’une autre chaîne.
Dans tous les cas, elle fournit :
• la position du caractère (ou du début de la chaîne recherchée) si une
correspondance a effectivement été trouvée,
• la valeur -1 sinon.
2.5. La gestion des exceptions
De nombreuses fonctions Java sont susceptibles de générer des
exceptions, c'est à dire des erreurs.
Lorsqu'une fonction est susceptible de générer une exception, le
compilateur Java oblige le programmeur à gérer celle-ci dans le but d'obtenir
des programmes plus résistants aux erreurs : il faut toujours éviter le
"plantage" sauvage d'une application.
La gestion d'une exception se fait selon le schéma suivant :
try{
appel de la fonction susceptible de générer l'exception
} catch (Exception e){
traiter l'exception e
}
instruction suivante
Si la fonction ne génère pas d'exception, on passe alors à
l’instruction suivante, sinon on passe dans le corps de la clause catch puis à
instruction suivante.
Notons les points suivants :
- e est un objet dérivé du type Exception. On peut être plus précis en utilisant
des types tels que IOException, SecurityException, ArithmeticException, etc :
il existe une vingtaine de types d'exceptions. En écrivant catch (Exception e),
on indique qu'on veut gérer tous les types d'exceptions.
- On peut ajouter aux clauses try/catch, une clause finally :
try{
appel de la fonction susceptible de générer l'exception
} catch (Exception e){
traiter l'exception e
}
finally{
code exécuté après try ou catch

28
}
instruction suivante
Ici, qu'il y ait exception ou pas, le code de la clause finally sera toujours
exécuté.La classe Exception a certaines méthodes telles que:
- getMessage () qui rend un message détaillant l'erreur qui s'est produite.
- toString () qui rend une chaîne de caractères indiquant le type de l'exception
ainsi que la valeur de la propriété Message.
2.6. Squelette d’une Application

Une application Java est un programme autonome qui peut être
exécuté sur n’importe quelle plateforme disposant d’une machine virtuelle
Java.
Tout type d’application peut être développé en Java : interface
graphique, accès aux bases de données, applications client/serveur,
multithreading...
Une application est composée au minimum d’un fichier .class qui
doit lui-même contenir au minimum le point d’entrée de l’application, la
méthode main ().
Exemple de la structure minimum d’une application :
public class MonApplication {
public static void main(String arguments[ ]) {
/* corps de la méthode principale */
}
}

29
Chapitre III : La notion des Classes et d’Objets
Introduction
La programmation orienté objet est un paradigme de

programmation (une manière de programmer) le plus utilisé de nos jours.
Elle consiste à modéliser informatiquement un ensemble
d'éléments d'une partie du monde réel (que l'on appelle domaine) en un
ensemble d'entités informatiques. Ces entités informatiques sont appelées
« les objets ».
Le principe fondamental d’un langage orienté objet est que le
langage doit permettre d’exprimer la solution d’un problème à l’aide des
éléments de ce problèmes.
3.1. L’Objet par l’exemple
3.1.1. Généralités
Nous abordons maintenant, par l'exemple, la programmation

objet. Un objet est une entité qui contient des données qui définissent son
état (on les appelle des attributs ou propriétés) et des fonctions (on les
appelle des méthodes). Un objet est créé selon un modèle qu'on appelle une
classe :
public class C1{
type1 p1; // propriété p1
type2 p2; // propriété p2
…
type3 m3(…){ // méthode m3
…
}
type4 m4(…){ // méthode m4
…
}
}
A partir de la classe C1 précédente, on peut créer de nombreux
objets O1, O2,… Tous auront les propriétés p1, p2,… et les méthodes m3,
m4, … Ils auront des valeurs différentes pour leurs propriétés pi ayant ainsi
chacun un état qui lui est propre.

30
 Définition d’un Objet
L’objet est comme un élément de l’univers relatif au problème à
traiter.
 Définition d’une Classe

Une classe peut être comparée à un moule (modèle ou patron)
qui, lorsque nous le remplissons, nous donne un objet ayant la forme du
moule ainsi que toutes ses caractéristiques.
C’est aussi considéré comme une description abstraite de
structure des données et de traitements destinée à mémoriser et à gérer une
réalité ou une notion.
3.1.2. Définition de la classe Personne
La définition de la classe Personne sera la suivante :
import java.io.*;
public class Personne{
// attributs
private String prenom;
private String nom;
private int age;
// méthode
public void initialise(String P, String N, int age){
this.prenom=P; this.nom=N; this.age=age;
}
// méthode
public voididentifie(){ System.out.println(prenom+","+nom+","+age);
}
}
Nous avons ici la définition d'une classe, donc un type de
données. Lorsqu'on va créer des variables de ce type, on les appellera des
objets. Une classe est donc un moule à partir duquel sont construits des
objets.
Les membres ou champs d'une classe peuvent être des données
ou des méthodes (fonctions). Ces champs peuvent avoir l'un des trois
attributs suivants :
- Privé : Un champ privé (private) n'est accessible que par les seules méthodes
internes de la classe;
- Public : Un champ public est accessible par toute fonction définie ou non au
sein de la classe;

31
- Protégé: Un champ protégé (protected) n'est accessible que par les seules
méthodes internes de la classe ou d'un objet dérivé.
En général, les données d'une classe sont déclarées privées alors
que ses méthodes sont déclarées publiques. Cela signifie que l'utilisateur
d'un objet (le programmeur):
a) n'aura pas accès directement aux données privées de l'objet;
b) pourra faire appel aux méthodes publiques de l'objet et notamment à
celles qui donneront accès à ses données privées.
La syntaxe de déclaration d'une classe est la suivante :
public class nomClasse{
private donnée ou méthode privée
public donnée ou méthode publique
protected donnée ou méthode protégée
}
3.1.3. La méthode initialise
Revenons à notre classe Personne déclarée comme:
import java.io.*;
// attributs
private String nom;
private int age;
// méthode
this.prenom=P;
this.nom=N;
this.age=age;
}
// méthode
public voididentifie (){
System.out.println(prenom+","+nom+","+age);
}
}
Quel est le rôle de la méthode initialise ? Parce que nom, prenom
et age sont des données privées de la classe Personne, les instructions :
Personne p1;
p1.prenom="Jean"; sont illégales.
p1.nom="Kasonga";
p1.age=30;

32
Il nous faut initialiser un objet de type Personne via une méthode publique.
C'est le rôle de la méthode initialise. On écrira :
Personne p1;
p1.initialise ("Jean","Kasonga",30);
L'écriture p1.initialise est légale car initialise est d'accès public.
3.1.4. L'opérateur new

La séquence d'instructions:
Personne p1;
p1.initialise ("Jean","Kasonga",30); est incorrecte.
L’instruction Personne p1; déclare p1 comme une référence à un
objet de type Personne. Cet objet n'existe pas encore et donc p1 n'est pas
initialisé. C'est comme si on écrivait : déclare p1 comme une référence à un
objet de type Personne. Cet objet n'existe pas encore et donc p1 n'est pas
initialisé. C'est comme si on écrivait : Personne p1=null;
où on indique explicitement avec le mot clé null que la variable
p1 ne référence encore aucun objet. Lorsqu'on écrit ensuite: p1.initialise
("Jean","Kasonga",30);on fait appel à la méthode initialise de l'objet référencé
par p1. Or cet objet n'existe pas encore et le compilateur signalera l'erreur.
Pour que p1 référence un objet, il faut écrire : Personne p1=new Personne ();
Cela a pour effet de créer un objet de type Personne non encore

initialisé : les attributs nom et prenom qui sont des références d'objets de
type String auront la valeur null, et age la valeur 0. Il y a donc une
initialisation par défaut. Maintenant que p1 référence un objet, l'instruction
d'initialisation de cet objet : p1.initialise ("Jean","Kasonga",30); est valide.
3.1.5. Le mot clé this
Regardons le code de la méthode initialise :
this.prenom=P;
this.nom=N;
this.age=age;
}

33
L'instruction this.prenom=P signifie que l'attribut prenom de
l'objet courant (this) reçoit la valeur P. Le mot clé this désigne l'objet courant
: celui dans lequel se trouve la méthode exécutée. Comment le connaît-on ?
Regardons comment se fait l'initialisation de l'objet référencé par p1 dans le
programme appelant : p1.initialise("Jean","Kasonga",30);
C'est la méthode initialise de l'objet p1 qui est appelée. Lorsque
dans cette méthode, on référence l'objet this, on référence en fait l'objet p1.
La méthode initialise aurait aussi pu être écrite comme suit :
prenom=P;
nom=N;
this.age=age;
}
Lorsqu'une méthode d'un objet référence un attribut A de cet
objet, l'écriture this.A est implicite. On doit l'utiliser explicitement lorsqu'il y
a conflit d'identificateurs. C'est le cas de l'instruction : this.age=age;
oùage désigne un attribut de l'objet courant ainsi que le

paramètre age reçu par la méthode. Il faut alors lever l'ambiguïté en
désignant l'attribut age par this.age.
3.1.6. Un programme de test

public class test1{
public static void main(String arg[ ]){
Personne p1=new Personne( );
p1.initialise("Clement","Bakuaya",25);
p1.identifie( );
}
}
3.1.7 Une autre méthode initialise
Considérons toujours la classe Personne et rajoutons-lui la
méthode suivante :
public voidinitialise(Personne P){
prenom=P.prenom;
nom=P.nom;
this.age=P.age;
}

34
On a maintenant deux méthodes portant le nom initialise : c'est
légal tant qu'elles admettent des paramètres différents. C'est le cas ici. Le
paramètre est maintenant une référence P à une Personne.
Les attributs de la Personne P sont alors affectés à l'objet courant
(this). On remarquera que la méthode initialise a un accès direct aux attributs
de l'objet P bien que ceux-ci soient de type private. C'est toujours vrai : les
méthodes d'un objet O1 d'une classe C a toujours accès aux attributs privés
des autres objets de la même classe C.
Voici un test de la nouvelle classe Personne :
// import Personne;
import java.io.*;
public class test1{
Personne p1=new Personne(); p1.initialise("Jean","Kasonga",30);
System.out.print("p1=");
p1.identifie();
Personne p2=new Personne();
p2.initialise(p1);
System.out.print("p2="); p2.identifie();
}
}
3.1.8. Constructeurs de la classe Personne
Un constructeur est une méthode qui porte le nom de la classe et
qui est appelée lors de la création de l'objet. On s'en sert généralement pour
l'initialiser. C'est une méthode qui peut accepter des arguments mais qui ne
rend aucun résultat. Son prototype ou sa définition ne sont précédés d'aucun
type (même pas void).
Si une classe a un constructeur acceptant n arguments argi, la
déclaration et l'initialisation d'un objet de cette classe pourra se faire sous la
forme :
Classe objet =new Classe(arg1,arg2, ... argn);
Ou Classe objet;
…
objet=new Classe(arg1,arg2, ... argn);
Lorsqu'une classe a un ou plusieurs constructeurs, l'un de ces
constructeurs doit être obligatoirement utilisé pour créer un objet de cette
classe. Si une classe C n'a aucun constructeur, elle en a un par défaut qui est
le constructeur sans paramètres : public C( ).

35
Les attributs de l'objet sont alors initialisés avec des valeurs par
défaut. C'est ce qui s'est passé lorsque dans les programmes précédents, on
avait écrit :
Personne p1;
p1=new Personne( );
Créons deux constructeurs à notre classe Personne :
// attributs
private String nom;
private int age;
// constructeurs
publicPersonne(String P, String N, int age){
initialise(P,N,age);
}
public Personne(Personne P){
initialise(P);
}
// méthode
this.prenom=P; this.nom=N; this.age=age;
}
public voidinitialise(Personne P){
this.prenom=P.prenom; this.nom=P.nom;
this.age=P.age;
}
// méthode
public voididentifie(){
System.out.println(prenom+","+nom+","+age);
}
}
Nos deux constructeurs se contentent de faire appel aux
méthodes initialise correspondantes. On rappelle que lorsque dans un
constructeur, on trouve la notation initialise(P) par exemple, le compilateur
traduit par this.initialise(P). Dans le constructeur, la méthode initialise est
donc appelée pour travailler sur l'objet référencé par this, c'est à dire l'objet
courant, celui qui est en cours de construction.
Voici un programme de test :
// import Personne;
import java.io.*;
public class Test1{
Personne p1=new Personne("Clement","Bakuaya",25);

36
Personne p2=new Personne(p1);
p2.identifie();
}
}
3.1.9. Les références d'objets

Nous utilisons toujours la même classe personne. Le programme
de test devient le suivant :
// import personne;
import java.io.*;
public class test1{
// p1
personne p1=new personne("Jean","Kasonga",30);
// p2 référence le même objet que p1
personne p2=p1;
// p3 référence un objet qui sera une copie de l'objet référencé par p1
personne p3=new personne(p1);
// on change l'état de l'objet référencé par p1
p1.initialise("Clement","Kanku",67);
// comme p2=p1, l'objet référencé par p2 a du changer d'état
// comme p3 ne référence pas le même objet que p1, l'objet référencé par p3 n'a pas
du changer
}
}
Les résultats obtenus sont les suivants :
p1=Jean, Kasonga, 30 p1=Clement, Kanku, 67
p2=Jean, Kasonga, 30 p2= Clement, Kanku, 67
p3=Jean, Kasonga, 30 p3= Jean, Kasonga, 30
Lorsqu'on déclare la variable p1 par :
Personne p1=new Personne ("Jean","Kasonga",30);
p1 référence l'objet Personne("Jean","Kasonga",30) mais n'est pas l'objet lui-
même. En C, on dirait que c'est un pointeur, c.à.d..l'adresse de l'objet créé. Si
on écrit ensuitep1=null;
Ce n'est pas l'objet Personne("Jean","Kasonga",30) qui est modifié, c'est
la référence p1 qui change de valeur. L'objet
Personne("Jean","Kasonga",30) sera "perdu" s'il n'est référencé par aucune
autre variable.

37
Lorsqu'on écrit : Personne p2=p1;On initialise le pointeur p2 : il "pointe" sur
le même objet (il désigne le même objet) que le pointeur p1. Ainsi si on
modifie l'objet "pointé" (ou référencé) par p1, on modifie celui référencé par
p2.
Lorsqu'on écrit :Personne p3=new Personne (p1);il y a création d'un nouvel
objet, copie de l'objet référencé par p1. Ce nouvel objet sera référencé par
p3. Si on modifie l'objet "pointé" (ou référencé) par p1, on ne modifie en rien
celui référencé par p3. C'est ce que montrent les résultats obtenus.
3.1.10. Méthodes de lecture et d'écriture des attributs privés
Nous rajoutons à la classe Personne les méthodes nécessaires
pour lire ou modifier l'état des attributs des objets :
public class Personne{ // accesseurs
private String prenom; public String getPrenom(){ return
private String nom; prenom; }
private int age; public String getNom(){ return nom; }
public Personne(String P, String N, int age){ public int getAge(){return age; }
this.prenom=P; //modifieurs
this.nom=N; public void setPrenom(String P){
this.age=age; this.prenom=P;
} }
public Personne(Personne P){ public void setNom(String N){
this.prenom=P.prenom; this.nom=N;
this.nom=P.nom; }
this.age=P.age; public void setAge(int age){
} this.age=age;
public void identifie(){ }
System.out.println(prenom+","+nom+","+age); }
}
Nous testons la nouvelle classe avec le programme suivant :
// import Personne;
public class Test1{
public static void main(String[] arg){
Personne P=new Personne ("Jean","Kasonga",30);
System.out.println("P=("+P.getPrenom()+", "+ P.getNom()+","+P.getAge()+")");
P.setAge(56);
System.out.println("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
}
}
3.1.11. Passage d'un objet à une fonction
Si une référence d'objet R1 est transmise à une fonction, elle sera
recopiée dans le paramètre formel correspondant R2. Aussi les références R2
et R1 désignent-elles le même objet. Si la fonction modifie l'objet pointé par
R2, elle modifie évidemment celui référencé par R1 puisque c'est le même.

38
C'est ce que montre l'exemple suivant :
// import personne;
public class test1{
personne p1=new personne("Jean","Dupont",30);
System.out.print("Paramètre effectif avant modification : ");
p1.identifie();
modifie(p1);
System.out.print("Paramètre effectif après modification : ");
p1.identifie();
}// main
privatestaticvoidmodifie(personne P){
System.out.print("Paramètre formel avant modification : ");
P.identifie();
P.initialise("Sylvie","Vartan",52);
System.out.print("Paramètre formel après modification : ");
P.identifie();
}// modifie
}// class
La méthode modifie est déclarée static parce que c'est une
méthode de classe : on n'a pas à la préfixer par un objet pour l'appeler.
On voit qu'il n'y a construction que d'un objet : celui de la
Personne p1 de la fonction main et que l'objet a bien été modifié par la
fonction modifie.
3.1.12. Un tableau de Personnes
Un objet est une donnée comme une autre et à ce titre plusieurs
objets peuvent être rassemblés dans un tableau :
// import Personne;
public class Test1{
Personne[] amis=new Personne[3];
System.out.println("----------------");
amis[0]=new Personne("Jean","Kasonga",30);
amis[1]=new Personne("Sylvie","Vartan",52);
amis[2]=new Personne("Neil","Armstrong",66);
int i;

39
for(i=0;i<amis.length;i++)
amis[i].identifie();
}
}
L'instruction Personne [] amis=new Personne [3]; crée un tableau de 3
éléments de type personne. Ces 3 éléments sont initialisés ici avec la valeur
null, c.à.d. qu'ils ne référencent aucun objet. De nouveau, par abus de
langage, on parle de tableau d'objets alors que ce n'est qu'un tableau de
références d'objets. La création du tableau d'objets, tableau qui est un objet
lui-même (présence de new) ne crée donc en soi aucun objet du type de ses
éléments : il faut le faire ensuite.
3.2. L'héritage par l'exemple
3.2.1 Généralités
Nous abordons ici la notion d'héritage. Le but de l'héritage est de
"personnaliser" une classe existante pour qu'elle satisfasse à nos besoins.
Supposons qu'on veuille créer une classe enseignant : un enseignant est une
personne particulière. Il a des attributs qu'une autre personne n'aura pas : la
matière qu'il enseigne par exemple.
Un enseignant fait donc pleinement partie de la classe personne
mais a des attributs supplémentaires. Plutôt que d'écrire une classe
enseignant en partant de rien, on préfèrerait reprendre l'acquis de la classe
personne qu'on adapterait au caractère particulier des enseignants. C'est le
concept d'héritage qui nous permet cela.
Pour exprimer que la classe enseignant hérite des propriétés de
la classe personne, on écrira :
public class Enseignant extends Personne
Personne est appelée la classe parent (ou mère) et Enseignant la
classe dérivée (ou fille). Un objet enseignant a toutes les qualités d'un objet
personne : il a les mêmes attributs et les mêmes méthodes. Ces attributs et
méthodes de la classe parent ne sont pas répétées dans la définition de la
classe fille : on se contente d'indiquer les attributs et méthodes rajoutés par
la classe fille :
public class Enseignant extendsPersonne{

40
// attributs
private int section;
// constructeur
public Enseignant(String P, String N, int age,int section){
super(P,N,age);
this.section=section;
}
}
La méthode identifie a été légèrement modifiée pour rendre une
chaîne de caractères identifiant la personne et porte maintenant le nom
identite. Ici la classe enseignant rajoute aux méthodes et attributs de la
classe personne :un attribut section qui est le n° de section auquel appartient
l'enseignant dans le corps des enseignants (une section par discipline en
gros).
3.2.2. Construction d'un objet enseignant
Le constructeur de la classe enseignant est le suivant :
// Constructeur
public Enseignant (String P, String N, int age, int section) {
super (P,N,age);
}
L'instruction super (P,N,age) est un appel au constructeur de la
classe parent, ici la classe personne. On sait que ce constructeur initialise les
champs prenom, nom et age de l'objet personne contenu à l'intérieur de
l'objet enseignant.
// constructeur
publicEnseignant(String P, String N, int age, int section){
this.prenom=P;
this.nom=N;
this.age=age;
}
C'est impossible. La classe personne a déclaré privés (private) ses
trois champs prénom, nom et age. Seuls des objets de la même classe ont un
accès direct à ces champs. Tous les autres objets, y compris des objets fils
comme ici, doivent passer par des méthodes publiques pour y avoir accès.
Cela aurait été différent si la classe personne avait déclaré protégés
(protected) les trois champs : elle autorisait alors des classes dérivées à avoir
un accès direct aux trois champs. Dans notre exemple, utiliser le
constructeur de la classe parent était donc la bonne solution et c'est la

41
méthode habituelle : lors de la construction d'un objet fils, on appelle
d'abord le constructeur de l'objet parent puis on complète les initialisations
propres cette fois à l'objet fils (section dans notre exemple).
// import personne;
// import enseignant;
public class test1{
public staticvoidmain(String arg[]){
System.out.println(new enseignant("Jean","Kasonga",30,27).identite());
}
}
Ce programme ce contente de créer un objet enseignant (new) et
de l'identifier. La classe enseignant n'a pas de méthode identité mais sa
classe parent en a une qui de plus est publique : elle devient par héritage une
méthode publique de la classe enseignant.
3.2.3 Surcharge d'une méthode

Dans l'exemple précédent, nous avons eu l'identité de la partie
personne de l'enseignant mais il manque certaines informations propres à la
classe enseignant (la section). On est donc amené à écrire une méthode
permettant d'identifier l'enseignant :
public class Enseignant extendsPersonne{
int section;
publicEnseignant(String P, String N, int age, int section){
super(P,N,age);
}
public String identite(){
return "enseignant("+super.identite()+","+section+")";
}
}
La méthode identite de la classe enseignant s'appuie sur la
méthode identite de sa classe mère (super.identite) pour afficher sa partie
"personne" puis complète avec le champ section qui est propre à la classe
enseignant.
L'héritage permet donc de surcharger dans la classe fille des
méthodes de même nom dans la classe mère. C'est ce qui permet d'adapter la
classe fille à ses propres besoins.

42
Considérons le même exemple que précédemment :
public class test1{
System.out.println(new enseignant("Jean","Kasonga",30,27).identite());
}
}
3.3. Les paquetages
3.3.1 Créer des classes dans un paquetage
Pour écrire une ligne à l'écran, nous utilisons l'instruction :
System.out.println(...)
Si nous regardons la définition de la classe System nous
découvrons qu'elle s'appelle en fait java.lang.System :
Vérifions-le sur un exemple :

public class Test1{
public static void main(String[ ] args){
java.lang.System.out.println("Coucou");
}//main
}//classe
3.2.2. Recherche des paquetages
Lorsque nous écrivons dans un programme :import java.util.*;
Pour avoir accès à toutes les classes du paquetage java.util, où
celui-ci est-il trouvé ? Nous avons dit que les paquetages étaient cherchés par
défaut dans le répertoire courant ou dans la liste des répertoires déclarés
dans l'option classpath du compilateur ou de la JVM si cette option est
présente. Ils sont également cherchés dans les répertoires lib du répertoire
d'installation du JDK.

43
Chapitre IV : Accès aux bases de données et Création des
programmes d’installation Java
4.1. Accès aux Bases de Données

JDBC est l'acronyme de Java DataBaseConnectivity et désigne une
API (Application Programming Interface) définie par Sun pour permettre un
accès aux bases de données avec Java. Les classes de JDBC sont regroupées
dans le package java.sql. Afin que les applications Java puissent tirer parti
elles-aussi de l’interface ODBC, Sun a créé l’interface JDBC (Java
DataBaseConnectivity) qui va s’intercaler entre l’application Java et l’interface
ODBC :
4.1.1. Enregistrer la base de données comme source de Données

Utilisateur (Data Source Name)
Il faut d’abord créer la base de données et l’enregistrer comme

une source de données utilisateur. Pour enregistrer la base de données en
tant que source de données utilisateur, il faut suivre la procédure suivante :
Menu Démarrer >Panneau de configuration > Outils

d’administration > Sources de données (ODBC Data Sources (32-bit)) >
Onglet Source de données Utilisateur, bouton Ajouter > Double cliquer sur le
pilote pour lequel vous souhaiter définir une source de données >Installation
ODBC du pilote sélectionné : cliquer sur le bouton sélectionner… ;
Parcourir jusqu’au répertoire où la base de données est

enregistrée. Celle-ci apparaîtra dans la liste de gauche > Cliquer sur le bouton
OK > Dans la fenêtre Installation ODBC …, tapez dans la zone de texte nom
de la source de données, le nom de la base de données sans son extension et
cliquer sur le bouton OK pour terminer.

44
4.1.2. Présentation des classes de l'API JDBC
Toutes les classes de JDBC sont dans le package java.sql. Il faut

donc l'importer dans tous les programmes devant utiliser JDBC.Exemple :
import java.sql.*;
Il y a 4 classes importantes : DriverManager, Connection,

Statement (PreparedStatement), et ResultSet, chacune correspondant à une
étape de l'accès aux données :
Classe Rôle
DriverManager charge et configure le driver de la base
de données.
Connection réalise la connexion et
l'authentification à la base de données.
Statement (et PreparedStatement ) contient la requête SQL et la transmet à
la base de données.
permet de parcourir les informations

ResultSet retournées par la base de données dans le
cas d'une sélection de données
Chacune de ces classes dépend de l'instanciation d'un objet de la
précédente classe.
1. Connexion à la base de données
- Importer préalablement le package java.sql : import java.sql.* ;
- Créer l’interface JDBC-ODBC : Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
- Etablir la connexion avec la base de données: on crée un objet de la classe

Connection grâce à la méthode getConnection() de la classe DriverManager.
La méthode getConnection() reçoit trois paramètres : l’url

représentant la base de données, le nom de l’utilisateur de la base de
données et le mot de passe.
Ces deux derniers paramètres sont des chaînes de caractères qui

peuvent être vides. L’url est une chaîne de caractères dont la syntaxe est :
"jdbc : odbc : base" où base est le nom de la base de données enregistrée en
tant que source de données utilisateur.

45
Nous allons détailler chacune de ces étapes sur un exemple.
Nous considérons une base de données ACCESS appelée ARTICLES et ayant la
structure suivante :
Cette base ACCESS est définie comme source de données «

utilisateur » dans le gestionnaire des bases ODBC :
Cette configuration consiste essentiellement à associer à la base

ARTICLES, le fichier Access articles.mdb correspondant à cette base. Ceci fait,
la base ARTICLES est accessible aux applications utilisant l’interface ODBC.
Voici l’étape de la connexion à l’aide du Langage Java :

importjava.sql.*;
….
public class Gest_Articlesextendsjavax.swing.JFrame {
Connection con=null;
Statement stat=null;
ResultSetrs=null;
String base="jdbc:odbc:Articles";
public voidconnex(){
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
con=DriverManager.getConnection(base,"","");
JOptionPane.showMessageDialog(null,"Connexion à la BDD OK")
}
catch(Exception e){
JOptionPane.showMessageDialog(null,"Erreur de connexion");
System.exit(0);
}
}

46
2. Emissions des requêtes SQL à la base de données
En Java, le seul moyen de travailler avec les bases de données est

d’y émettre des requêtes SQL (StructuredQuery Language).
Il faut préalablement créer un objet la classe Statement en

utilisant la méthode createStatement appliquée à un objet Connection. Cet
objet de la classe Statement sert à exécuter les requêtes SQL :
Soit que la connexion est déjà établie et représentée, par

exemple, par l’objet con de la classe Connection : Statement stat =
con.createStatement() ; (Attention : cette instruction est susceptible de
lancer une exception).
 Requête d'insertion dans la base de données
Pour faire l'insertion des données, on utilise la méthode

executeUpdate(). Celle-ci doit être exécutée par un objet Statement. La
méthode executeUpdate() retourne un entier qui correspond au nombre
d’enregistrements mis à jour.
Exemple : int nbEnreg = stat.executeUpdate(requete) ;
L’extrait du code qui suit permet l’Enregistrement d'un article :

public void enregistrement(){
String code=jTextField1.getText();
String design=jTextField2.getText();
float prix=0.0f;
intstkact=0, stkmin=0;
try{
prix=Float.parseFloat(jTextField3.getText());
stkact=Integer.parseInt(jTextField4.getText());
stkmin=Integer.parseInt(jTextField5.getText());
stat=con.createStatement();
String requete="insert into Articles values ('" + code + "', '" + design + "', "
+prix + ", " + stkact + "," + stkmin + ")";
intnbrEnreg=stat.executeUpdate(requete1);
JOptionPane.showMessageDialog(null, "Vous venez
d'ajouter"+nbrEnreg+"enregistement dans la BDD");
}
con.close();
}

47
 Requête de consultation de la base de données
- Emission de la requête
Le résultat de la consultation consiste en un ou plusieurs
enregistrements de la base de données. D’où la nécessité de créer un objet de
la classe ResultSet qui recueille le résultat de la consultation.
Exemple : ResultSet résultat ;
L’émission d’une requête de consultation se fera en utilisant la

méthode executeQuery() exécutée par un objet de la classe Statement
préalablement créé, de telle sorte que le résultat de la consultation soit
recueilli par un objet ResultSet.
Les principales méthodes pour obtenir des données sont :
Méthode Rôle
retourne sous forme d'entier le contenu de la colonne
getInt(int) dont le numéro est passé en paramètre.
retourne sous forme d'entier le contenu de la colonne
getInt(String) dont le nom est passé en paramètre.
retourne sous forme d'un nombre flottant le contenu

getFloat(int) de la colonne dont le numéro est passé en
paramètre.
Exemple : float prix = rs.getFloat(3)
retourne sous forme d'un nombre flottant le contenu
getFloat(String) de la colonne dont le nom est passé en paramètre.
Ex.:float prix = rs.getFloat(« produitPrixUnit ») ;
retourne sous forme de date le contenu de la colonne

getDate(int) dont le numéro est passé en paramètre.
retourne sous forme de date le contenu de la colonne

getDate(String) dont le nom est passé en paramètre.
se déplace sur le prochain enregistrement : retourne

next() false si la fin est atteinte
Exemple : rs.next() ; //Passage à l’enregistrement
//suivant de rs. L’enregistrement précédent
//disparaît, sans espoir d’y revenir
close() ferme le ResultSet. Exemple : rs.close() ;

- getString(int) : retourne le contenu de la colonne dont le numéro est
passé en paramètre sous forme de chaîne de caractères.
Ex. : String libellé = rs.getString(2);

48
- getString(String) : retourne le contenu de la colonne dont le nom est
passé en paramètre sous forme de chaîne de caractères.
Exemple : String libellé = rs.getString("Design");
- getDouble(int) : retourne le contenu de la colonne dont le numéro est
passé en paramètre sous forme de nombre flottant double précision.
- getDouble(String) : retourne le contenu de la colonne dont le nom est
passé en paramètre sous forme de nombre flottant double précision.
- La classe ResultSetMetaData
La méthode getMetaData() d'un objet ResultSet retourne un objet

de type ResultSetMetaData. Cet objet permet de connaître le nombre, le nom
et le type des colonnes.
Méthode Rôle
int getColumnCount() retourne le nombre de colonnes du ResultSet
String getColumnName(int) retourne le nom de la colonne dont le
numéro est donné
String getColumnLabel(int) retourne le libellé de la colonne donnée
boolean isCurrency(int) retourne true si la colonne contient un

nombre au format monétaire
boolean isReadOnly(int) retourne true si la colonne est en lecture

seule
boolean isAutoIncrement(int) retourne true si la colonne est auto
incrémentée
int getColumnType(int) retourne le type de données SQL de la
colonne
- Recherche d'un article
public void recherche(){

String coderech=jTextField1.getText();
try{
String requete="select * from Articles where Code='"+coderech+"' ";
rs=stat.executeQuery(requete);
if(rs.next()){ //sil'enregistrementexiste
jTextField2.setText(rs.getString(2));
jTextField3.setText(""+rs.getFloat("Prix"));
jTextField4.setText(""+rs.getInt(4));

49
jTextField5.setText(""+rs.getInt("Stock_mini"));
}
con.close();
JOptionPane.showMessageDialog(null, stat);
}
}
- Modification d'un article
public void modification(){
String codemod=jTextField1.getText();
String nom=jTextField2.getText();
try{
float prix=Float.parseFloat(jTextField3.getText());
intstkact=Integer.parseInt(jTextField4.getText());
intstkmin=Integer.parseInt(jTextField5.getText());
String requete1="update Articles set Nom= '" + nom + "', Prix=" +prix + ",
Stock_actu= " + stkact + ",Stock_mini=" + stkmin + " where
Code='"+codemod+"'";
intnbEnreg=stat.executeUpdate(requete1);
JOptionPane.showMessageDialog(null,"Vous avez effectué"+nbEnreg+"mise à

jour");
System.err.println("Echec connexion"+e.getMessage());
System.exit(0);
4.2. Création des programmes d’installation Java
Après avoir créé votre programme, vous avez envie de le

partager, mais vous ne savez pas sous quelle forme. Jusqu’à maintenant,

50
vous avez utilisé votre EDI pour le lancement de votre programme, mais vous
ne pouvez pas le distribuer ainsi.
Dans ce point, nous allons montrer comment créer un exécutable

de votre programme Java : un fichier BAT, un JAR, un lanceur ou un
exécutable natif.
Pour cela, voici les 3 étapes à suivre pour le déploiement d’une

application Java sous Windows :
 Génération du fichier .jar de l’application Java

 Conversion du fichier .jar vers .exe par : Launch4j
 Création d’un fichier d’installation par : Inno Setup Compiler.
4.2.1. Génération du fichier .jar de l’application Java
Un .jar est tout simplement l’exécutable Java par défaut, c’est

l’équivalent du .exe pour le C++. Un jar est utilisable comme n’importe quel
exécutable sur votre ordinateur pour peu qu’il possède bien la JVM. Un jar
n’est rien d’autre qu’une archive contenant un fichier Manifeste
(MANIFEST.MF) que la JVM va aller lire pour savoir quelle classe lancer et que
ce qu’il faut inclure dans le Class-Path.
Pour créer un .jar avec Netbeans, il faut faire un clic droit sur le
projet, puis cliquer sur "build Project".Ensuite, le .jar sera automatiquement
créé dans le répertoire dist de votre projet.

51
4.2.2. Conversion du fichier .jar vers .exe par : Launch4j
Après la génération du fichier .jar de l’application Java dans le

dossier dist du projet.
Il suffit ici de compléter les champs de chaque onglet un par un.

Dès que tout est complété il vous suffira de cliquer sur "BuildWrapper". Vous
pouvez ensuite directement tester le lanceur avec le bouton "testWrapper".

52
4.2.3. Création d’un fichier d’installation par : Inno Setup Compiler
Inno Setup est un logiciel gratuit fonctionnant sur les systèmes

d'exploitation Windows (7, XP, Vista...). Elle vouspermet de créer un
installateur d'une application, qu'elle soit développée en Java, C, C++, Ada,
Pascal, etc.
 Création de l'installateur de l'application
Étape 1 : Lancez Inno setup dans le menu démarrer de votre ordinateur. Puis
choisissez Create a new script file usingscript wizard. Un assistant vous
aidera à construire votre installateur. Puis, cliquez sur le bouton OK.
L'assistant s'ouvre : cliquez next.
Étape 2: renseignez le nom de votre application (Application name), sa

version (Application version), la compagnie(ou personne) propriétaire
(Application publisher) et enfin un site web de l'application (Application
website). Puis, next.

53
Lorsque la création de l'installateur sera terminée, vous pourrez voir une
partie de ces informations en posant lecurseur sur le fichier installateur créé
par Inno Setup, et une autre dans ses propriétés onglet détails (clique
droitsur le fichier-->propriétés-->détails).
Étape 3 : choisissez le répertoire qui accueillera votre application

(Application destination base folder), lorsque vousl'installerez sur un
ordinateur (Program Files, par défaut). Puis, next.

54
Étape 4 : indiquez où se trouve le fichier exécutable de votre application
(dans notre cas, executable-calculatrice). Vousdevez l'indiquer dans le champ
texte appelé Application main executable file. Puis, next.

55
Étape 5 : renseignez un certain nombre de Paramètres (à votre guise). Puis,
next.
Étape 6 : renseignez la licence du logiciel (Licence file) de votre application

(est-elle gratuite/payante ?) et d'autresinformations telles que le Read me
(Information file shownbefore the installation), le manuel d'utilisation
(Informationfile shownafter the installation), etc. Puis next.

56
Étape 7 : choisissez les différentes langues que propose Inno Setup à
l'assistant d'installation pour guider l'utilisateurà déployer l'application sur
son ordinateur. Puis, next.
Étape 8 : renseignez des informations telles: le répertoire dans lequel sera

déposé l'installateur de votre application(Custom compiler output folder); le
nom que vous donnez à cet installateur (Computer output base file name); si
vousvoulez donner une image icône à votre installateur, renseignez le champ
Custom file icon file. L'installateur doit-ilinstaller votre application avec un
mot de passe? (Setup Password). Puis, next.

57
Cliquez next à la prochaine fenêtre. Puis finish. Puis compiler le script qui est
généré automatiquement, à la demandede la boîte de dialogue qui apparaît et
l'enregistrer dans un répertoire de votre machine.
L'installateur de votre application est automatiquement créée dans un

dossier du répertoire que vous avez choisi.

58

Cours de Java G3 IG JOUR ISP 2020 SMM

Transféré par

Droits d'auteur :

Formats disponibles

Cours de Java G3 IG JOUR ISP 2020 SMM

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours de Java G3 IG JOUR ISP 2020 SMM

Transféré par

Droits d'auteur :

Formats disponibles

Institut Département d’Informatique

LANGAGE DE PROGRAMMATION JAVA

Java est un langage très utilisé, notamment par un grand nombre de

On peut faire de nombreuses sortes de programmes avec Java :

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Chapitre 1 : Environnement de développement Intégré Java

Chapitre 2 : Les bases du langage Java

Chapitre 3 : Classes et Objets

Chapitre 4 : Accès aux bases de données et Création des programmes

- Claude DELANNOY, Programmer en Java, 5e Edition, Ed. EYROLLES,

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

La nécessité de faciliter et d’automatiser le processus de

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

NB : Toute instruction en java se termine par un point-virgule ( ; )

I.4.5. La fenêtre de démarrage du projet

, vous déroulez et cliquez sur Customize…, en suite

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Faites un clic droit sur le bouton de commande, sélectionner Evénements sur

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Extrait du code d’un programme utilisant un combobox pour y ajouter les

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Nous traitons Java d'abord comme un langage de programmation

2.1. Les données de Java

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

2.1.3. Déclaration des données

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

2.1.4. Les conversions entre nombres et chaînes de caractères

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

1. lecture d'informations provenant du clavier

2.2.1. Ecriture sur écran

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

3. Les caractères d’échappement

2.2.2. Lecture de données tapées au clavier

1. Utilisation de l'objet Scanner

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Type de commentaires Exemple

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

équivalent à : a = a << 10 a est complété par des zéros à droite

Il existe diverses fonctions mathématiques :

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

>> Décalage vers la droite 10>>1 5

< a<10 strictement inférieur

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

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

& a&b ET binaire

^ a^b OU exclusif binaire

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

opérateur conditionnel : renvoie la valeur b ou c

 Les opérateurs Booléens

&& Et logique If(test1) Vraie si test1 et test2 sont

2.3. Les instructions de contrôle du déroulement du programme

2.3.2. Les Structures de Contrôle

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat

Institut Supérieur Pédagogique de Mbuji-mayi | Troisième Graduat