Cours Java Tome 1

UNIVERSITE BARACK OBAMA DE SONFONIA COURS DE JAVA SE
TOME I : LES BASES DU LANGAGE JAVA
Table des matières

CHAPITRE 1 : PRESENTATION DU LANGAGE JAVA .................................. 4
1- Historique : ....................................................... 4
2- Java et la programmation orientée objet ................................... 4
3- Java et la programmation événementielle .................................. 5
3.1.1- Les programmes à interface console ................................. 5
3.1.2- Les programmes à interface graphique (G.U.I.) ......................... 5
4- Java et la portabilité ................................................. 6
5- Règles d’écriture d’un programme Java .................................... 7
6- Compilation et Exécution d’un programme java. .............................. 8
7- Les Editions du langage JAVA. ........................................... 9
CHAPITRE 2 : LES TYPES PRIMITIFS DE JAVA ..................................... 10
1- Les Entiers ....................................................... 10
2- Les Réelles ....................................................... 10
3- Les caractères .................................................... 10
4- Les booléens ..................................................... 10
CHAPITRE 3 : LES VARIABLES ET LES CONSTANTES ................................ 11
1- Notion de Variable ................................................. 11
2- Notion de Constantes ............................................... 11
CHAPITRE 4 : LES OPERATEURS ET LES EXPRESSIONS .............................. 12
1- Les Opérateurs Arithmétiques ......................................... 12
2- Les Opérateurs d’affectation élargie ..................................... 13
3- Les Opérateurs d’incrémentation et de décrémentation ........................ 14
4- Les Opérateurs relationnels ........................................... 14
5- Les Opérateurs logiques ............................................. 15
6- L’opérateur d’expression Conditionnel ................................... 15
CHAPITRE 5 : LES D’ENTREES/SORTIES ........................................ 16
1- Lecture d’information au clavier ........................................ 16
2- Affichage d’information à l’écran ....................................... 17
Proposé par BAH AMADOU TIDIANE [BGRAS] Chef de département MIAGE/GENI INFORMATIQUE
UNIVERSITE BARACK OBAMA
Contact : 625789118
Mail : [email protected] Page 1

Exercices d’Application................................................... 17
CHAPITRE 6 : LES INSTRUCTIONS DE CONTROLES DE JAVA .......................... 18
1- Les Structures de Contrôles ........................................... 18
1.1- L’instruction if ................................................ 18
1.2- Imbrication des instructions if .................................... 19
1.3- L’instruction switch ............................................ 19
4- Les Structures de Boucles ............................................ 21
4.1- La Boucle do...while ............................................ 21
4.2- La Boucle while................................................ 21
4.3- La Boucle for.................................................. 21
5- Les instructions de Branchement inconditionnelles .......................... 23
5.1- L’instruction break ............................................. 23
5.2- L’instruction continue ........................................... 24
Exercice d’application ................................................... 26
CHAPITRE 7 : Les CLASSES ET LES OBJETS....................................... 29
1- Définition d’une classe............................................... 29
1.1- Définition des champs........................................... 29
1.2- Définition des méthodes ......................................... 29
1.3- Utilisation d’une classe .......................................... 30
2- La notion de constructeur ............................................ 32
2.1- Généralités ................................................... 32
2.2- Quelques règles concernant les constructeurs ......................... 33
2.3- Typologie des méthodes d’une classe ............................... 34
3- Affectation et comparaison d’objets ..................................... 35
3.1- La notion de clone .............................................. 35
3.2- Comparaison d’objets ........................................... 35
4- Champs et méthodes de classe ......................................... 35
4.1- Champs de classe .............................................. 36
4.2- Méthodes de classe ............................................. 37
5- Sur définition de méthodes ........................................... 37
Contact : 625789118

6- Autoréférence : le mot-clé this ......................................... 38
7- La récursivité des méthodes ........................................... 39
8- Les objets membres ................................................ 39
9- Les classes internes................................................. 41
9.1- Imbrication de définitions de classe ................................ 41
9.2- Lien entre objet interne et objet externe ............................. 41
Exercices d’application ................................................... 43
CHAPITRE 8 : LES TABLEAUX ................................................ 47
1- Déclaration et création de tableaux ...................................... 47
1.1- Déclaration de tableaux ......................................... 47
1.2- Création d’un tableau ........................................... 47
1.2.1- Création par l’opérateur new ..................................... 47
1.2.2- Utilisation d’un initialiseur ....................................... 48
2- Accès aux éléments d’un tableau ........................................ 48
3- La taille d’un tableau : length .......................................... 48
4- Utilisation de la boucle for.… each ....................................... 49
5- Cas particulier des tableaux de caractères ................................. 49
6- Tableau en argument ou en retour ...................................... 49
7- Les tableaux à plusieurs indices ........................................ 50
7.1- Création ..................................................... 50
7.2- Initialisation .................................................. 50
8- Arguments variables en nombre ........................................ 50
Exercice d’application ................................................... 51
Contact : 625789118
CHAPITRE 1 : PRESENTATION DU LANGAGE JAVA
1- Historique :
Le langage Java est issu d’un projet de Sun Microsystems datant de 1990 développer JAMES GOSLING
et son équipe.
2- Java et la programmation orientée objet

Il introduit de nouveaux concepts, en particulier ceux d’objets, d’encapsulation, de classe et
d’héritage.
Java est-il un pur langage de P.O.O ?
Certains langages ont été conçus pour appliquer à la lettre les principes de P.O.O. C’est notamment le
cas de Simula, Smalltalk et de Eiffel. Dans ce cas, tout est objet (ou instance de classe) et
l’encapsulation des données est absolue. Les procédures sont obligatoirement des méthodes, ce qui
revient à dire qu’il n’existe pas de procédures indépendantes, c’est-à-dire susceptibles de s’exécuter
indépendamment de tout objet.
Java n’appartient pas à cette catégorie, autrement dit un pur langage de P.O.O. pour les raisons ci-
dessous :
 Java dispose de types dits primitifs pour représenter les entiers, les flottants, les caractères et
les booléens. Les variables correspondantes ne sont pas des objets. En POO pur ces types
primitifs seront utilisés que pour définir les champs d’une classe, donc finalement d’un objet ;
 Une classe pourra comporter des méthodes particulières dites méthodes de classe (déclarées
avec le mot-clé static) qui seront utilisables de façon indépendante d’un objet. En POO pur il
n’y a pas de méthodes static.
 L’encapsulation se trouve naturellement induite par la syntaxe du langage mais elle n’est pas
obligatoire. En POO pur l’encapsulation des champs est obligatoire.
Contact : 625789118
3- Java et la programmation événementielle

Actuellement, on peut distinguer deux grandes catégories de programmes, en se fondant sur leur
interface avec l’utilisateur, c’est-à-dire sur la manière dont se font les échanges d’informations entre
l’utilisateur et le programme :
 Les programmes à interface console,

 Les programmes à interface graphique.
3.1.1- Les programmes à interface console
Historiquement, ce sont les plus anciens. Dans de tels programmes, on fournit des informations à
l’écran sous forme de lignes de texte s’affichant séquentiellement, c’est-à-dire les unes à la suite des
autres. Pour fournir des informations au programme, l’utilisateur frappe des caractères au clavier
Entrent dans cette catégorie :
• Les programmes fonctionnant sur PC sous DOS ou, plus fréquemment, dans une fenêtre DOS de
Windows,
• Les programmes fonctionnant sous Unix ou Linux et s’exécutant dans une "fenêtre de commande".
Avec une interface console, c’est le programme qui décide de l’enchaînement des opérations :
l’utilisateur est sollicité au moment voulu pour fournir les informations demandées.
3.1.2- Les programmes à interface graphique (G.U.I.)
Dans ces programmes, la communication avec l’utilisateur se fait par l’intermédiaire de composants
tels que les menus, les barres d’outils ou les boîtes de dialogue, ces dernières pouvant renfermer des
composants aussi variés que les boutons, les cases à cocher, les boutons radio, les boîtes de saisie, les
listes déroulantes...
L’utilisateur a l’impression de piloter le programme, qui semble répondre à n’importe laquelle de ses
demandes. D’ailleurs, on parle souvent dans ce cas de programmation événementielle, expression qui
traduit bien le fait que le programme réagit à des évènements provoqués par l’utilisateur.
Le terme G.U.I. (Graphical User Interface) désigne ce genre d’interface.
Le langage Java utilise toutes ces deux techniques de programmation
Contact : 625789118
4- Java et la portabilité
Dans la plupart des langages, on dit qu’un programme est portable car un même code source peut
être exploité dans des environnements différents moyennant simplement une nouvelle compilation.
En Java, la portabilité va plus loin. La compilation d’un code source produit, non pas des motifs
binaires, mais un code intermédiaire formé de byte codes. D’une part, ce code est exactement le
même, quel que soit le compilateur et l’environnement concernés. Ces byte codes sont exécutables
dans toute implémentation.
Application Code Binaire Windows

