Système d’Information et de Connaissances

Introduction à la programmation
en Java

S.I.C
 Plan
 Introduction générale
 Langages compilés

 Langages interprétés

 JAVA, interprété ou compilé ?

 Introduction au JAVA
 Environnement de programmation

 JVM, JRE, JDK et SDK

 Quelques packages

 Package de base : java.lang

 Historique des versions

2
 Plan
 Syntaxe et éléments de bases de Java
 Types primitifs
 Variables
 Constantes
 Conversion de type de données
 Conversion explicite
 Conversion implicite
 Lire les entrées clavier
 Opérateurs
 Fonctions mathématiques
 Structures de contrôles des instructions
 Tableaux
 Fonctions
 Procédures

3
 Langages de programmation

 Les langages de programmation actuels sont majoritairement de deux sortes :

 Langages compilés.

 Langages interprétés.

 Lors du choix d’un langage pour un projet, cet aspect fondamental peut faire
pencher la balance.

4
 Langage machine
 Le langage machine, ou code machine, c’est le langage natif d’un
processeur, c’est-à-dire le seul qu’il puisse traiter.

 C’est la suite de bits qui est interprétée par le processeur d’un ordinateur
exécutant un programme informatique.

 Il est composé d’instructions et de données à traiter codées en binaire.

 Le code machine est généré, généralement par la compilation d’un langage de

programmation.

5
 Langage compilé

 Un programme écrit dans un langage compilé va être traduit une fois pour toutes
par un compilateur, afin de générer un fichier exécutable.
 Exemple : C, C++, Pascal, Fortran, Cobol, ADA.
 Le langage C :
 gcc -o essai.o -c essai.c
 gcc -o essai essai.o
 Ou

 gcc –o essai essai.c

 Avantage : rapide.
 Inconvénient : fermé si on n’a pas le source, besoin de l’outil de développement
pour modifier.

6
 Langage interprété

 Un langage informatique se dit interprété lorsque les instructions qui le

composent sont décodées les unes après les autres et exécutées aussitôt.

 Son fonctionnement est le suivant :

 Lire l’instruction ;

 Exécuter l’instruction ;

 Passer à l’instruction suivante et recommencer.

7
 Langage interprété

 Un langage interprété a besoin d’un interpréteur.

 BASIC, MATLAB, PHP, Prolog, Perl.

 Le QBasic se lançait avec la commande : qbasic /run prog.bas

 Avantage : le programme prog.bas est un fichier texte, facilement

modifiable.

 Inconvénient : c’est forcément plus lent que quand c’est compilé.

8
Quelques langages

9
 Langages intermédiaires

 Certains langages appartiennent en quelque sorte aux deux catégories :

 LISP, Python, …

 Le programme écrit avec ces langages peut dans certaines conditions subir
une phase de compilation intermédiaire vers un fichier écrit dans un langage
différent du fichier source et non exécutable (nécessité d’un interpréteur).

10
 JAVA : compilé ou interprété ?
 JAVA a été développé par Sun au début des années 90 dans une filiation avec le
langage C et surtout le langage objet C++ mais dans une optique de plus
grande portabilité d’une machine à une autre et d’une plus grande fiabilité.

 Les programmes JAVA sont compilés en "bytecode", un langage intermédiaire

indépendant de la plateforme.

 Ce "bytecode" est interprété par une machine virtuelle sur des machines
différentes : Mac, Pc, Windows, Linux, Unix, ...

11
 JAVA : compilé ou interprété ?

 Un langage compilé est un langage pour lequel le compilateur va traduire le

code écrit par les développeurs en code exécutable directement par la
machine.

 Un langage interprété est un langage pour lequel la traduction en code

machine n’est fait qu’à l’exécution.

 Pour le java, on à une étape de compilation qui produit du code qui sera
exécuté par une machine virtuelle, c’est une solution intermédiaire qui permet
de rester indépendant du type de machine qui exécutera le code tout en ayant
un code déjà optimisé pour l’exécution.

12
 JAVA : compilé ou interprété ?

Fichier source Compilateur

(*.java) (javac)

Bytecode
(*.class)

Interpréteur
(java)

13
 JAVA : environnement de programmation
 JAVA est un environnement de programmation objet composé de :
 Langage orienté objet JAVA.
 JVM (machine virtuelle Java) : permettant d’interpréter et d’exécuter le
bytecode Java.
 API (Application Programming Interface) : un ensemble de classes standards
(bibliothèque standard).
 JRE (Java Runtime Environment) : l’environnement d’exécution Java désigne
un ensemble d’outils permettant l’exécution de programmes Java sur toutes les
plates-formes supportées.
 JRE est constitué de la JVM et de la bibliothèque standard (API) à partir
de laquelle doivent être développés tous les programmes en Java.
 java.lang est le package de base qui contient les classes qui seraient
toujours utilisées (System, Thread, Math, String, …).
 Toutes les classes et interfaces de java.lang sont automatiquement
importées par le compilateur.
14
 JAVA : environnement de programmation
 Java Development Kit (JDK) : le nouveau terme c’est SDK (Standard
Development Kit) qui est l’environnement dans lequel le code Java est
compilé pour être transformé en bytecode afin que la machine virtuelle Java
(JVM) puisse l’interpréter. Les composants primaires du JDK sont une
sélection d’outils de programmation, incluant :
 javac : le compilateur, qui convertit le code source en fichier .class