C,C++,...en Windows
Application Code Binaire Unix

C, C++,...en Unix
Application Code Binaire MAC

C, C++,...en MAC
Contact : 625789118
5- Règles d’écriture d’un programme Java

Java bien que n’étant pas un pur langage orienté Objet l’écriture du programme respecte cependant
les normes de la P.O.O.
• Toute instruction doit se placer dans une méthode
• Toute méthode doit être dans une classe
Le canevas général pour écrire un programme java est le suivant :
class NomclassePrincipale
{
public static void main(String [] Args)
{
-------------------------------
-------------------------------
}
}
NB :
Java est un langage fortement sensible à la casse c’est-à-dire qu’il fait la différence entre les
minuscules et les majuscules.
Par exemple si vous écrivez string au lieu de String il signale une erreur.
Contact : 625789118

Java dispose de plusieurs classes et de méthode prédéfinies et il impose les règles suivantes :
- Le nom des classes composées d’un seul mot commence par une lettre majuscule et le reste
en minuscule.
- Si la classe est composée de plusieurs mots la première lettre de chaque mot en majuscule et
le reste en minuscule.
- Le nom des méthodes composées d’un seul mot s’écrit en minuscule.
- Si la méthode est composée de plusieurs mots la première lettre du deuxième mot en
majuscule et le reste en minuscule
- Tous les mots clés sont écrits en minuscule. - Les constantes prédéfinies en majuscule.
6- Compilation et Exécution d’un programme java.

Pour compiler et Exécuter un programme java vous pouvez utiliser l’invite de commande DOS ou un
IDE tels que : Jcreator, Eclipse, Netbeans, …
Avant d’attendre les notions de classes nous utiliserons l’invite de commande DOS pour la
compilation et l’exécution de nos programmes. Avant son utilisation il faudra paramétrer les
commandes java (C:\Program Files (x86) \Java\jdk1.7.0\bin) dans les variables d’environnement
du système d’exploitation.
Après avoir paramétré les variables d’environnement lancez l’invite de commande DOS et via la
commande cd (change directory) placer vous sur le répertoire où se trouve votre fichier source(.java)
et lancez la commande suivante :
C:\\...\monrepertoire>Javac nomfichiersource.java
S’il n’y a aucune erreur dans votre code source vous verrez l’invite de commande à nouveau
C:\\...\monrepertoire>
Sinon le compilateur (javac) affiche la liste des erreurs que vous devez corriger et recompilez.
Après avoir fini exécutez maintenant le fichier byte code (.class) généré après la compilation.
NB :
Le nom du fichier byte codes ne porte pas forcement le même nom que le fichier source au fait il
porte le nom de la classe où se trouve la fonction main. Pour éviter des erreurs faites de telles sortes
que le fichier source possède le même nom lors de l’enregistrement. Pour exécuter votre programme
faite appel à la JRE en tapant la commande :
C:\\...\monrepertoire>Java nomfichierbytecodes
NB : On ne doit pas préciser l’extension du fichier byte codes

Contact : 625789118
7- Les Editions du langage JAVA.

Le langage Java est livré sous trois éditions :
• JSE : Java standard Edition pour le développement des applications simple sur des PC (tel que
la connexion aux bases de donnée).
• JEE : Java Enterprise Edition, ou Java EE (anciennement J2EE) destinée aux applications
d’entreprise (de types serveurs).
• JME : La plate-forme Java, Micro Edition (Java ME) fournit un environnement robuste et
flexible pour les applications qui s'exécutent sur des périphériques intégrés et mobiles :
téléphones mobiles, décodeurs etc.
Contact : 625789118
CHAPITRE 2 : LES TYPES PRIMITIFS DE JAVA

1- Les Entiers
Java dispose de quatre types entiers, correspondant chacun à des emplacements mémoire de taille
différente, donc à des limitations différentes :
 byte
 short
 int
 long
2- Les Réelles
 float
 double
3- Les caractères
Une variable de type caractère se déclare en utilisant le mot-clé char comme dans :
char c1, c2 ;
4- Les booléens
Ce type sert à représenter une valeur logique du type vrai/faux. En Java, on peut disposer de variables
de ce type, en utilisant le mot clé boolean :
boolean ordonne ; // déclaration d’une variable de type booléen
Contact : 625789118
CHAPITRE 3 : LES VARIABLES ET LES CONSTANTES

1- Notion de Variable
Une variable peut recevoir une valeur initiale au moment de sa déclaration :
int n = 15 ;
Rien n’empêche que la valeur de n n’évolue par la suite. Il est aussi possible d’associer la déclaration
de plusieurs variables si elles sont de même type :
int n, m=9, p ;
 En Java les déclarations peuvent apparaître à n’importe quel emplacement du programme

 En Java, une variable n’ayant pas encore reçu de valeur ne peut pas être utilisée, sous peine
d’aboutir à une erreur de compilation.
2- Notion de Constantes
En Java les constantes sont des variables déclarées de type final c’est ce mot clé qui permet de
déclarer une constante.
En théorie, vous n’êtes pas obligé d’initialiser une variable déclarée final lors de sa déclaration. En
effet, Java demande simplement qu’une variable déclarée final ne reçoive qu’une seule fois une
valeur.
final int n ; // OK, même si n n’a pas (encore) reçu de valeur

.....
n = 5; // première affectation de n : OK
.....
n++ ; // nouvelle affectation de n : erreur de compilation
Cette démarche nuit fortement à la lisibilité des programmes il faut toujours chercher à initialiser une
constante lors de sa déclaration.
Contact : 625789118
CHAPITRE 4 : LES OPERATEURS ET LES EXPRESSIONS
1- Les Opérateurs Arithmétiques

Comme tous les langages, Java dispose d’opérateurs classiques binaires (c’est-à-dire portant sur deux
opérandes), à savoir l’addition (+), la soustraction (-), la multiplication (*) et la division (/),
De plus, il existe un opérateur de modulo noté % qui peut porter sur des entiers ou sur des flottants.
Avec des entiers, il fournit le reste de la division entière de son premier opérande par son second. Par
exemple
o 11%4 vaut 3
o 23%6 vaut 5
o -11%3 vaut -2
o -11%-3 vaut -2
Avec des flottants, il fonctionne de manière similaire :
o 12.5%3.5 vaut environ 3

o -15.2%7.5 vaut environ -0.2.
NB :
• En Java, le quotient de deux entiers fournit un entier. Ainsi 5/2 vaut 2 ; en revanche, le
quotient de deux flottants (noté lui aussi /) est bien un flottant (5.0/2.0 vaut bien
approximativement 2.5).
• En Java, aucune opération sur les flottants ne conduit à un arrêt de l’exécution (pas même une
division par zéro !). En effet, comme nous l’avons dit, les flottants sont codés en respectant les
conventions IEEE 754. Celles-ci imposent qu’il existe un motif particulier pour représenter
l’infini positif, l’infini négatif et une valeur non calculable. En Java, ces valeurs peuvent même
être affichées ou affectées directement à des variables.
• S’il le souhaite, le programmeur peut forcer la conversion d’une expression quelconque dans
un type de son choix, à l’aide d’un opérateur un peu particulier nommé cast. Si, par exemple, n
et p sont des variables de type int, l’expression : (double) n/ (double) p aura comme valeur
celle de n convertie en double diviser par celle de p convertie en double.
Contact : 625789118
2- Les Opérateurs d’affectation élargie

Java dispose d’opérateurs encore plus puissants. Ainsi, vous pourrez remplacer :
i = i + k par : i += k
Ou, encore :
a = a * b par: a *= b
D’une manière générale, Java permet de condenser les affectations de la forme :
variable = variable opérateur expression
En :
variable opérateur= expression
Cette possibilité concerne tous les opérateurs binaires arithmétiques. Les opérateurs d’affectation
élargie sont :
• +=
• -=
• *=
• /=
• %=
Contact : 625789118
3- Les Opérateurs d’incrémentation et de décrémentation

Dans des programmes écrits dans un langage autre que Java (ou C), on rencontre souvent des
expressions (ou des instructions) telles que :
i = i + 1 ;
n = n – 1 ;
Qui incrémentent ou qui décrémentent de 1 la valeur d’une variable. En Java, ces actions peuvent être
réalisées par des opérateurs unaires portant sur cette variable. Ainsi, l’expression :
++i ;
A pour effet d’incrémenter de 1 la valeur de i, et sa valeur est celle de i après incrémentation.

On dit que ++ est :
• Un opérateur de pré incrémentation lorsqu’il est placé à gauche de son opérande,
• Un opérateur de pos incrémentation lorsqu’il est placé à droite de son opérande.
De la même manière, il existe un opérateur de décrémentation noté -- qui est :

• Un opérateur de pré décrémentation lorsqu’il est placé à gauche de son opérande,
• Un opérateur de post décrémentation lorsqu’il est placé à droite de son opérande.
Tous ces opérateurs peuvent s’appliquer à tous les types numériques (pas nécessairement entiers)
ainsi qu’au type char.
4- Les Opérateurs relationnels

Comme tout langage, Java permet de comparer des expressions à l’aide d’opérateurs classiques
de comparaison :
 > supérieur stricte

 >= supérieur ou égale
 < inferieur
 <= inferieur ou égale
 == égalité
 != différence
Contact : 625789118
5- Les Opérateurs logiques
Java dispose d’opérateurs logiques dont voici la liste,
 || ou logique
 && et logique
 ! Négation logique
6- L’opérateur d’expression Conditionnel

En Java, il est possible, grâce à l’opérateur conditionnel, de traduire une alternative de la manière
suivante :
nomvariable = (condition ? val1 : val2) ;
L’expression figurant à droite de l’opérateur d’affectation est en fait constituée de trois expressions
(Condition, val1 et val2) qui sont les trois opérandes de l’opérateur conditionnel, lequel se
matérialise par deux symboles séparés : ? et :
Cet opérateur évalue la condition. Si cette condition est vraie, le second opérande(val1) est fourni en
résultat ; si la condition est fausse c’est le troisième(val2) opérande qui est fourni en résultat.
Contact : 625789118
CHAPITRE 5 : LES D’ENTREES/SORTIES

1- Lecture d’information au clavier
Comme dans la plupart des langages de programmation java dispose des instructions lui permettant
de saisir sur le périphérique d’entré standard (clavier). Ces instructions se présentent sous forme de
méthodes définie dans une classe prédéfinie nommée Scanner appartenant au paquetage util. Pour
utiliser ces méthodes il suivre de suivre la démarche suivante :
- Importer le paquetage util par l’instruction
Import java.util.* ;
- Instancier une instance de la classe Scanner par l’instruction
Scanner nom_instance=new Scanner(System.in) ;
- Via l’instance faire appel aux méthodes de la classe Scanner
nom_var = nom_instance.methode() ;
Remarque :
• L’objet in de la classe System est en fait associé à votre clavier

• Scanner et System étant des classes prédéfinies elles commencent par une lettre majuscule.
• Les différentes méthodes de la classe Scanner sont :
 nextInt () : pour les int

 nextByte () : pour les bytes
 nextShort () : pour les short
 nextLong () : pour les long
 nextFloat () : pour les float
 nextDouble () : pour les double
 next () : pour les chaines
• Attention la première lettre du second mot est en majuscule

• Il n’y a pas de méthodes pour le type char
Contact : 625789118
2- Affichage d’information à l’écran
Le paquetage java.lang dispose de deux méthodes print et println pour l’affichage d’information à
l’écran. Mais contrairement à java.util ce paquetage est automatiquement importer en java donc
inutile de l’importer avec l’instruction import. Pour l’affichage des informations utiliser l’une des
instructions suivantes :
• System.out.print() ;//affichage sans retour à la ligne
• System.out.println() ;//affichage avec retour à la ligne
//programme principale
public class Main
{
public static void main (String args[])
{
int age = 10; double taille = 4.5;
System.out.print("bonjour");
System.out.println(" Monsieur");
System.out.print("votre taille est : ");
System.out.println(taille);
System.out.println("votre age est : "+age+" ans");
}
}
Exercices d’Application
1. Ecrire un programme Java qui demande à l’utilisateur de saisir deux entiers, calcul et affiche :
- La somme
- Le Produit
- La division entière
- La division réelle
- Le reste de la division entière
2. Ecrire un programme qui demande un nombre à l’utilisateur, puis calcule et affiche le carré de
ce nombre.
Contact : 625789118
CHAPITRE 6 : LES INSTRUCTIONS DE CONTROLES DE JAVA
1- Les Structures de Contrôles
1.1- L’instruction if
Le mot else et l’instruction qu’il introduit étant facultatifs, l’instruction if présente deux formes :
if (condition) instruction_1
[else instruction_2]
L’instruction if condition est une expression booléenne quelconque, instruction_1 et instruction_2 sont
des instructions quelconques, c’est-à-dire :
– Simple (terminée par un point-virgule),
– Bloc.
N.B. : les crochets [...] signifient que ce qu’ils renferment est facultatif.
Exercice d’application
1- Ecrire un programme Java qui demande à l’utilisateur de saisir une quantité Q d’un produit
P dont le prix unitaire est fixé à 500 F. le programme calcul et affiche le montant hors taxe.
Si la quantité commandée est supérieur à 100 une remise de 2% est accordée sur le
montant hors taxe.
2- Ecrire un programme Java qui demande à l’utilisateur de saisir deux entiers. Calcul et
affiche le minimum de ces trois entiers :
 En utilisant une alternative
 En utilisant l’opérateur d’expression conditionnel
3- Reprendre l’exercice 2 pour trois entiers en ne considérant que la première question.
Contact : 625789118
1.2- Imbrication des instructions if
Lorsque vous imbriquée des instructions if, la règle adoptée par Java pour lever une telle
ambiguïté est la suivante
Un else se rapporte toujours au dernier if rencontré auquel un else n’a pas encore été attribué.
Il s’agit d’un programme de facturation avec remise. Il lit en donnée un simple montant hors taxes et
calcule le montant TTC correspondant (avec un taux de TVA constant de 18,6%). Il établit ensuite une
remise dont le taux dépend de la valeur ainsi obtenue, à savoir :
• 0 % pour un montant inférieur à 1000 F,
• 1 % pour un montant supérieur ou égal à 1 000 F et inférieur à 2000 F,
• 3 % pour un montant supérieur ou égal à 2 000 F et inférieur à 5000F,
• 5 % pour un montant supérieur ou égal à 5 000 F.
1.3- L’instruction switch
switch (expression)
{
case constante_1 : [ instructions_1 ]
case constante_2 : [ instructions_2 ]
..............
case constante_n : [instructions_n ]
[ default : instructions ]
}
L’instruction switch commence au mot switch. Son exécution se déroule comme suit. On commence
tout d’abord par évaluer l’expression figurant après le mot switch. Puis on recherche dans le bloc qui
suit s’il existe une étiquette de la forme case x correspondant à la valeur ainsi obtenue. Si tel est le
cas, on se branche à l’instruction figurant après cette étiquette. Sinon, on passe à l’instruction qui suit
le bloc.
L’étiquette default
Il est possible d’utiliser le mot-clé default comme étiquette à laquelle le programme se branchera si
aucune valeur satisfaisante n’a été rencontrée auparavant.
Contact : 625789118
Exercise d’application
1- Soit le programme suivant :
public class Test

{
public static void main(String[] args)
{
Scanner clavier = new Scanner(System.in);
int n = clavier.nextInt() ;
switch (n)
{
case 0 : System.out.println ("Nul") ;
case 1 :
case 2 : System.out.println ("Petit") ; break ;
case 3 :
case 4 :
case 5 : System.out.println ("Moyen") ;
default : System.out.println ("Grand") ;
}
}
}
Quels résultats affiche-t-il lorsqu’on lui fournit en donnée :
 La valeur 0,
 La valeur 1,
 La valeur 4,
 La valeur 10,
 La valeur -5.
Contact : 625789118
4- Les Structures de Boucles
4.1- La Boucle do...while
Syntaxe
do
instruction
while (condition)
;
L’instruction : do ..... while répète l’instruction qu’elle contient tant que la condition mentionnée est
vraie.
Toutefois, elle est toujours parcourue au moins une fois. La condition qui régit cette boucle n’est
examinée qu’à la fin de chaque répétition.
4.2- La Boucle while
Syntaxe
while (condition)
instruction
L’instruction while répète l’instruction qui suit tant que la condition mentionnée est vraie, comme le
ferait do... while. Mais cette fois, la condition de poursuite est examinée avant chaque parcours de la
boucle et non après.
4.3- La Boucle for
Syntaxe
for ([initialisation] ; [condition] ; [incre/decre])

instruction
• La première partie correspond à l’initialisation d’un compteur

• La deuxième partie correspond à la condition d’arrêt
• La troisième partie correspond à l’incrémentation ou décrémentation d’un compteur. En fait, Java
autorise qu’on place en première et en troisième partie une liste d’expressions, c’est-à-dire une ou
plusieurs expressions (de type quelconque) séparées par des virgules. La deuxième partie, en
revanche, est obligatoirement une expression booléenne.
Contact : 625789118