(contenant le bytecode Java).
 javadoc : le générateur de documentation, qui génère automatiquement
de la documentation à partir des commentaires du code source.
 jar : l’archiveur, qui met sous forme d’un paquetage unique l’ensemble
des fichiers class en un fichier JAR.
 jdb : le débogueur.
 JRE : environnement d’exécution Java.

15
 Quelques packages
 Package de base : java.lang
 Toutes les classes et interfaces de java.lang sont automatiquement importées
par le compilateur.
 Gestion de données et utilitaires : java.util
 Rassemble des classes d’utilitaires (gestion des collections de données,
génération de nombres aléatoires, énumération, date,...).
 Définit les classes d’exceptions :
 EmptyStackException.

 NoSuchElementException.

 Gestion des applets : java.applet

 La classe Applet et les interfaces de ce package permettent de programmer
une applet Java et d'intégrer une applet dans un navigateur.
 Manipulation d’images : java.awt.image
 Les classes de ce package permettent de manipuler les images (gestion du
chargement des images, filtres, gestion des couleurs,...).
16
 Quelques packages
 Entrées-sorties : java.io
 Rassemble les classes permettant de gérer les entrées-sorties (accès fichiers,
gestion de répertoires,...).
 Définit les classes d’exceptions :
 IOException.
 EOFException.
 FileNotFoundException.
 InterruptedIOException.
 UTFDataFormatException.
 Accès réseau : java.net
 Rassemble les classes permettant de gérer les accès réseau.
 Définit les classes d’exceptions :
 MalformedURLException.
 ProtocolException.
 SocketException.
 UnknownHostException.
 UnknownServiceException. 17
 Quelques packages

 Interface utilisateur :
 java.awt : utilise les composant graphiques natifs.
 Définit les classes d’exceptions :
 AWTException.
 AWTError.
 javax.swing : librairie très puissante, composants très évolués (arbres,
tables, …).
 Définit l’exception : UnsupportedLookAndFeelException
 Java 3D : javax.media.j3d
 Rassemble les classes de l’API Java 3D (interface de programmation pour
la plateforme Java visant la synthèse d'image 3D).

18
 Historique des versions
 Le langage Java a connu plusieurs évolutions depuis le JDK 1.0 (Java
Development Kit) avec l’ajout de nombreuses classes et packages à la
bibliothèque standard.

 JDK 1.0 (23 janvier 1996 - 211 classes et interfaces) : version initiale.

 JDK 1.1 (19 février 1997 - 477 classes et interfaces) : de nombreux ajouts
avec notamment :

 Une refonte complète du modèle événementiel AWT.

 Les classes internes sont ajoutées au langage.
 JavaBeans.
 JDBC.
 Java Remote Invocation (RMI).

19
 Historique des versions
 J2SE 1.2 (9 décembre 1998 - 1524 classes et interfaces) : cette version et
les suivantes jusque J2SE 5.0 sont rebaptisées Java 2 et l’édition nommée
J2SE remplace JDK pour distinguer la plate-forme de base de l’édition J2EE
et de l’édition J2ME.
 J2SE : (Java 2 Standard Edition) comprenant les API et bibliothèques
de bases, ainsi que les API destinés au poste client (comme par exemple
Java Foundation Classes (JFC) qui est un framework graphique pour Java
composé de AWT, Swing et Java2D).
 J2EE : (Java 2 Enterprise Edition) destinée aux développements des
applications d’entreprises. Sun propose en plus des spécifications, des
mises en œuvre illustratives.
 J2ME : (Java 2 Micro Edition) destinée aux systèmes mobiles tel que
par exemple, les assistants personnels ou les téléphones portables.
 Plusieurs ajouts par rapport à la version précédente dont :
 Le framework Collections.
 L’API graphique Swing est intégrée.

20
 Historique des versions

 J2SE 1.3 (8 mai 2000 - 1840 classes et interfaces) : changements principaux :

 Changement pour les RMI pour être basé sur CORBA.

 JavaSound.

 JNDI (Java Naming and Directory Interface) inclus de base (disponible

auparavant comme extension) pour utiliser différents services de nommages

ou d'annuaires.

 JPDA (Java Platform Debugger Architecture) pour les outils de type

débogueur.

21
 Historique des versions
 J2SE 1.4 (6 février 2002 - 2723 classes et interfaces) : les principaux
changements sont :
 Mot-clé assert.
 Expressions rationnelles modélisées en s’inspirant du langage Perl.
 Chaînage d’exception.
 API de journalisation.
 API Image I/O pour lire et écrire des images dans des formats comme
JPEG et PNG.
 Intégration d’un parser XML (pour extraire les données d’un document
XML et pour vérifier sa validité) et du moteur XSLT nommé JAXP.
 JAXP (Java API for XML Processing) est une API permettant la
création, la manipulation et le traitement de fichiers XML à bas
niveau.
 Intégration des extensions de sécurité JCE (Java Cryptography
Extension), JSSE et JAAS.
 Java Web Start (introduit pour la première fois en mars 2001 pour J2SE
1.3).
22
 Historique des versions
 J2SE 5.0 (30 septembre 2004 - 3270 classes et interfaces) : (initialement
numérotée 1.5, qui est toujours utilisé comme numéro de version interne),
ajoute un nombre significatif de nouveautés au langage :
 Programmation générique.
 Metadata, également appelées annotations, permet au langage de
construire des classes et des méthodes étiquetées avec des données
additionnelles qui peuvent être utilisées en tant que méta-données.
 Autoboxing/unboxing, conversion automatique entre des types primitifs
(comme le type int) et le Wrapper de classe correspondant (comme la
classe Integer).
 Énumérations : le mot-clé enum permet de créer une liste ordonnée de
valeurs sans type.
 Extension du for pour les boucles, la syntaxe du for est étendue avec une
syntaxe spéciale pour itérer sur n’importe quel objet itérable comme un
tableau, ou une collection.
23
 Historique des versions
 Java SE 6 (11 décembre 2006 - 3777 classes et interfaces) : avec cette version,
Sun remplace le nom J2SE par Java SE et supprime le .0 au numéro de version.

 Java SE 7 (28 juillet 2011) : Il s’agira de la première version sous la licence GPL.
 La GPL met en œuvre la notion de copyleft.
 Copyright garantit exclusivement les droits de l’auteur.
 Copyleft s’attarde tout particulièrement aux droits des utilisateurs, et vise à
préserver la liberté d’utiliser, d’étudier, de modifier et de diffuser le logiciel et
ses versions dérivées.

 Java SE 8 (prévue pour 2013): une des nouveautés majeures de cette version sera
l’ajout des closures (en cours de spécifications).
 closure est un bloc de code référençable, manipulant optionnellement des
variables dites "libres", libres en ce sens qu’elles sont définies non dans le bloc
de code, ni de façon globale, mais par le contexte dans lequel le bloc est
exécuté.

24
 Caractéristiques du JAVA
 Simple : plus simple que le C ou le C++ car on lui a retiré les caractéristiques peu
utilisées ou difficile à utiliser :
 Pointeurs.
 Héritage multiple.
 Le mécanisme de libération de la mémoire (garbage-collector) est
transparent contrairement au C++.
 Le ramasse-miettes qui est une fonctionnalité de la JVM est appelé
régulièrement et automatiquement pendant l’exécution du programme.
 Quand il n’existe plus aucune référence permettant d’atteindre un objet, le
ramasse-miettes le détruit automatiquement puisque qu’il est devenu
inaccessible libérant la mémoire et prévenant ainsi toute fuite de mémoire.
 Orienté objet : une classe contient des attributs et des méthodes.
 Principe de l’encapsulation.
 Distribué : il est facile de mettre en place une architecture Client-Serveur pour
travailler avec des fichiers situés sur un ordinateur distant.
 Multithread : pour l’exécution simultanée de plusieurs processus. Java est fourni avec
un jeu de primitives qui facilitent l’écriture de ce genre de programmes.
25
 Caractéristiques du JAVA
 Robuste : le typage des données est très strict, tant à la compilation qu’à
l’exécution. Les pointeurs utilisés dans Java ne sont pas accessibles au
programmeur.
 Dynamique : les classes de Java peuvent être modifiées sans modification du
programme qui les utilise.
 Portable : le compilateur java fabrique du byte code "universel". Pour l’exécuter
sur une machine quelconque, il faut qu’un interpréteur java (machine virtuelle)
existe pour cette machine. Les types de données sont indépendants de la plate-
forme.
 Une variable int sera toujours définie dans un entier 32 bits en complément à
2 aussi bien sur un PC 486 que sur un Power Macintosh.
 Les char relèvent du standard Unicode.
 Les boolean prennent toujours les valeurs true et false.
 Haute performance : le compilateur java génère du byte code optimisé en
incluant des instructions qui permettront à chaque interpréteur de tirer la meilleure
performance possible du code. La vitesse d’exécution du code peut être semblable
à celle de C ou C++.
26
 Premier programme JAVA

// mon premier programme java

class Prog1
{
public static void main(String args[])
{
System.out.println ("bonjour tous le monde");
}
}

Un programme JAVA est une classe qui doit être enregistrée dans
un fichier de même nom et d’extension .java.

27
 Lignes du programme

 // introduit un commentaire.
 Un programme Java exécutable comporte au moins 1 classe qui contient elle-
même au moins la méthode main.
 La méthode main est toujours celle qui est "lancée" à l’exécution du
programme.
 La seule instruction de la méthode est l’affichage d’une chaîne de caractères
sur la sortie standard (l’écran) avec ajout d’un passage à la ligne : appel à la
méthode println de la classe System.
 Compilation puis exécution :
 javac Prog1.java
 java Prog1
bonjour tous le monde

28
Types primitifs en JAVA

29
 Variables
 Les variables en langage Java sont typées, c’est-à-dire que les données contenues
dans celles-ci possèdent un type, ainsi elles sont donc stockées à une adresse
mémoire et occupent un nombre d’octets dépendant du type de donnée stockée.
 La déclaration de variables :
int nb;
nb=8;
int x=nb+2;
float toto = 125.36f;
System.out.println("Le nombre entier vaut : " + x + "\n"+"Le nombre reel vaut :
" +toto );

 Exécution :
javac affichage.java
java affichage
Le nombre entier vaut : 10
Le nombre reel vaut : 125.36
30
 Constantes

 Une constante est une variable dont la valeur est inchangeable lors de
l’exécution d’un programme.

 Le mot clé final permet de définir une variable dont la valeur ne peut pas être
modifiée après son initialisation.

 final int d = 12;

final double b = 12.6;

b=b*2;

31
 Conversion de type de données
 Conversions implicites :
 Une conversion de type implicite sans perte d’informations est réalisée
d’un type primitif vers un type plus grand (élargissement) :
 byte short int long float double
 char int

 Exemple:

int i=7;
double x=i;

32
 Conversion de type de données

 Conversion explicite :
 Une conversion explicite consiste en une modification du type de donnée
forcée.
 Cela signifie que l’on utilise un opérateur dit de cast pour spécifier la
conversion.
 L’opérateur de cast est tout simplement le type de donnée, dans lequel on
désire convertir une variable, entre des parenthèses précédant la variable.
 Une conversion de type explicite se fait avec perte d’informations est
réalisée d’un type primitif vers un type plus petit.
 Exemple :
double x=4.667;
int i= (int) x; // i vaut la valeur 4

33
 Lire les entrées clavier
import java.util.Scanner;
class Prog1
{
public static void main(String args[])
{
Scanner sc = new Scanner (System.in);
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
System.out.println("Vous avez saisi : " + str);
System.out.println("Veuillez saisir un caractere :");
char carac = sc.nextLine().charAt(0);
System.out.println("Vous avez saisi le caractère : " + carac);
System.out.println("Veuillez saisir un entier :");
int x = sc.nextInt();
System.out.println("Vous avez saisi le nombre : " + x);
System.out.println("Veuillez saisir un reel :");
double d = sc.nextDouble();
System.out.println("Vous avez saisi le nombre : " + d);
System.out.println("Veuillez saisir un boolean :"); // true ou false
boolean bool=sc.nextBoolean();
System.out.println("Vous avez saisi : " + bool);
}
}
34
 Chaînes de caractères
 La classe String permet de gérer les chaînes de caractères.
 La méthode length() retourne le nombre de caractères de la chaîne concernée.
 String s = "java" ;
 System.out.println (s.length ( ) ) ; // affiche 4
 La méthode charAt (int i) retourne le caractère d’indice i de la chaîne.
 String s = "java" ;
 System.out.println (s.charAt ( 2 ) ) ; // affiche v
 La méthode equals (String c) retourne true si la chaîne concernée est identique à la
chaîne c et false sinon.
 String s = "java" ;
 String t = "lundi" ;
 String u = "ja" + "va" ; // Concaténation de 2 chaine s
 System.out.println (s.equals ( t ) ) ; // Affiche false
 System.out.println (s.equals (u ) ) ; // Affiche true
35
 Chaînes de caractères
 public String concat (String str)
 Renvoie la chaîne, résultat de la concaténation de str à la fin d’une chaîne
de caractères.
 public String replace (char oldChar, char newChar)
 Renvoie une chaîne où tous les caractères oldChar sont convertis en
newChar.
 public String toLowerCase ( )
 public String toUpperCase ( )
 Renvoie une chaîne où tous les caractères majuscules sont convertis en
minuscules, et inversement.
 public String trim ( )
 Renvoie une chaîne où tous espaces en tête et en queue d’une chaîne de
caractères sont supprimés.
36
 Exemple
class affichage{
public static void main(String args[]){
String a="bonjour".concat (" tous le monde");
System.out.println (a);
String b=a.replace ('o','i');
System.out.println (b);
System.out.println (b.toUpperCase ( ));
System.out.println ("TLEMCEN".toLowerCase ( ));
System.out.println (" univ ".trim ( ));
}
}
 Exécution :
bonjour tous le monde
binjiur tius le minde
BINJIUR TIUS LE MINDE
tlemcen
univ 37
 Opérateurs

 Les opérateurs sont des symboles qui permettent de manipuler des variables.
 On distingue plusieurs types d’opérateurs :
 Opérateurs de calcul.

 Opérateurs d’assignation.

 Opérateurs d’incrémentation.

 Opérateurs de comparaison.

 Opérateurs logiques.

…

38
 Opérateurs de calcul

Permettent de modifier mathématiquement la valeur d’une variable

39
 Opérateurs d’assignation
 Ces opérateurs permettent de simplifier des opérations telles que ajouter une valeur
dans une variable et stocker le résultat dans la variable.

 Exemple :

 x=x+2 x+=2

 Les autres opérateurs du même type sont les suivants :

Opérateur Effet
+= Addition deux valeurs et stocke le résultat dans la variable à gauche
-= Soustrait deux valeurs et stocke le résultat dans la variable
*= Multiplie deux valeurs et stocke le résultat dans la variable
/= Divise deux valeurs et stocke le résultat dans la variable

40
 Opérateurs d’incrémentation

 Ce type d’opérateur permet de facilement augmenter ou diminuer d’une unité

une variable.
 Ces opérateurs sont très utiles pour des structures telles que des boucles qui ont besoin
d’un compteur (variable qui augmente de un en un).

41
 i++ et ++i

 int i=1;
 int j=i++; i++ : on retourne la valeur de i et après on l’incrémente.
 System.out.println (j); 1
 System.out.println (i); 2

 int i=1;
 int j=++i; ++i : on incrémente la valeur de i et on la retourne.
 System.out.println (j); 2
 System.out.println (i); 2

42
Opérateurs de comparaison

43
 Opérateurs logiques (booléens)

Ce type d’opérateur permet de vérifier si plusieurs conditions sont vraies :

44
 Fonctions mathématiques

double r;
r=Math.random();
System.out.println("valeur aléatoire = " +r);
r=Math.random();
System.out.println("encore : " +r);
double d=5.4; double e=5.5;
System.out.println("valeur = "+d+" son arrondi = "+Math.round(d));
System.out.println("valeur = "+e+" son arrondi = "+Math.round(e));
int i=11, j=32, k=13, m;
m = Math.max (i,Math.max(j,k));
System.out.println("max de 3 entiers = " +m);

Pas besoin d’importer la classe Math : elle fait partie du

"package" java.lang de classes directement intégrées.

45
 Fonctions mathématiques

Exécution :

valeur aléatoire = 0.7553004262329193

encore : 0.5000391529538152

valeur = 5.4 son arrondi = 5

valeur = 5.5 son arrondi = 6

max de 3 entiers = 32

46
 Structures de contrôles des instructions
 Les instructions alternatives (de choix)
 if-else

if (condition)
instruction à exécuter quand
la condition est vrai;
else
instruction à exécuter quand
la condition est fausse;

47
 Exemple

 Écrire un programme qui affiche "vous êtes majeur" ou "vous

êtes mineur" en fonction d’une variable age.

48
 Solution

int age ;
age=17;
if ( age>=18)
{
System.out.println ("Vous êtes majeur" ) ;
}
else
{
System.out.println ( "Vous êtes mineur") ;
}
49
 Imbrication de structure de contrôle alternative

if (condition1)
bloc_1
else if (condition2)
bloc_2
else if (condition3)
bloc_3
.
.
else
bloc_n

50
 Exemple

 Écrire un programme qui affiche l’état d’un liquide composé d’eau pure en
fonction d’une variable température t.

 Bien évidemment nous sommes sur terre, au niveau de la mer, avec une
pression normale.

51
 Solution

int t ;
t=-10;
if ( t<=0)
{
System.out.println ("solide") ;
}
else if (t<=100)
{
System.out.println ("liquide") ;
}
else
{
System.out.println ( "gaz") ;
}

52
 Opérateur ternaire
 Il est possible de faire un test avec une structure beaucoup moins lourde grâce
à la structure suivante, appelée opérateur ternaire :
 (condition) ? instruction si vrai : instruction si faux
 Lorsque la condition est vraie, l’instruction de gauche est exécutée.
 Lorsque la condition est fausse, l’instruction de droite est exécutée.

 Exemple:
 int a=12;

 int b=9;

 int max = (a>b) ? a : b;

 System.out.println(max);

53
 Switch
 L’instruction switch permet de faire plusieurs tests de valeurs sur le contenu d’une même
variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs
d’une variable.
 Cette opération aurait été compliquée (mais possible) avec des if imbriqués. Sa
syntaxe est la suivante :

switch (Variable) {

case Valeur1 :
Liste d’instructions;
break;
case Valeur2 :
Liste d’instructions;
break;
case Valeurs... :
Liste d’instructions;
break;
default:
Liste d’instructions;
break;
} 54
import java.util.Scanner;
class Jour {
public static void main (String args[]) {
Scanner sc = new Scanner(System.in);
String res;
System.out.println("donner un numero");
int x = sc.nextInt();
switch (x) {
case 0 :
res = "lundi";
break;
case 1 :
res = "mardi";
break;
case 2 :
res = "mercredi";
break;
case 3 :
Exemple
res = "jeudi";
break;
case 4 :
res = "vendredi";
break;
case 5 :
res = "samedi";
break;
case 6 :
res = "dimanche";
break;
default :
res = "erreur";
break;
}
System.out.print("c’est un "+res);
} 55
}
 Boucles : instructions répétitives

 La boucle for : permet de répéter un nombre de fois prédéfini

une instruction ou un bloc d’instructions.
int i ;
int x ;
for (i =1; i <5; i=i+1)
{
x=2*i ;
System.out.println (x) ;
}

56
 Double boucle

for (int i=0; i<10; i=i+1)

Exécution :
{
for (int j =0; j<i ; j=j+1)
x
{
xx
System.out.print("x") ;
xxx
}
xxxx
System.out.println( ) ;
xxxxx
}
xxxxxx
xxxxxxx
xxxxxxxx
xxxxxxxxx

57
 Boucle while

int x ;
x=32;
while ( x!=1)
{
System.out.println (x) ;
x=x / 2 ;
}

58
 Boucle do while
Exemple : Obliger l’utilisateur à saisir une valeur entre 5 et 9.
//----------------------------
import java.util.Scanner;
class nombre
{
public static void main (String args[])
{
Scanner sc = new Scanner(System.in);
int nombre;
do {
System.out.println ("donnez une valeur entiere entre 5 et 9");
nombre= sc.nextInt();
} while ((5 > nombre) || (nombre > 9)) ;
System.out.println("la valeur est : " + nombre);
}
}
59
 Math.random( )

 La fonction Math.random ( ) permet de générer aléatoirement un nombre réel dans

l’intervalle [0; 1[.
 Pour générer un nombre entier aléatoire compris entre 0 et 100 nous devons
multiplier le résultat de la fonction Math.random(), puis convertir le résultat en
entier.
 int x ;
 x=(int) (Math.random( ) *101 ) ;
 x aura pour valeur un nombre aléatoire compris entre 0 et 100.
 Exercice :
 Proposer un programme permettant d’afficher :
 15 valeurs aléatoires comprises entre 56 et 78.
 4 valeurs aléatoires comprises entre -5 et 5.

60
 Exercices

 Écrire un programme affichant les multiples de 3 de 1 à 10.

 Écrire un programme affichant la somme des 20 premiers entiers.

 Écrire deux programme différents qui affichent les 20 premiers chiffres entiers, du
plus grand au plus petit.

 Écrire un programme permettant de lire au clavier un entier, tant que celui-ci n’est pas
pair.

 Écrire un programme qui lit des entiers tant que leur somme est inférieure à 100.

 Écrire un programme qui lit un nombre entier, qui affiche son carré et qui se termine
quand le chiffre 0 est lu.

61
 Exercices

 Écrire un programme, en utilisant une boucle adaptée, pour chacune des tâches
suivantes :

 Afficher les 20 premiers termes de la suite 1/2^i.

 Lire un entier x et afficher les nombres pairs, à partir de 2, tant que leur somme
est inférieure à x.

 Lire 10 nombres et calculer le minimum de ceux-ci.

 Lire un entier x et afficher les 5 premiers termes de la suite 1/x^i , tant que l’entier
x lu n’est pas 0.

62
 Tableaux
class TabMax
{
public static void main (String args[])
{
int [] tab;
tab = new int[5];
tab[0]= 3; tab[1]= 45; tab[2]= 5; tab[3]= 412; tab[4]= 0;
//int tab[] = {3,45,5,412,0};
int nbre, i, max;
System.out.println("le nombre d’element"+ " du tableau = " + tab.length);
i=1; max=tab[0];
while (i < tab.length)
{
if (tab[i]>max) max = tab[i] ;
i = i+1;
}
System.out.println("le maximun est " + max);
}
}
Stocker plusieurs éléments de même type 63
 Tableau à 2 dimensions
class IDENT {
public static void main (String args[]) {
int ident [ ][ ];
int i,j;
ident = new int[5][5];
for (i=0; i<5;i++)
for (j=0; j<5 ; j++)
if (i ==j )
ident[i][j]=1;
else
ident[i][j]=0;
System.out.println("matrice identite :");
for (i=0; i<ident.length ; i++)
{
for (j=0; j<ident[0].length ; j++)
System.out.print(ident[i][j]+" ");
System.out.println();
}
//int matrice [] [] = {{1,2},{3,4}};
//System.out.print(matrice[1][0]+" ");
}
}
64
 Tableau à 2 dimensions
class IDENT {
public static void main (String args[]) {
int ident [ ][ ];
int i,j;
ident = new int[5][5];
for (i=0; i<5;i++)
for (j=0; j<5 ; j++)
if (i ==j ) Exécution :
ident[i][j]=1; matrice identite :
else
ident[i][j]=0; 10000
System.out.println("matrice identite :"); 01000
for (i=0; i<ident.length ; i++)
{ 00100
for (j=0; j<ident[0].length ; j++) 00010
System.out.print(ident[i][j]+" ");
System.out.println(); 00001
}
//int matrice [] [] = {{1,2},{3,4}};
//System.out.print(matrice[1][0]+" ");
}
}
65
 Tableau : arguments de la méthode main
 Il est possible de passer des paramètres au programme par l’argument de la méthode
main :
 String args[] est un tableau de chaînes de caractères, autant de paramètres passés.
 Le passage se fait en tapant la commande :
 java programme parametre1 parametre2 ….
 Exemple :
class ARG {
public static void main (String args[]) { Exécution :
int i; javac ARG.java
java ARG tous le 13 tlemcen
System.out.println("les arguments :");
les arguments :
for (i=0; i<args.length ; ++i) for (String d : args)
tous
System.out.println(args[i]); System.out.println (d);
le
} 13
Rapprochement vers la boucle foreach()
} tlemcen
que l’on trouve dans d’autres langages.

66
 Exercice

 Proposer un programme permettant de définir un tableau de 20 entiers de

valeurs initiales 1.

 Proposer un programme permettant de définir un tableau de 20 entiers

correspondant aux 20 premières valeurs de la suite ui = 2*i; i > 0.

 Proposer un programme permettant de définir un tableau de 2000 entiers de

la suite 2000, 1999, 1998, 1997, 1996, 1995, 1994, . . ., . . ., 3, 2, 1.

 Proposer un programme permettant de remplir, par des lectures au clavier, un

tableau de 10 entiers.

67
 Tableau de caractères vs String
 Tableau de caractère vers chaîne de caractère :
char [ ] tab ={'a','b','c','d'};
String s =new String (tab);
System.out.println (s); // affiche abcd

char [ ] tab2 = new char [2] ;

tab2 [0] = 'h';
tab2 [1] = 'i';
s = new String (tab2);
System.out.println (s); // affiche hi

 Chaîne de caractère vers tableau de caractère :

String chaine="bonjour";
char []tab=new char [chaine.length()];
for (int i=0;i<chaine.length();i++) tab[i]=chaine.charAt(i);
for (int i=0;i<chaine.length();i++) System.out.println(tab[i]);

68
 Fonctions et procédures

 Un algorithme a souvent besoin de répéter des séries d’instructions, identiques

ou similaires, qui aboutissent à un résultat dépendant des valeurs d’entrée.
 Il va donc déporter ces tâches de calcul dans un sous-algorithme.

 Un algorithme peut appeler un sous-algorithme : l’algorithme principal passe

ainsi temporairement le contrôle de l’exécution du traitement au sous-
algorithme.

 Un sous-algorithme est conçu pour faire un traitement bien défini, bien

délimité, si possible indépendamment du contexte particulier de l’algorithme
appelant.

69
 Procédure avec paramètres

public class carre

{
public static void affichagecarre (int i)
{
System.out.println (i*i) ;
}
public static void main ( String [ ] Argv )
{
int y ;
y=8;
affichagecarre (3) ;
affichagecarre (5) ;
affichagecarre (y) ;
affichagecarre (10) ;
}
}

70
 Procédure sans paramètres

public class affichage

{
public static void affichage5 ( )
{
int i ;
for ( i =1; i <6; i=i+1)
{
System.out.println ( i ) ;
}
}
public static void main ( String [ ] Argv )
{
affichage5 ( );
}
}

71
 Fonctions
public class PROD
{
public static int produit ( int i , int j )
{
int k ;
k=i*j ;
return k ;
}
public static void main ( String [ ] Argv )
{
int x ;
x= produit (5 , 6) ;
System.out.println (x) ;
x= produit (15 , 3) ;
System.out.println (x) ;
}
} 72
 Fonctions
public class MAXI{
public static double maximun( double x , double y )
{
double z ;
if (x<y )
{
z=y ;
}
else
{
z=x;
}
return z ;
}
public static void main ( St ring [ ] Argv )
{
double max ;
max= maximun ( 5.0 , 5.1 ) ;
System .out.println (max ) ;
max= maximun ( 15.80 , 7.91 ) ;
System .out.println (max ) ;
}
}
73
 Instruction d’interruption break
 Une instruction break ne peut se situer qu’à l’intérieur du corps d’instruction d’un
bloc switch ou de l’une des trois itérations while, do..while, for.
 Lorsque break est présente dans l’une des trois itérations while, do..while, for :
 Si break n’est pas suivi d’une étiquette, elle interrompt l’exécution de la boucle
dans laquelle elle se trouve, l’exécution se poursuit après le corps d’instruction.
 Si break est suivi d'une étiquette, elle fonctionne comme un goto : utilisation
déconseillée en programmation moderne sauf pour le switch.

public static void afficher (int n) public static void main (String args[]) {
{ afficher(17);
for (int i=1; i<=n;i++) { }
System.out.print(i+" ");
if (i%10==0) break;
1 2 3 4 5 6 7 8 9 10 bonjour
}
System.out.println("bonjour");
}
74
 Instruction de rebouclage continue
 Une instruction continue ne peut se situer qu’à l'intérieur du corps d'instruction de
l’une des trois itérations while, do..while, for.
 Lorsque continue est présente dans l’une des trois itérations while, do..while, for :
 Si continue n’est pas suivi d’une étiquette elle interrompt l’exécution de la
séquence des instructions situées après elle, l’exécution par rebouclage de la
boucle.
 Si continue est suivi d’une étiquette elle fonctionne comme un goto : utilisation
déconseillée en programmation moderne.

public static void afficher(int n){

for (int i=1; i<=n;i++) public static void main (String args[]) {
{ afficher(17);
if (i%10==0) continue; }
System.out.print(i+" ");
} 1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17
}
75
 Exercice

 Le palindrome est un mot dont l’ordre des symboles reste le même qu'on le lise de
gauche à droite ou de droite à gauche (radar, elle, rever, Engage le jeu que je le gagne,
...).

 Écrire une fonction inverseChaine qui retourne une chaine de caractères représentant
l’inverse de la chaîne passée en paramètre.

 Écrire une fonction estIdentique qui retourne vrai si les 2 chaînes de caractères passées
en paramètres sont identiques, faux sinon.

 Écrire un programme principal qui utilise intelligemment toutes les fonctions et

procédures écrites précédemment.

 Reprendre les questions précédentes en gérant les espaces et la casse.

76
 Exercice

 En utilisant des procédures, proposez les algorithmes suivants :

 Lire un nombre entier et afficher son cube.

 Lire un entier et afficher "Vrai" si l’entier est pair.

 Lire un nombre réel x et afficher tous les entiers positifs plus petit que x,
ceci tant que x est supérieur à 0.

77
 Exercice
 En utilisant des fonctions, proposez les algorithmes suivants. A noter qu’il est
préférable d’éviter les instructions d’affichage à l’intérieur d’une fonction.
 Lire un nombre réel et calculer le cube de celui-ci.

 Lire un nombre entier n et calculer la somme des n premiers entiers (en

utilisant une boucle).
 Lire deux nombres entiers hauteur et largeur puis calculer l’aire du
rectangle correspondant.
 Calculer le maximum de trois nombres.

 Lire un nombre entre 1 et 7 et afficher le jour de la semaine

correspondant.
 Lire un nombre réel x puis calculer l’arrondi inférieur de x.

78
 Exercice

 Proposez une fonction lire_entier_pair permettant de lire un entier et

d’assurer sa parité.

 Proposez un jeu permettant de retrouver au clavier un nombre préalablement

défini. Tant que le nombre lu n’est pas le bon, le jeu affichera plus petit ou
plus grand. La victoire sera marquée par gagné.

 On affichera au final le nombre de coups nécessaires pour trouver le nombre.

79
 Exercice
 Proposer une procédure affiche_tableau_entiers (tab : tableau d’entiers) permettant
d’afficher un tableau d’entiers.

 Écrire une fonction créer_tableau qui permet de définir un tableau de 20 entiers

correspondant aux 20 premières valeurs de la suite u0 = 1;
ui = 3*u i-1 +4; i > 0.

 La fonction Math.random ( ) permet de générer aléatoirement un nombre réel dans

l’intervalle [0; 1[.
 Pour générer un nombre entier aléatoire compris entre 0 et 100 nous devons
multiplier le résultat de la fonction Math.random(), puis convertir le résultat en
entier.
 int x ;
 x=(int) (Math.random( ) *101 ) ;
 x aura pour valeur un nombre aléatoire compris entre 0 e t 100.

 Proposer un programme permettant de définir un tableau de 50 entiers rempli avec des

valeurs aléatoires comprises entre 0 et 1000.

80
 Exercice
 Écrire une fonction somme qui permet de calculer la somme des éléments d’un
tableau.

 Écrire une fonction au_dessus qui prend en paramètre un tableau d’entiers et un entier
n. Cette fonction retourne le nombre d’éléments strictement supérieurs à la valeur n.

 Écrire une fonction moyenne qui permet de calculer la moyenne des éléments d’un
tableau.

 Écrire une fonction maximum qui retourne le maximum des éléments d’un tableau.

 Écrire une fonction minimum qui retourne le minimum des éléments d’un tableau.

 Écrire une fonction occurrence qui retourne le nombre d’occurrences d’un entier x
parmi les éléments d’un tableau. La valeur de x sera passée en paramètre de la
fonction.

 Écrire une procédure affichage_inverse qui affiche un tableau dans l’ordre inverse.

81
 Exercice

 Écrire une fonction autreSens qui retourne le tableau d’entiers passé en paramètre dans
l’ordre inverse. La première valeur de l’un est donc la dernière valeur de l’autre.
 Écrire une fonction sousTab qui prend un tableau d’entiers tab, une valeur de départ,
une valeur de fin et qui retourne le sous tableau compris entre les indices départ et fin
du tableau tab. On prendra soin de vérifier que les valeurs départ et fin sont valides
(par exemple fin doit être supérieur à départ).
 Écrire une fonction compareTab qui retourne vrai si les deux tableaux d’entiers passés
en paramètres sont égaux.
 Écrire une fonction concatTab qui retourne la concaténation de deux tableaux
d’entiers passés en paramètres.
 Ecrire une fonction qui teste si un tableau d'entiers passé en paramètre est trié ou non
(la fonction retourne un booléen).

82
 Exercice
 Écrire la procédure public static void remplissagealeatoire(int [] tableau) qui remplit un
tableau de nombres aléatoires compris entre 0 et 10000.

 Écrire la procédure public static void remplissageordrecroissant(int [] tableau) qui

remplit un tableau avec des valeurs classées par ordre croissant.

 Écrire la procédure public static void remplissageordredecroissant(int [] tableau) qui

remplit un tableau avec des valeurs classées par ordre décroissant.

 Écrire la procédure public static void triSelection(int[] tableau) permettant de trier le

tableau par selection.

 La fonction System.currentTimeMillis() ; retourne une valeur de type long égale au

nombre de millisecondes écoulées depuis le 1er janvier 1970 0H00 UTC.

 En comparant les valeurs retournées avant et après l’exécution d’une fonction

nous pouvons en déduire le temps approximatif d’exécution de la fonction.

83
 Exercice
long start ;
long stop ;
start=System.currentTimeMillis ( ) ;
triSelection (tab) ;
stop=System.currentTimeMillis ( ) ;
System.out.println ( "Temps tri du tableau : "+(stops-start ) ) ;

 Modifier la procédure main de la classe précédente pour afficher :

 Le temps pour trier un tableau rempli de nombres aléatoires.
 Le temps pour trier un tableau rempli de nombres trier par ordre
croissant.
 Le temps pour trier un tableau rempli de nombres trier par ordre
décroissant.

84