N.B :
Si la deuxième partie est facultative cela conduira à une boucle infinie.
1- Ecrire un programme Java qui demande à l’utilisateur de saisir une suite de nombre entier
terminé par -1. Le programme calcul et affiche la somme des nombres pairs et le produit
des nombres impairs de cette :
 En utilisant la boucle while
 En utilisant la boucle do....while
 En utilisant la boucle for sans condition
Contact : 625789118
5- Les instructions de Branchement inconditionnelles
5.1- L’instruction break
5.1.1- L’instruction break ordinaire
Java vous autorise d’employer cette instruction dans une boucle (while, do... while ou for).
Dans ce cas, elle sert à interrompre le déroulement de la boucle, en passant à l’instruction suivant
la boucle. Bien entendu, cette instruction n’a d’intérêt que si son exécution est conditionnée par
un choix ; dans le cas contraire, elle serait exécutée dès le premier tour de boucle, ce qui rendrait
la boucle inutile.
Remarque
En cas de boucles imbriquées, l’instruction break fait sortir de la boucle la plus interne.
De même, si break apparaît dans une instruction switch imbriquée dans une boucle, elle ne fait sortir
que du switch.
5.1.2- L’instruction break avec étiquette
L’instruction break ordinaire a l’inconvénient de ne sortir que du niveau (boucle ou switch) le plus
interne. Dans certains cas, cela s’avère insuffisant. Par exemple, on peut souhaiter sortir de deux
boucles imbriquées. Un tel schéma ne convient pas alors :
while { .....
for (.....)
{ .....
break ; // ce break nous branche
.....
}
..... // <-- ici
}
.....
En fait, Java permet de faire suivre ce mot-clé break d’une étiquette qui doit alors figurer devant la
structure dont on souhaite sortir :
Contact : 625789118
repet : while
{ .....
for (.....)
{ .....
break repet ; // cette fois, ce break nous branche
.....
}
.....
}
..... // <-- ici
Les étiquettes pouvant figurées devant une structure sont des identificateurs usuels.
5.2- L’instruction continue
5.2.1- L’instruction continue ordinaire
L’instruction continue permet de passer prématurément au tour de boucle suivant
Remarques
1- Comme on s’y attend, lorsqu’elle est utilisée dans une boucle for, cette instruction continue
effectue bien un branchement sur l’évaluation des expressions d’incrémentation, et non après.
2- En cas de boucles imbriquées, l’instruction continue ne concerne que la boucle la plus interne.
5.2.2- L’instruction continue avec étiquette
L’instruction continue ordinaire présentée ci-dessus présente l’inconvénient de ne concerner que le

niveau de boucle le plus interne.
while (...)
{ .....
for (...)
{
.....
continue ; // ce continue nous fait poursuivre la boucle for
.....
} // <-- ici
.....
}
Contact : 625789118

En fait, comme pour break, Java permet de faire suivre ce mot-clé continue d’une étiquette qui doit
alors figurer devant la structure sur laquelle on souhaite boucler :
repet : while (...)

{
.....
for (...)
{
.....
continue repet ; // ce continue nous fait poursuivre la boucle
while
.....
}
.....
} // <-- ici
Remarque :
Contrairement à l’instruction break avec étiquette, l’étiquette mentionnée dans l’instruction continue
doit obligatoirement être celle d’une structure de boucle (sinon, elle n’aurait pas de signification).
Contact : 625789118
1- Quels résultats fournit le programme suivant ?
public class Test

{
public static void main(String [] args)
{
int n=0 ;
do
{
if (n % 2 == 0)
{
System.out.println (n + " est pair") ;
n += 3 ;
continue ;
}
if (n % 3 == 0)
{
System.out.println (n + " est multiple de 3") ;
n += 5 ;
}
if ( n%5 == 0)
{
System.out.println (n + " est multiple de 5") ;
break ;
}
n += 1 ;
}
while (true) ;
}
}
1. Un magasin de reprographie facture 2 F les dix premières photocopies, 1.50 F les vingt suivantes
et 1 F au-delà. Ecrivez un programme qui demande à l’utilisateur le nombre de photocopies
effectuées puis affiche le montant correspondant.
2. Ecrire un programme permettant d’afficher le nom du jour en introduisant le numéro du jour.
3. Ecrire un programme permettant de fournir les trois coefficients d’une équation du second degré
ensuite calcul et affiche les racines réelles si elles existent.
Contact : 625789118

4. Ecrire un programme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce que
la réponse convienne.
5. Ecrire un programme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse
convienne. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus petit ! », et
inversement, « Plus grand ! » si le nombre est inférieur à 10.
6. Ecrire un programme qui demande un nombre de départ, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de
18 à 27 en utilisant l’instruction while.
7. Réécrire le programme précédent, en utilisant cette fois l'instruction for.
8. Ecrire un programme qui demande un nombre de départ, et qui ensuite écrit la table de
multiplication de ce nombre, présentée comme suit (cas où l'utilisateur entre le nombre 7) :
Table de 7 :
7x1=7
7 x 2 = 14
7 x 3 = 21
…
7 x 10 = 70
9. Ecrire un programme qui demande un nombre de départ, et qui calcule la somme des entiers
jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1+ 2 + 3 + 4 + 5 = 15.
On souhaite afficher uniquement le résultat, pas la décomposition du calcul.
10. Ecrire un programme qui demande un nombre de départ, et qui calcule sa factorielle.
NB : la factorielle de 8, notée 8 ! vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8.
11. Ecrire un programme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise
ensuite quel était le plus grand parmi ces 20 nombres. Modifiez ensuite le programme pour que
le programme affiche de surcroît en quelle position avait été saisie ce nombre.
12. Réécrire le programme précédent, mais cette fois-ci on ne connaît pas d’avance combien
l’utilisateur souhaite saisir de nombres. La saisie des nombres s’arrête lorsque l’utilisateur entre
un zéro.
Contact : 625789118

13. Lire la suite des prix (en F entiers et terminée par zéro) des achats d’un client. Calculer la somme
qu’il doit, lire la somme qu’il paye, et simuler la remise de la monnaie en affichant les textes "10
F", "5 F" et "1 F" autant de fois qu’il y a de coupures de chaque sorte à rendre.
14. Ecrire un programme qui permet à l’utilisateur de saisir une suite caractère se terminant par ‘*’,
et qui affiche à la fin le nombre d’apparition de la lettre ‘A’ ou ‘a’.
15. Ecrire un programme permettant de convertir un entier N écrit sous forme binaire en sa valeur
décimale.
16. Ecrire un programme pour résoudre chacun des problèmes suivants :
 Calcul de la somme des N premiers nombres entiers.

 Recherche du minimum et du maximum dans un ensemble de N nombres.
 Calcul du quotient et reste de la division de deux entiers A et B sans utiliser l’opération
de division.
 Le calcul du produit de deux entiers en utilisant uniquement l'opération d'addition '+’.
 Détermination si A est divisible par B. Avec A et B des entiers positifs.
 Déterminer tous les diviseurs d’un entier X donné.
 Déterminer si un nombre entier X est premier ou non.
 Calcule la somme des chiffres qui composent un entier naturel N.
Contact : 625789118
CHAPITRE 7 : Les CLASSES ET LES OBJETS

1- Définition d’une classe
Rappelons le canevas général de définition d’une classe en Java, que nous avons déjà utilisé dans les
précédents chapitres dans le seul but de contenir une fonction main :
public class Nom_classe

{
// instructions de definition des champs et des methodes de la classe
}
1.1- Définition des champs
Pour définir les champs d’une classe Il nous suffira de les déclarer ainsi :
Private type nom_du_champ ;
Le mot-clé private qui précise que ces champs ne seront pas accessibles à l’extérieur de la classe,
c’est-à-dire en dehors de ses propres méthodes. Cela correspond à l’encapsulation des données,
dont on voit qu’elle n’est pas obligatoire en Java (elle est toutefois fortement recommandée).
Ces déclarations peuvent être placées où vous voulez à l’intérieur de la définition de la classe, et pas
nécessairement avant les méthodes. En général, on place les champs et méthodes privées à la fin.
1.2- Définition des méthodes
La définition d’une méthode pourra se présenter comme ceci :
public type_retour nomMethode (liste des paramètres)

{
actions
}
L’en-tête précise :
• Le nom de la méthode ;
• Le mode d’accès : public pour que cette méthode soit effectivement utilisable depuis un
programme quelconque ; nous avons déjà rencontré private pour des champs ;
• Les arguments qui seront fournis à la méthode lors de son appel.
• Le type de la valeur de retour ; si la méthode ne fournit aucun résultat, on utilise le mot-clé void.
Contact : 625789118

Remarque
On peut disposer de méthodes privées ; dans ce cas, elles ne sont utilisables que par d’autres
méthodes de la classe. On peut théoriquement disposer de champs publics mais c’est fortement
déconseillé.
1.3- Utilisation d’une classe
À l’intérieur d’une méthode quelconque, une déclaration telle que : Nomclasse Nomobjet ;
est tout à fait correcte. Cependant, contrairement à la déclaration d’une variable d’un type primitif
(comme int n ;), elle ne réserve pas d’emplacement pour cet objet, mais seulement un emplacement
pour une référence à cet objet. L’emplacement pour l’objet proprement dit sera alloué sur une
demande explicite du programme, en faisant appel à un opérateur unaire nommé new. Ainsi,
l’expression :
new Nomclasse() // attention à la présence des parenthèses ()
Crée un emplacement pour un objet et fournit sa référence en résultat. Par exemple, on pourra
procéder à cette affectation :
Nomobjet = new Nomclasse () ;
Une fois qu’une référence à un objet a été convenablement initialisée, on peut appliquer n’importe
quelle méthode à l’objet correspondant en procédant ainsi :
Nomobjet.nomMethode (……) ;
Exemple :
Créer une classe Rectangle comportant deux champs longueur et largeur puis ajouter les méthodes :
 Initialise pour initialiser les champs
 Périmètre pour calculer le périmètre d’un rectangle
 Surface pour calculer la surface d’un rectangle
 Affiche pour afficher les dimensions d’un rectangle
Tester les différentes méthodes depuis le programme principal.
Contact : 625789118

// definition de la classe Rectangle
public class Rectangle
{
//definition des champs
private int lon;
private int larg;
//definition des méthodes
public void initialise(int a, int b)
{
lon = a;
larg = b;
}
public int perimetre()
{
return(2 * (lon + larg));
}
public int surface()
{
return(lon * larg);
}
public void affiche()
{
System.out.println("la longueur est : "+lon);
System.out.println("la largeur est : "+larg);
}
}
public class Main
{

{
Rectangle R;
R = new Rectangle();
R.initialise(10, 5);
R.affiche();
System.out.println("le perimetre est : "+R.perimetre());
System.out.println("la surface est : "+R.surface());
}
Contact : 625789118
2- La notion de constructeur
2.1- Généralités
Dans l’exemple précédent, il est nécessaire de recourir à la méthode initialise pour attribuer des
valeurs aux champs d’un objet de type Rectangle. Une telle démarche suppose que l’utilisateur de
l’objet fera effectivement l’appel voulu au moment opportun. En fait, la notion de constructeur vous
permet d’automatiser le mécanisme d’initialisation d’un objet.
Un constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, portant le même nom que
la classe. Il peut disposer d’un nombre quelconque d’arguments (éventuellement aucun).
2.1-1.1. Exemple de classe comportant un constructeur
Considérons la classe Rectangle présentée au paragraphe précédent et transformons simplement la

méthode initialise en un constructeur en la nommant Rectangle. La définition de notre nouvelle
classe se présente alors ainsi :
// definition de la classe Rectangle
public class Rectangle
{
private int lon;
private int larg;
public Rectangle(int a, int b)
{
lon = a;
larg = b;
}
public int perimetre()
{
return(2 * (lon + larg));
}
public int surface()
{
return(lon * larg);
}
{
System.out.println("la longueur est : "+lon);
System.out.println("la largeur est : "+larg);
}
Contact : 625789118

2.1-1.2. Comment utiliser cette classe ?
Cette fois, une instruction telle que :
Rectangle R = new Rectangle () ;
Ne convient plus : elle serait refusée par le compilateur. En effet, à partir du moment où une classe
dispose d’un constructeur, il n’est plus possible de créer un objet sans l’appeler. Ici, notre
constructeur a besoin de deux arguments. Ceux-ci doivent obligatoirement être fournis lors de la
création, par exemple :
Rectangle R = new Rectangle (10, 5) ;
2.2- Quelques règles concernant les constructeurs
 Un constructeur ne fournit aucune valeur. Dans son entête, aucun type ne doit figurer devant
son nom. Même la présence (logique) de void est une erreur
 Une classe peut ne disposer d’aucun constructeur (c’était le cas de notre première classe
Rectangle). On peut alors instancier des objets comme s’il existait un constructeur par défaut
sans arguments (et ne faisant rien) par des instructions telles que :
Rectangle R = new Rectangle () ; // OK si Rectangle n’a pas de constructeur
Mais dès qu’une classe possède au moins un constructeur, ce pseudo-constructeur par
défaut ne peut plus être utilisé, On notera que. Si, pour une classe T donnée, l’instruction
suivante est acceptée : T t = new T () ; cela signifie simplement que :
 Soit T ne dispose d’aucun constructeur,
 Soit T dispose d’un constructeur sans arguments.
 Un constructeur ne peut pas être appelé directement depuis une autre méthode. Par
exemple, si Rectangle dispose d’un constructeur à deux arguments de type int :
Rectangle R = new Rectangle (10, 5) ;
.....
R.Rectangle(8, 3) ; // interdit
 Un constructeur peut être déclaré privé (private). Dans ce cas, il ne pourra plus être appelé de
l’extérieur, c’est-à-dire qu’il ne pourra pas être utilisé pour instancier des objets .
Contact : 625789118
2.3- Typologie des méthodes d’une classe
Parmi les différentes méthodes que comporte une classe, on a souvent tendance à distinguer :
• Les constructeurs ;
• Les méthodes d’accès (en anglais accessor) qui fournissent des informations relatives à l’état
d’un objet, c’est-à-dire aux valeurs de certains de ses champs (généralement privés), sans les
modifier ;
• Les méthodes d’altération (en anglais mutator) qui modifient l’état d’un objet, donc les valeurs de
certains de ses champs.
On rencontre souvent l’utilisation de noms de la forme getXXXX pour les méthodes d’accès et
setXXXX pour les méthodes d’altération.
Contact : 625789118
COURS DE JAVA SE TOME I : LES BASES DE LA PROGRAMMATION EN JAVA
3- Affectation et comparaison d’objets
3.1- La notion de clone
L’affectation de variables de type objet se limite à la recopie de références.

Elle ne provoque pas la recopie de la valeur des objets. Si on le souhaite, on peut bien entendu
effectuer explicitement la recopie de tous les champs d’un objet dans un autre objet de même type.
Toutefois, si les données sont convenablement encapsulées, il n’est pas possible d’y accéder
directement. On peut songer à s’appuyer sur l’existence de méthodes d’accès et d’altération de ces
champs privés.
En fait, la démarche la plus réaliste consiste plutôt à prévoir dans la classe correspondante une
méthode destinée à fournir une copie de l’objet concerné, cette copie profonde qu’on nomme clonage
en Java, consiste à faire en sorte que chaque classe concernée par l’éventuelle récursion dispose de sa
propre méthode.
3.2- Comparaison d’objets
Les opérateurs == et != s’appliquent théoriquement à des objets. Mais comme ils portent sur les
références elles-mêmes, leur intérêt est très limité. Ainsi, avec :
Rectangle a, b ;
L’expression a == b est vraie uniquement si a et b font référence à un seul et même objet, et non pas
seulement si les valeurs des champs de a et b sont les mêmes.
4- Champs et méthodes de classe
En Java, on peut définir des champs qui, au lieu d’exister dans chacune des instances de la classe,
n’existent qu’en un seul exemplaire pour toutes les instances d’une même classe. Il s’agit en quelque
sorte de données globales partagées par toutes les instances d’une même classe. On parle alors de
champs de classe ou de champs statiques. De même, on peut définir des méthodes de classe (ou
statiques) qui peuvent être appelées indépendamment de tout objet de la classe (c’est le cas de la
méthode main).

Contact : 625789118
4.1- Champs de classe
Présentation
Considérons la définition de la classe suivante :
class A {
private int n;
private float y;
}
Par exemple, avec cette déclaration :
A a1 = new A ();
A a2 = new A ();
Chaque objet de type A possède ses propres champs n et x.
Mais Java permet de définir ce qu’on nomme des champs de classe (ou statiques)
qui n’existent qu’en un seul exemplaire, quel que soit le nombre d’objets de la
classe. Il suffit pour cela de les déclarer avec l’attribut static. Par exemple, si nous
définissons :
class B
{ private static int n ;
Private float y ;
}
B a1 = new B ();
B a2 = new B () ;
Les notations a1.n et a2.n désignent donc le même champ. En fait, ce champ existe indépendamment
de tout objet de sa classe. Il est possible (et même préférable) de s’y référer en le nommant
simplement : B.n // champ (statique) n de la classe B
Bien entendu, ces trois notations (a1.n, a2.n, B.n) ne seront utilisables que pour un champ non privé.
Il sera possible de prévoir des champs statiques privés, mais l’accès ne pourra alors se faire que par
le biais de méthodes.
Notez que depuis une méthode de la classe B, on accédera à ce champ on le nommant comme
d’habitude n (le préfixe B. n’est pas nécessaire, mais il reste utilisable).
NB : pour initialiser les champs static on peut créer un bloc static

Contact : 625789118
4.2- Méthodes de classe
Nous venons de voir comment définir des champs de classe, lesquels n’existent qu’en un seul
exemplaire, indépendamment de tout objet de la classe. De manière analogue, on peut imaginer que
certaines méthodes d’une classe aient un rôle indépendant d’un quelconque objet. Ce serait
notamment le cas d’une méthode se contentant d’agir sur des champs de classe ou de les utiliser.
Bien sûr, vous pouvez toujours appeler une telle méthode en la faisant porter artificiellement sur un
objet de la classe (alors que la référence à un tel objet n’est pas utile). Là encore, Java vous permet de
définir une méthode de classe en la déclarant avec le mot-clé static. L’appel d’une telle méthode ne
nécessite plus que le nom de la classe correspondante.
Une méthode de classe ne pourra en aucun cas agir sur des champs non statiques.
5- Sur définition de méthodes

On parle de sur définition (ou encore de surcharge) lorsqu’un même symbole possède plusieurs
significations différentes entre lesquelles on choisit en fonction du contexte. En Java, cette possibilité
de sur définition s’applique aux méthodes d’une classe, y compris aux méthodes statiques. Plusieurs
méthodes peuvent porter le même nom, pour peu que le nombre et le type de leurs arguments
permettent au compilateur d’effectuer son choix.
Règles générales
À la rencontre d’un appel donné, le compilateur recherche toutes les méthodes acceptables et il
choisit la meilleure si elle existe. Pour qu’une méthode soit acceptable, il faut :
 Qu’elle dispose du nombre d’arguments voulus,
 Que le type de chaque argument effectif soit compatible par affectation avec le type de
l’argument muet correspondant,
 Qu’elle soit accessible
Le choix de la méthode se déroule alors ainsi :

 Si aucune méthode n’est acceptable, il y a erreur de compilation.
 Si une seule méthode est acceptable, elle est bien sûr utilisée pour l’appel.
 Si plusieurs méthodes sont acceptables, le compilateur essaie d’en trouver une qui soit
meilleure que toutes les autres. Pour ce faire, il procède par éliminations successives. Après
élimination de toutes les méthodes possibles :
 S’il ne reste plus qu’une seule méthode, elle est utilisée,
 S’il n’en reste aucune, on obtient une erreur de compilation,
 S’il en reste plusieurs, on obtient une erreur de compilation mentionnant une
ambiguïté.

Contact : 625789118
Remarques
Le type de la valeur de retour d’une méthode n’intervient pas dans le choix d’une méthode sur-
définie.
6- Autoréférence : le mot-clé this

this désigne la référence à l’objet ayant appelé la méthode
Utilisation de this
 Employer des noms d’arguments identiques à des noms de champ, ce qui évite parfois d’avoir à
créer de nouveaux identificateurs,
private int lon;
private int larg;
public Rectangle(int lon, int larg)
{
this.lon = lon;
this.larg = larg;
}
 Appel d’un constructeur au sein d’un autre constructeur

Nous avons déjà vu qu’il n’était pas possible d’appeler directement un constructeur, comme
dans : R.Rectangle(17, 8) ; Il existe cependant une exception : au sein d’un constructeur, il est
possible d’en appeler un autre de la même classe (et portant alors sur l’objet courant). Pour
cela, on fait appel au mot clé this qu’on utilise cette fois comme un nom de méthode.

private int lon;
private int larg;
public Rectangle()
{
this(0, 0); // doit être la première instruction
}

Contact : 625789118
7- La récursivité des méthodes

Java autorise la récursivité des appels de méthodes. Celle-ci peut être :
 Directe : une méthode comporte, dans sa définition, au moins un appel à elle-même ;
public static int factoriel(int n)

{
if(n == 0 || n == 1) return 1;
else return (n * factoriel(n - 1));
}
 Croisée : l’appel d’une méthode entraîne l’appel d’une autre méthode qui, à son tour, appelle
une autre méthode (le cycle pouvant d’ailleurs faire intervenir plus de deux méthodes).
public int cube(int n)

{
return n * n * n;
}
public double volumeSphere(int rayon)
{
return((4 / 3 * 3.14 * cube(rayon)));
}
8- Les objets membres

Les champs d’une classe sont soit d’un type primitif, soit des références à des objets. Dans le second
cas, on parle souvent d’objet membre
Exemple :
Créons une classe Cercle permettant de représenter des cercles définis par un centre, objet du type
Point, et un rayon (flottant). Nous supposerons que les fonctionnalités de notre classe Cercle se
réduisent à l’affichage des caractéristiques d’un cercle (coordonnées du centre et rayon)

Contact : 625789118
// definition de la classe Point

public class Point
{ private int abs;
private int ord;
public Point(int abs, int ord)
{
this.abs = abs;
this.ord = ord;
}
{
System.out.println("l'abscisse du centre est : " + abs);
System.out.println("l'ordonner du centre est : " + ord);
}
}
//classe Cercle
public class Cercle
{
private Point centre;
private double rayon;
public Cercle(int abs, int ord, double rayon)
{
centre = new Point(abs, ord);
this.rayon = rayon;
}
{
centre.affiche();
System.out.println("le rayon est : " + rayon);
}
}
public class Main
{
{
Cercle C = new Cercle(5, 7, 5.6);
C.affiche();
}
}

Contact : 625789118
9- Les classes internes

La notion de classe interne a été introduite essentiellement dans le but de simplifier l’écriture du
code de la programmation événementielle.
9.1- Imbrication de définitions de classe
Une classe est dite interne lorsque sa définition est située à l’intérieur de la définition d’une autre
classe. Malgré certaines ressemblances avec la notion d’objet membre étudiée ci-dessus, elle ne
doit surtout pas être confondue avec elle, même s’il est possible de l’utiliser dans ce contexte.
La notion de classe interne correspond à cette situation :
class E // definition d’une classe usuelle (dite alors externe)

{
..... // methodes et donnees de la classe E
class I // definition d’une classe interne à la classe E
{
..... // methodes et donnees de la classe I
}
..... // autres methodes et donnees de la classe E
}
9.2- Lien entre objet interne et objet externe
1. Un objet d’une classe interne a toujours accès aux champs et méthodes (même privés) de l’objet
externe lui ayant donné naissance.
2. Un objet de classe externe a toujours accès aux champs et méthodes (même privés) d’un objet
d’une classe interne auquel il a donné naissance.
Remarque : Une classe interne ne peut pas contenir de membres statiques.
Exemple :
Reprendre l’exemple précèdent sur les objets membres en utilisant des classes internes.

Contact : 625789118
public class Cercle //classe externe Cercle

{
public class Point // classe interne Point
{
private int abs;
private int ord;
}
private Point centre;
private double rayon;
public Cercle(int abs, int ord, double rayon)
{
centre = new Point();
centre.abs= abs;
centre.ord = ord;
this.rayon = rayon;
}
{
System.out.println("l'abscisse du centre est : " + centre.abs);
System.out.println("l'ordonner du centre est : " + centre.ord);
System.out.println("le rayon est : " + rayon);
}
}
public class Main
{
{
Cercle C = new Cercle(5, 7, 5.6);
C.affiche();
}
}

Contact : 625789118
Exercices d’application
1. Définir une classe Livre avec les attributs suivants : Titre, Auteur (Nom complet), Prix.
 Définir à l’aide des propriétés les méthodes d’accès aux différents attributs de la classe.
 Définir un constructeur permettant d’initialiser les attributs de la méthode par des valeurs
saisies par l’utilisateur.
 Définir la méthode Afficher () permettant d’afficher les informations du livre en cours.
Écrire un programme testant la classe Livre.
2. Un nombre complexe Z est entièrement défini par sa partie réelle a et imaginaire b

(Z = a + bi). Donner la déclaration de la classe d’un nombre complexe contenant les méthodes :
reel, image et module donnant les attributs d'un nombre complexe respectivement : la partie
réelle, la partie imaginaire et le module). Introduire les fonctions somme, différence et produit
nécessaires à l'arithmétique sur les complexes, respectivement pour l’addition, la soustraction et
la multiplication.
3. Écrire la définition de la classe Personne ayant trois attributs définissant certaines

caractéristiques d’une personne réelle : taille, poids et age. Cette classe aura :
 Une méthode imc () : qui détermine l’IMC de la personne,
 Une méthode interpretation () qui affiche "Insuffisance pondérale" si l’IMC est
inférieur ou égale à 18,5 et qui affiche "obésité" si l’IMC est supérieur ou égale à 30.
Rappel : l’IMC (Indice de masse corporelle) est donné par la formule
imc = (poids/taille2).
4. Définir une classe Point caractérisée par son abscisse et son ordonné.
Définir à l’aide des getters et les setters les méthodes d’accès aux attributs de la classe.
Définir le constructeur par défaut et d’initialisation de la classe.
Définir la méthode Norme () qui retourne la distance entre l’origine du repère et le point en cours.
Écrire un programme permettant de tester la classe.

Contact : 625789118
5. On veut écrire un programme simulant des poupées russes de différentes tailles. Chaque poupée
a une taille donnée, peut s'ouvrir ou se fermer, peut contenir une autre poupée et être contenue
dans une autre poupée. Écrivez une classe PoupeeRusse contenant les méthodes suivantes :
o Un constructeur
o void ouvrir () : ouvre la poupée si elle n'est pas déjà ouverte et si elle ne se trouve pas à
l'intérieur d'une autre poupée
o void fermer () : ferme la poupée si elle n'est pas déjà fermée et si elle ne se trouve pas à
l'intérieur d'une autre poupée
o void placerDans (PoupeeRusse p) : place la poupée courante dans la poupée p si c'est
possible. Il faut que la poupée courante soit fermée et ne soit pas déjà dans une autre
poupée, que la poupée p soit ouverte et ne contienne aucune poupée, et que p soit
d'une taille supérieure à la poupée courante.
o voidsortirDe (PoupeeRusse p) : sort la poupée courante de la poupée p si elle est dans
p et si p est ouverte.
6. Définir une classe Client avec les attributs suivants : CIN, Nom, Prénom, Tél.
 Définir à l’aide des propriétés les méthodes d’accès aux différents attributs de la classe.
 Définir un constructeur permettant d’initialiser tous les attributs.
 Définir un constructeur permettant d’initialiser le CIN, le nom et le prénom.
 Définir la méthode Afficher () permettant d’afficher les informations du Client en cours.
 Créer Une classe Compte caractérisée par son solde et un code qui est incrémenté lors de sa
création ainsi que son propriétaire qui représente un client.
 Définir à l’aide des propriétés les méthodes d’accès aux différents attributs de la classe (le
numéro de compte et le solde sont en lecture seule)
 Définir un constructeur permettant de créer un compte en indiquant son propriétaire.
 Ajouter à la classe Compte les méthodes suivantes :
a. Une méthode permettant de Crediter () le compte, prenant une somme en paramètre.

b. Une méthode permettant de Crediter () le compte, prenant une somme et un compte en
paramètres, créditant le compte et débitant le compte passé en paramètres.
c. Une méthode permettant de Debiter () le compte, prenant une somme en paramètre
d. Une méthode permettant de Debiter () le compte, prenant une somme et un compte
bancaire en paramètres, débitant le compte et créditant le compte passé en paramètres
e. Une méthode qui permet d’afficher le résumé d’un compte.
f. Une méthode qui permet d’afficher le nombre des comptes crées.
Créer un programme de test pour la classe Compte.

Contact : 625789118
7. Définir une classe Employé caractérisée par les attributs :
Matricule, Nom, Prénom, DateNaissance, DateEmbauche, Salaire.

 Définir à l’aide des propriétés les méthodes d’accès aux différents attributs de la classe.
 Définir un constructeur permettant d’initialiser les attributs de la méthode par des valeurs
saisies par l’utilisateur.
 Ajouter à la classe la méthode Age () qui retourne l’âge de l’employé.
 Ajouter à la classe la méthode Anciennete () qui retourne le nombre d’années d’ancienneté de
l’employé.
 Ajouter à la classe la méthode AugmentationDuSalaire () qui augmente le salaire de
l’employé en prenant en considération l’ancienneté :
 Si Ancienneté < 5 ans, alors on ajoute 2%. –
 Si Ancienneté < 10 ans, alors on ajoute 5%. –
 Sinon, on ajoute 10%.
 Ajouter la méthode AfficherEmploye () qui affiche les informations de l’employé comme suit :
Matricule : […]
Nom complet : [NOM Prénom]
Age : […]
Ancienneté : […]
Salaire : […]
Le nom doit être affiché en majuscule. Pour le prénom, la première lettre doit être en majuscule, les
autres en minuscule.
Ecrire un programme de test pour la classe Employé.

Contact : 625789118
8. On veut réaliser un programme qui représente des montres et les gens qui les portent. Une montre
donne l'heure et les minutes. On peut initialiser une montre soit à partir d'un couple heure/
minute donné, soit en utilisant l'heure affichée par une autre montre. Il doit être possible de faire
avancer l'heure d'une montre en ajoutant une minute (attention, les minutes sont limitées à 60 et
les heures à 24).
Écrivez une classe qui représente les montres telles que décrites au-dessus et une méthode
principale qui crée une montre affichant 13h45 et une autre montre qui est un clone de la
première.
Une personne a un nom et peut éventuellement porter une montre. On peut faire porter une
montre donnée à une personne, si elle n'en a pas déjà une. On peut aussi lui enlever sa montre si
elle en a une. Une personne peut demander l'heure à une autre, qui lui donne l'heure sous forme
d'une chaine de caractères, en consultant sa montre si elle en a une (sinon elle peut retourner une
chaine vide).
Écrivez une classe qui représente les personnes telles que décrites au-dessus.
On veut faire en sorte que chaque montre ne soit portée que par une seule personne. Proposez des
ajouts/modifications des deux classes précédentes pour garantir cela.

Contact : 625789118
CHAPITRE 8 : LES TABLEAUX

En programmation, on parle de tableau pour désigner un ensemble d’éléments de même type
désignés par un nom unique, chaque élément étant repéré par un indice précisant sa position au sein
de l’ensemble. Comme tous les langages, Java permet de manipuler des tableaux. En particulier, les
tableaux sont considérés comme des objets et les tableaux à plusieurs indices s’obtiennent par
composition de tableaux.
1- Déclaration et création de tableaux
1.1- Déclaration de tableaux
La déclaration d’une référence à un tableau précise donc simplement le type des éléments du tableau.
Elle peut prendre deux formes différentes :
 Type nomtableau [] ;
 Type [] nomtableau;
La différence entre les deux formes devient intéressant lorsque l’on déclare plusieurs identificateurs
dans une même instruction. Ainsi, int [] t1, t2 ; // t1 et t2 sont des références a des tableaux d’entiers
est équivalent à : int t1[], t2[] ;
La première forme permet le mélange de tableaux de type T et de variables de type T :
int t1[], n, t2[] ; // t1 et t2 sont des tableaux d’entiers et n est un entier.
En Java, les éléments d’un tableau peuvent être d’un type primitif ou d’un type objet.
Remarque
Une déclaration de tableau ne doit pas préciser de dimensions. Cette instruction sera rejetée à
la compilation : int t[5] ; // erreur : on ne peut pas indiquer de dimension ici
1.2- Création d’un tableau
On peut allouer l’emplacement d’un tableau comme celui d’un objet à l’aide de l’opérateur new. On
peut aussi utiliser un initialiseur au moment de la déclaration du tableau, comme on le fait pour une
variable d’un type primitif.
1.2.1- Création par l’opérateur new
Type Nomtableau [] = new type [taille] ;

Notez cependant que l’objet tableau une fois créé ne pourra pas voir sa taille modifiée.

Contact : 625789118
1.2.2- Utilisation d’un initialiseur
Lors de la déclaration d’une référence de tableau, on peut fournir une liste d’expressions entre
accolades, comme dans :
Type Nomtableau [] = {val1, val2, ……, valn} ;
Remarque
La notation {.....} n’est utilisable que dans une déclaration.
2- Accès aux éléments d’un tableau

On peut manipuler un élément de tableau comme on le ferait avec n’importe quelle variable ou
n’importe quel objet du type de ses éléments. On désigne un élément particulier en plaçant entre
crochets, à la suite du nom du tableau, une expression entière nommée indice indiquant sa position.
Le premier élément correspond à l’indice 0 et ainsi de suite.
int t[] = new int[5] ;

.....
t[0] = 15 ; // place la valeur 15 dans le premier élément du tableau t
.....
t[2]++ ; // incrémente de 1 le troisième élément de t
.....
System.out.println (t[4]) ; // affiche la valeur du dernier élément de t Si, lors de l’exécution, la valeur
d’un indice est négative ou trop grande par rapport à la taille du tableau, on obtient une erreur
d’exécution.
3- La taille d’un tableau : length

Le champ length permet de connaître le nombre d’éléments d’un tableau de référence donnée :
int t[] = new int[5] ;

System.out.println ("taille de t : " + t.length) ; // affiche 5
t = new int[3] ;
System.out.println ("taille de t : " + t.length) ; // affiche 3
Remarque :
On écrit t.length et non t.length() car length s’utilise comme s’il s’agissait d’un champ public de l’objet
tableau t et non d’une méthode.

Contact : 625789118
4- Utilisation de la boucle for.… each

Java a introduit une nouvelle structure de contrôle adaptée aux collections, aux tableaux et aux
chaînes. Par exemple, si l’on dispose d’un tableau t déclaré ainsi :
double t [] ;
Avec cette cette instruction :
for (double v : t) System.out.println (v) ;
La variable v prendra successivement les différentes valeurs du tableau t. On obtiendra le même

résultat qu’en utilisant :
for (int i = 0 ; i<t.length ; i++) System.out.println (t[i]) ;
Il faut toutefois bien voir que cette structure for.… each ne s’applique qu’à des consultations de
valeurs, et en aucun cas à des modifications.
5- Cas particulier des tableaux de caractères

Considérez cette situation :
char [] tc ;
int [] ti ;
.....
System.out.println(tc); //on obtient les valeurs des caractères de tc
System.out.println(ti); //on n’obtient pas les valeurs des entiers de ti
En fait, la méthode println ou print est sûr définie pour des tableaux de caractères. Elle ne l’est pas
pour les autres tableaux.
6- Tableau en argument ou en retour

Lorsqu’on transmet un nom de tableau en argument d’une méthode, on transmet en fait (une copie
de) la référence au tableau. La méthode agit alors directement sur le tableau concerné et non sur une
copie.
Exemple :
Créer deux méthodes statiques (définies dans une classe utilitaire nommée Util) permettant :
 D’afficher les valeurs des éléments d’un tableau d’entiers (méthode affiche),
 De mettre à zéro les éléments d’un tableau d’entier (méthode raz).
Les mêmes réflexions s’appliquent à un tableau fourni en valeur de retour. Par exemple, dans la
classe util précédente introduire une méthode fournissant en résultat un tableau formé des n
premiers nombres entiers.

Contact : 625789118
7- Les tableaux à plusieurs indices
En Java un tableau à plusieurs dimensions est un tableau de tableaux, c’est-à-dire des tableaux dont
les éléments sont eux-mêmes des tableaux. Cette possibilité est en fait plus riche que celle de
tableaux à plusieurs indices offerts par les autres langages. Elle permet notamment de disposer de
tableaux irréguliers, c’est-à-dire dans lesquels les différentes lignes pourront être de taille différente.
7.1- Création
type nomtableau [][] = new type[taille1][taille2] ;
7.2- Initialisation
type nomtableau[][] = { {val1,val ,val3}, {val1, val2}} ;
Exemple
Ecrire un programme complet utilisant deux méthodes statiques définies dans une classe Util,
permettant :
 D’afficher les valeurs des éléments d’un tableau d’entiers à deux indices, ligne par ligne
(méthode affiche),
 De mettre à zéro les éléments d’un tableau d’entiers à deux indices (méthode raz).
8- Arguments variables en nombre

On peut définir une méthode dont le nombre d’arguments est variable. Par exemple, si l’on définit
une méthode somme avec l’en-tête suivant :
int somme (int... valeurs)
On pourra l’appeler avec un ou plusieurs arguments de type int ou même sans argument. Voici
quelques appels corrects de somme :
int n, p, q ;
somme () ; // aucun argument
somme (n) ; // un argument de type int
somme (n, p) ; // deux arguments de type int
somme (n, p, q) ; // trois arguments de type int
La notation ... utilisée dans un tel contexte se nomme souvent « ellipse ».

Dans le corps de la méthode, on accédera aux différents arguments représentés par l’ellipse comme
s’ils avaient été fournis sous forme d’un tableau.

Contact : 625789118
1. Soit un vecteur T (tableau à une dimension) contenant N nombres entiers (N≤100). Ecrire un
programme pour :
 Détermine le minimum, le maximum et la moyenne des éléments d’un tableau T
 Calcule le produit de tous les éléments de T ainsi que le nombre de valeurs strictement
positives.
 Calcule la somme et le produit scalaire de deux vecteurs (T1 et T2).
 Détermine les positions de l’apparition d’une valeur dans un vecteur T.
 Inverse le contenu d’un vecteur T.
 Supprime toutes les valeurs nulles d'un vecteur T.
 Met les valeurs négatives au début et les valeurs positives à la fin en utilisant un seul
tableau.
2. Ecrire un programme qui permet d’éclater un vecteur T de N (N≤250) entiers supposés

positifs en deux vecteurs T1 et T2 contenant respectivement les nombres pairs et impairs de
T.
3. Soit T un vecteur de N entiers (N≤200). Ecrire un programme qui détermine le nombre de

succession de deux valeurs (V1 et V2) particulières dans le vecteur.
4. Soient deux vecteurs d’entiers triés V1 (N entiers, N≤100) et V2 (M entiers, M≤150). Ecrire un
programme qui fusionne ces deux vecteurs dans un autre vecteur V3 trié sans répétition de
valeurs identiques.
5. Soit une matrice A (N, M) de caractères (N≤20 et M≤30). Ecrire un programme qui
 Recherche un élément dans la matrice A.

 Calcule le nombre de voyelles appartenant à la matrice A.
6. Soit une matrice A (N, M) d’entiers (N≤20 et M≤30), écrire un programme qui :
 Calcule et sauvegarde la somme de chaque colonne, -

 Détermine la position Jmin de la somme minimale et la position Jmax de la somme
maximale.
 Permute les deux colonnes d’indices Jmin et Jmax de la matrice A si Jmin > Jmax.

Contact : 625789118

Cours Java Tome 1

Transféré par

Droits d'auteur :

Formats disponibles

Cours Java Tome 1

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 Java Tome 1

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSITE BARACK OBAMA DE SONFONIA COURS DE JAVA SE

TOME I : LES BASES DU LANGAGE JAVA

Table des matières

TOME I : LES BASES DU LANGAGE JAVA

TOME I : LES BASES DU LANGAGE JAVA

TOME I : LES BASES DU LANGAGE JAVA

CHAPITRE 1 : PRESENTATION DU LANGAGE JAVA

2- Java et la programmation orientée objet

TOME I : LES BASES DU LANGAGE JAVA

3- Java et la programmation événementielle

 Les programmes à interface console,

3.1.1- Les programmes à interface console

3.1.2- Les programmes à interface graphique (G.U.I.)

Le langage Java utilise toutes ces deux techniques de programmation

TOME I : LES BASES DU LANGAGE JAVA

Application Code Binaire Windows

Application Code Binaire Unix

Application Code Binaire MAC

TOME I : LES BASES DU LANGAGE JAVA

5- Règles d’écriture d’un programme Java

TOME I : LES BASES DU LANGAGE JAVA

6- Compilation et Exécution d’un programme java.

NB : On ne doit pas préciser l’extension du fichier byte codes

TOME I : LES BASES DU LANGAGE JAVA

7- Les Editions du langage JAVA.

TOME I : LES BASES DU LANGAGE JAVA

CHAPITRE 2 : LES TYPES PRIMITIFS DE JAVA

boolean ordonne ; // déclaration d’une variable de type booléen

TOME I : LES BASES DU LANGAGE JAVA

CHAPITRE 3 : LES VARIABLES ET LES CONSTANTES

 En Java les déclarations peuvent apparaître à n’importe quel emplacement du programme

final int n ; // OK, même si n n’a pas (encore) reçu de valeur

TOME I : LES BASES DU LANGAGE JAVA

CHAPITRE 4 : LES OPERATEURS ET LES EXPRESSIONS

1- Les Opérateurs Arithmétiques

o 12.5%3.5 vaut environ 3

TOME I : LES BASES DU LANGAGE JAVA

2- Les Opérateurs d’affectation élargie

D’une manière générale, Java permet de condenser les affectations de la forme :

variable = variable opérateur expression

variable opérateur= expression

TOME I : LES BASES DU LANGAGE JAVA

3- Les Opérateurs d’incrémentation et de décrémentation

A pour effet d’incrémenter de 1 la valeur de i, et sa valeur est celle de i après incrémentation.

De la même manière, il existe un opérateur de décrémentation noté -- qui est :

4- Les Opérateurs relationnels

 > supérieur stricte

TOME I : LES BASES DU LANGAGE JAVA

5- Les Opérateurs logiques

Java dispose d’opérateurs logiques dont voici la liste,

6- L’opérateur d’expression Conditionnel

nomvariable = (condition ? val1 : val2) ;

TOME I : LES BASES DU LANGAGE JAVA

CHAPITRE 5 : LES D’ENTREES/SORTIES

- Instancier une instance de la classe Scanner par l’instruction

Scanner nom_instance=new Scanner(System.in) ;

- Via l’instance faire appel aux méthodes de la classe Scanner

• L’objet in de la classe System est en fait associé à votre clavier

 nextInt () : pour les int