coursjavaDiapo.pdf

Info1A - Licence 1 - Année 2022/2023
Initiation à la programmation JAVA
Jean-Luc Baril
Université de Bourgogne
Labo. LIB
http://jl.baril.u-bourgogne.fr
September 12, 2022
Jean-Luc Baril Initiation à la programmation JAVA

Informations éventuellement utiles
Site web Module Info1A:
http://jl.baril.u-bourgogne.fr/Licence1.html
CM=14 TD=18 TP=18

Modalités de contrôle:
- Partiel écrit (en amphi) en milieu de semestre (coeff 1)
- Examen écrit (en amphi) en fin de semestre (coeff 2)
Planning:

Plages de TD et TPS selon groupes:

Bibliographie:

L’informatique?
Informatique - Computing science - Informatics
L’informatique est la science du traitement automatique de
l’information (1957 - Informatik - Karl Steinbuch).
Ordinateur - Computer
L’ordinateur est un ensemble de dispositifs physiques utilisés
pour traiter automatiquement des informations
(Microprocesseur, mémoire, écran, clavier, disques durs, ...).
Logiciel
Le logiciel est un ensemble structuré d’instructions décrivant un
traitement d’informations à faire réaliser par un ordinateur
(contraction de logique et matériel - 1972 - software )

L’informatique? Rapide historique
Les bouliers sont les plus anciennes machines à calculer.
Le principe du boulier est déjà en germe chez les
Babyloniens vers 2000 avant J.-C. ; à cette époque, on
utilise des cailloux pour compter. Puis, au cours du Ier
millénaire avant J.-C. naı̂t en Chine l’idée de fabriquer un
instrument qui faciliterait le calcul : le boulier.

Les batons de John Napier (1614) : Système de baquettes
coulissantes permettant de faire des multiplications.

En 1642, Blaise Pascal construit la Pascaline

En 1694, le mathématicien Gottfried Wilhelm Leibniz
construit la première machine à calculer utilisant des
cylindres cannelés

Vers 1800, le Français Joseph-Marie Jacquard met au point
un métier à tisser qui utilise des cartons perforés pour
commander les mouvements des aiguilles

Vers 1849, Charles babbage donne les plans de la machine
analytique, mais n’arrive pas à la construire

De 1939 à 1942, Alan Turing conçoit la ’Bombe’ qui permet
de décrypter Enigma
En 1945, il conçoit les plans du premier ordinateur
moderne, mais n’a pas les moyens de le réaliser

En 1945, aux Etats-Unis, naı̂t l’ENIAC (Electronic
Numerator Integrator and Computer), le premier véritable
ordinateur de l’histoire.
- il s’agit d’une machine électronique. Il n’y a plus de
rouages mécaniques ; l’information est transportée par
des électrons, des particules chargées d’électricité, qui se
déplacent très vite
- c’est une machine programmable. Cela signifie qu’on
peut enregistrer des instructions qui s’exécuteront sans
intervention de l’homme.

30 tonnes, 100m2, 17000 tubes à vides, des cafards
s’introduisent dans les tubes faussant les résultats, d’ou le
terme ’bug informatique’.

1953 : IBM lance son premier ordinateur commercial en
série : l’IBM 650.
........................ l’ère numérique commence .........

Ordinateur quantique:
1 qbit : α PILE + β FACE
Billet de loterie:
- Avant le tirage, billet de loterie = α GAIN + β PERTE
- Après le tirage, billet de loterie = GAIN ou PERTE

L’informatique et les mathématiques?
+ Calculateur puissant (simulation météo (équations
différentielles), traitement du signal (image-vidéo) transformée
de Fourier, bioinformatique (théorie des mots, combinatoire),
...)
+ Cryptographie (paiement sécurisé sur internet, carte
bancaire, système RSA issu de l’arithmétique)
+ Animation et reconstruction 3D (géométrie)
+ Quantique (matrice )
+ ...............

L’informatique? Algorithme
Algorithme (M. al-Khwarizmi - 780:850)
Un algorithme est une suite ordonnée d’instructions qui indique
la démarche à suivre pour résoudre un problème.
Exemple: Faire cuire un oeuf sur le plat
Acheter un oeuf; mettre de l’huile dans la poele; faire chauffer;
casser l’oeuf dans la poele; attendre 2 minutes.
Algorithmique
L’algorithmique est la science des algorithmes. (construction
d’algorithme, vérification de la validité, la robustesse, leur
réutilisabilité, la complexité et leur efficacité)

L’informatique? Programme
Programme
Il s’agit de la traduction d’un algorithme dans un langage
particulier. Un programme dépend donc du langage, et
également de la plateforme d’éxécution.
Programmation
C’est l’action qui consiste à rédiger un programme dans un
langage donné.

L’informatique? Compilation et Exécution
Compilation
C’est l’action qui consiste à traduire le programme en langage
compréhensible par l’ordinateur.
Interpréteur (en JAVA)
Un outil ayant pour tâche d’éxécuter un programme qui a été
compilé.

La programmation en Java
Installation de Java
http://www.oracle.com

La structure d’un programme java
public class monpremierprogramme // Nom du programme
{
public static void main (String[] args) //Programme principal
{
//declaration de variables
//instructions //commentaires
}
}
Comment Faire?
- Dans un fichier texte, taper le code ci-dessus
- Sauvegarder le fichier texte dans un fichier
monpremierprogramme.java
- Compiler le fichier: javac monpremierprogramme.java
(création du fichier monpremierprogramme.class)
- Exécuter le programme: java monpremierprogramme

Bit (binary digit)
0 ou 1: il s’agit de la plus petite unité d’information manipulable
par une machine
Octet (Byte en anglais)
Unité d’information composée de 8 bits
Unités standardisées
- 1 kilooctet (ko) = 1000 octets
- 1 megaoctet (Mo) = 106 octets
- 1 gigaoctet (Go) = 109 octets
- 1 tetraoctet (To) = 1012 octets
- 1 pétaoctet (Po) = 1015 octets

Représentation des entiers en binaire (division entière par
2)
1001101

Du binaire au décimal
Code binaire: 1001101
77 = 1.20
+ 0.21
+ 1.22
+ 1.23
+ 0.24
+ 0.25
+ 1.26
Avec 1, 2 ou 3 bits
- Avec un bit, on code les entiers 0 et 1
- Avec deux bits, on code les entiers 0, 1, 2 et 3
- Avec 3 bits, on code les entiers 0,1,2,3,4,5,6,7
- Avec n bits, on code les entiers compris entre 0 et 2n − 1

Comment coder un réels???? Exemple de 77,3
- Codage partie entière : 77 ←→ 1001101
- Codage partie non entière : 0.3←→ ????
0.3 ∗ 2 = 0.6
0.6 ∗ 2 = 1.2
0.2 ∗ 2 = 0.4
0.4 ∗ 2 = 0.8
0.8 ∗ 2 = 1.6
0.6 ∗ 2 = 1.2
... = ...
0.3 ←→ 0.0 1001 1001 1001 ...
Codage de 77.3
77.3 ←→ 1001101.0 1001 1001 1001 ...

Les types de données simples en Java

Les variables
Une variable est un contenant ayant un nom (identificateur) et
pouvant contenir une information des types précédents (int,
double, char, ...)
- C’est une boite ayant un nom et pouvant contenir une valeur
d’un seul type de données.
- Toute variable d’un programme doit être déclarée avant son
utilisation (en début de programme par exemple)
Déclaration d’une variable
Type de données Identificateur ;
Déclaration de la variable toto pouvant contenir un entier
int toto ;

Les opérateurs
L’addition, la soustraction, la multiplication, la division :
+, −, ∗, /
La division entière et le reste de la division entière : /, %
Les comparaisons : <, >, ==, <=, >=, ! =
Affectation : =
Le Non : !
Le ET logique : &&
Le Ou (exclusif) : ∧
Le Ou (Inclusif) : ||

Les opérations classiques
Une expression mathématique:
2x + 3y−1
5x+1
4x
ENJAVA
=⇒ (2 ∗ x + (3 ∗ y − 1)/(5 ∗ x + 1))/(4 ∗ x)
Reste de la division entière:
x mod 10
ENJAVA
=⇒ x%10
Division entière d’une variable entière a:
a
2
ENJAVA
=⇒ a/2

Affectation
C’est placer une valeur dans une variable
Comment faire:
Indiquer la valeur exacte à placer dans la variable toto de la
façon suivante:
toto = valeur à placer;
Examples
titi= 8 ; // place 8 dans la variable titi
toto= titi ; // place le contenu de titi dans la variable toto
toto= titi+5 ; // place la somme du contenu de titi avec 5 dans
toto
toto= toto+4 ; // place la somme du contenu de toto avec 4
dans toto

Les opérateurs booléens
Non : !
Ou exclusif : ∧ (Correspond au OU BIEN )
Ou inclusif : ||
Et : &&

Le type boolean
Le type boolean permet uniquement deux valeurs: true, false
Exercice: Donner une expression java
a = b
ENJAVA
=⇒ a == b
a ≥ b
ENJAVA
=⇒ a >= b
x ∈ [a, b]
ENJAVA
=⇒ x >= a && x <= b
x ∈]a, b]
ENJAVA
=⇒ x > a && x <= b
x ∈]a, b]∩[c, d[
ENJAVA
=⇒ (x > a&&x <= b) && (x >= c&&x < d)

Exercice: Donner une expression java
x ∈]a, b] ∪ [c, d[
ENJAVA
=⇒ (x > a&&x <= b) || (x >= c&&x < d)
[a, b] ⊂ [c, d]
ENJAVA
=⇒ a >= c && b <= d
x est une année bissextile lorsque x est un multiple de 4
mais pas de 100 OU BIEN x est un multiple de 400.
ENJAVA
=⇒ (x%4 == 0 && x%100! = 0) ∧ (x%400 == 0)

La négation d’une expression
* négation (Je fais un CM ET il fait beau) ↔ (je ne fais pas un
CM OU il ne fait pas beau)
* !(A && B) ↔ !A || !B
* négation (Je fais un CM OU je suis dans mon bureau) ↔ (je
ne fais pas un CM ET je ne suis pas dans mon bureau)
* !(A || B) ↔ !A && !B
Donner l’expression de la négation
On a vu que:
x ∈]a, b] ∪ [c, d[
ENJAVA
=⇒ (x > a&&x <= b) || (x >= c&&x < d)
x /
∈]a, b] ∪ [c, d[
ENJAVA
=⇒ (x ≤ a || x > b)&&(x < c || x >= d)

public class monpremierprogramme //Nom du programme
{
{
// Déclaration des variables
int toto, titi, tutu; // Déclare trois variables
boolean tyty; // Déclare une variable booléenne
// Instructions
toto= 4; // Met la valeur 4 dans toto
toto= toto+1; // Ajoute 1 au contenu de toto
titi= toto*4; // Met 4*5 dans titi
tutu= titi/3; // Met 20/3 dans tutu
tutu= titi % 3; // Met 20 % 3 dans tutu
tyty= false; // Met false dans tyty
tyty= tutu>=2 && tutu < 4; // Met true dans tyty
}
}

Echange du contenu de deux variables:
=⇒

=⇒
Etape 1: V = N

=⇒
Etape 1: V = N Etape 2: N = G

=⇒
Etape 1: V = N Etape 2: N = G Etape 3: G = V

public class echange //Nom du programme
{
{
// Déclaration des variables
int Nuits, Gevrey, Temp ; // Déclare trois variables
// Remplissage des verres
Nuits=4; // Remplit le verre de Nuits
Gevrey=8; // Remplit le verre de Gevrey
// Echange le contenu des deux verres
Temp=Nuits; // Verse le contenu de Nuits dans Temp
Nuits=Gevrey; // Verse le contenu de Gevrey dans Nuits
Gevrey=Temp; // Verse le contenu de Temp dans Gevrey
}
}

Communiquer avec l’ordinateur pendant l’éxécution du
programme
Affichage des résultats à l’écran (sortie)
Saisie d’informations au clavier (entrée)

La programmation en Java - Les sorties
Affichage à l’écran d’un texte
System.out.print("texte a afficher");
// Affiche le texte
System.out.println("texte a afficher");
// Affiche le texte puis revient à la ligne
Affichage à l’écran du contenu d’une variable
System.out.print(variable);
// Affiche le contenu de la variable
System.out.println(variable);
// Affiche le contenu de la variable puis revient à la ligne

Affichage à l’écran d’un texte et du contenu d’une variable
System.out.print("texte a afficher"+variable);
// Affiche le texte puis le contenu de la variable
System.out.println("texte a afficher"+variable);
// Affiche le texte puis le contenu de la variable et
// revient à la ligne
System.out.println("toto= "+toto);
//Affiche toto= 8
System.out.println("toto= "+toto+" et titi= "+titi);
// Affiche toto= 8 et titi= 4

{
{
int Nuits, Gevrey, Temp ;
System.out.println("Bonjour");
Nuits=4;
Gevrey=8;
Temp=Nuits;
Nuits=Gevrey;
Gevrey=Temp;
System.out.println("Le contenu de Nuits est:"+Nuits);
System.out.println("Le contenu de Gevrey est:"+Gevrey);
}
}

Un joli dessin!!!
public class jolidessin //Nom du programme
{
{
System.out.println("*******");
System.out.println(" ***** ");
System.out.println(" *** ");
System.out.println(" * ");
}
}

La programmation en Java - Les entrées
La saisie d’un entier dans la variable toto
int toto;
toto=Lire.i();
// attend que l’utilisateur saisisse un entier
La saisie d’un réel dans la variable titi
double titi;
titi=Lire.d();
// attend que l’utilisateur saisisse un réel
La saisie d’un texte dans une variable tutu
String tutu;
tutu=Lire.S();
// attend que l’utilisateur saisisse un texte

La programmation en Java - Les Entrées/Sorties
{
{
int Nuits, Gevrey, Temp ;
System.out.println("Saisir le contenu de Nuits");
Nuits=Lire.i();
System.out.println("Saisir le contenu de Gevrey");
Gevrey=Lire.i();
Temp=Nuits;
Nuits=Gevrey;
Gevrey=Temp;
System.out.println("Le contenu de Nuits est:"+Nuits);
System.out.println("Le contenu de Gevrey est:"+Gevrey);
}
}

Exercice - Les Entrées/Sorties
Moyenne de deux réels
Ecrire un programme Java permettant de faire la moyenne de
deux réels saisis par l’utilisateur.
public class moyenne //Nom du programme
{
{
double x, y, moyenne;
System.out.println("Saisir x");
x=Lire.d();
System.out.println("Saisir y");
y=Lire.d();
moyenne=(x+y)/2;
System.out.println("La moyenne est:"+moyenne);
}
}

Fiche Memo CM1- Les Entrées/Sorties
Le minimum à savoir!!!!
public class nomprog //Nom du programme
{
{
// Déclaration des variables utiles
}
}
1 ; à la fin de chaque instruction
2 Affectation: x=3;
3 Opérateurs booléen: &&, ||, ==,
x>= 1 && x<= 5, x==7 || y==8
4 Affichage à l’écran: System.out.println(”Bonjour”+variable);
5 Saisie au clavier: x=Lire.i(); y=Lire.d();

Exercice - Les Entrées/Sorties
Résolution de a ∗ x = b lorsque a 6= 0
Ecrire un programme Java permettant la saisie de a et b par
l’utilisateur, puis d’afficher la solution de l’équation.
public class moyenne //Nom du programme
{
{
// Déclaration des variables utiles
// Saisie de a et b
// Calcul de la solution
// Affichage de la solution
}
}

Les conditionnelles
Structures permettant de réaliser des aiguillages
if ...
if(condition)
{
// Bloc d’instructions
}
- Si la condition est vraie, le programme exécute les
instructions situées entre accolades
- Si la condition est fausse, le programme ne considère pas les
instructions et passe à la suite
Es-tu adulte?
// Déclaration et saisie d’un age
if(age>=18)
{System.out.println("Vous etes adultes");}

Les conditionnelles
x ∈ [1, 100]?
// Déclaration et saisie de $x$
if(x>=1 && x<=100)
{System.out.println(" x est entre 1 et 100");}
x ∈ [1, 100]?
if(x>=1 && x<=100)
{System.out.println(" x est entre 1 et 100");
x=x+1;
}
Si le bloc d’instructions dans le IF contient une seule instruction
alors les accolades sont facultatives

Les conditionnelles
if ... else ...
if(condition)
{
// Bloc d’instructions 1
}
else
{
// Bloc d’instructions 2
}
- Si la condition est vraie, le programme exécute les
instructions du bloc 1
- Si la condition est fausse, le programme exécute les
instructions du bloc 2

Les conditionnelles
x ∈ [1, 100]?
if(x>=1 && x<=100)
{System.out.println(" x est entre 1 et 100");}
else
{System.out.println(" x n est pas entre 1 et 100");}
x ∈ [1, 100]?
if(x>=1 && x<=100)
System.out.println(" x est entre 1 et 100");
else
System.out.println(" x n est pas entre 1 et 100");
Si le bloc d’instructions dans le IF contient une seule instruction
alors les accolades sont facultatives

Les conditionnelles
Maximum de deux entiers
public class maximum
{
public static void main (String[] args)
{
int x, y, maxi;
System.out.println("Saisir x");
x=Lire.i();
System.out.println("Saisir y");
y=Lire.i(); // Déclaration et saisie de x et y
if(x>y)
{maxi=x;}
else
{maxi=y;}
System.out.println("Le maximum est:"+maxi);
}
}

Les conditionnelles
Résolution équation ax+b=0
double a, b, x;
System.out.println("Saisir a");
a=Lire.d();
System.out.println("Saisir b");
b=Lire.d();
if(a!=0)
{ x=-b/a;
System.out.println("La solution est :"+x);
}
else
if(b==0)
System.out.println("Il y a une infinité de solutions");
else
System.out.println("Il n’y a pas de solution");
Le if ... else ... est considérée comme une seule instruction

Les conditionnelles
Classement par ordre croissant de trois entiers
//Déclaration et saisie de a, b et c
if(a<=b && b<=c)
System.out.println(a+"<="+b+"<="+c);
if(a<=c && c<=b)
System.out.println(a+"<="+c+"<="+b);
if(b<=a && a<=c)
System.out.println(b+"<="+a+"<="+c);
if(b<=c && c<=a)
System.out.println(b+"<="+c+"<="+a);
if(c<=a && a<=b)
System.out.println(c+"<="+a+"<="+b);
if(c<=b && b<=a)
System.out.println(c+"<="+b+"<="+a);

Les conditionnelles
Classement par ordre croissant de trois entiers
//Déclaration et saisie de a, b et c
if(a<=b)
if(b<=c)
System.out.println(a+"<="+b+"<="+c);
else
if(c<=a)
System.out.println(c+"<="+a+"<="+b);
else
System.out.println(a+"<="+c+"<="+b);
else
if(a<=c)
System.out.println(b+"<="+a+"<="+c);
else
if(c<=b)
System.out.println(c+"<="+b+"<="+a);
else
System.out.println(b+"<="+c+"<="+a);

Les conditionnelles
switch ...
switch(valeur)
{
case val1: { /*Bloc d’instructions B1*/ }
case val2: { /*Bloc d’instructions B2*/ }
...
case valn: { /*Bloc d’instructions Bn*/ }
}
- Si valeur vaut val1, le programme exécute B1, B2, ..., Bn
- Si valeur vaut val2, le programme exécute B2, ..., Bn
- ...
- Si valeur vaut valn, le programme exécute Bn
Attention
La variable valeur du switch doit être de type int ou char (pour
l’instant!!!)

Les conditionnelles
Affichage des derniers jours de la semaine
int jour;
System.out.println("Numéro de jour de la semaine?");
jour=Lire.i();
switch(jour)
{
case 1: { System.out.println("Lundi"); }
case 2: { System.out.println("Mardi"); }
case 3: { System.out.println("Mercredi"); }
case 4: { System.out.println("Jeudi"); }
case 5: { System.out.println("Vendredi"); }
case 6: { System.out.println("Samedi"); }
case 7: { System.out.println("Dimanche"); }
}
Si jour=5, alors le programme affiche Vendredi, Samedi et
Dimanche

Les conditionnelles
switch ...
switch(valeur)
{
case val1: { /*Instructions B1*/ break;}
case val2: { /*Instructions B2*/ break;}
...
case valn: { /*Instructions Bn*/ break;}
}
- Si valeur vaut val1, le programme exécute seulement B1
- Si valeur vaut val2, le programme exécute seulement B2
- ...
- Si valeur vaut valn, le programme exécute seulement Bn
L’instruction break permet d’arrêter l’exécution dans une
structure. Cette instruction sera permise UNIQUEMENT dans
un switch.

Les conditionnelles
Affichage du jour de la semaine
int jour;
System.out.println("Saisir le numéro de jour de la semaine");
jour=Lire.i();
switch(jour)
{
case 1: { System.out.println("Lundi"); break; }
case 2: { System.out.println("Mardi"); break; }
case 3: { System.out.println("Mercredi"); break; }
case 4: { System.out.println("Jeudi"); break; }
case 5: { System.out.println("Vendredi"); break; }
case 6: { System.out.println("Samedi"); break; }
case 7: { System.out.println("Dimanche"); break; }
}
Si jour=5, le programme affiche uniquement Vendredi

Les conditionnelles
Un mélange des deux syntaxes
int jour;
System.out.println("Saisir le numéro de jour de la semaine");
jour=Lire.i();
switch(jour)
{
case 1: { System.out.println("Lundi"); break; }
case 2: { System.out.println("Mardi"); break; }
case 3: { System.out.println("Mercredi"); break; }
case 4: { System.out.println("Jeudi"); }
case 5: { System.out.println("Vendredi"); }
case 6: { System.out.println("Samedi"); break; }
case 7: { System.out.println("Dimanche"); break; }
}
Si jour=4, le programme affiche Jeudi, Vendredi et Samedi

Les conditionnelles
Deux exercices!!!

Fiche Memo CM2- Les conditionnelles
if(condition)
{ ....}
if(condition)
{ ....}
else
{ ....}
switch(variable)
{
case val1: { ....; break;}
case val2: { ....; break;}
....
case valn: { ....; break;}
}

Les répétitions
Structures permettant de répéter des instructions
La boucle for(...)
for(initialisation; condition; incrémentation)
{ /* Instructions */ }
- L’initialisation permet de donner une valeur de départ à la
variable de boucle. C’est la première instruction exécutée.
- Condition est le test à vérifier pour pouvoir exécuter les
instructions de la boucle
- L’incrémentation est une instruction qui permet de modifier le
résultat de la condition ( i + +, ou i − −).

Les répétitions
Exemple : Afficher les 100 premiers entiers
for(i=1; i<=100; i++)
{ System.out.println(i); }

Les répétitions
Affichage de la somme des n premiers entiers
public class somme
{
{
int i, n, somme=0;
System.out.println("Saisir l’entier n");
n=Lire.i();
for(i=1; i<=n; i++)
somme=somme+i;
System.out.println("La somme est: "+somme);
}
}

Les répétitions
La boucle while(...)
while(condition)
- Tant que la condition est vraie (true), le programme exécute
les instructions de la boucle
* La condition est vérifiée avant d’exécuter les instructions
* Il est nécessaire de modifier la condition à l’intérieur de la
boucle pour que la boucle puisse s’arrêter

Les répétitions
Afficher les 100 premiers entiers
i=1;
while(i<=100)
{ System.out.println(i);
i=i+1; }

Les répétitions
public class somme
{
{
int i, n, somme=0;
n=Lire.i();
i=1;
while(i<=n)
{
somme=somme+i;
i=i+1;
}
}
}

Les répétitions
La boucle do ...while
do
while(conditions);
- Le programme exécute les instructions de la boucle, puis
vérifie ensuite la condition pour éventuellement continuer
* La condition est vérifiée après avoir exécuté les instructions
* Il est nécessaire de modifier la conditions à l’intérieur de la
boucle pour que la boucle puisse s’arreter

Les répétitions
Afficher les 100 premiers entiers
i=1;
do
{ System.out.println(i);
i=i+1; }
while(i<=100);

Les répétitions
public class somme
{
{
int i, n, somme=0;
n=Lire.i();
i=1;
do
{
somme=somme+i;
i=i+1;
}
while(i<=n);
}
}

Les répétitions
Saisie d’un entier positif ou nul
public class saisie
{
{
int n;
do
{
System.out.println("Saisir un entier positif ou nul");
n=Lire.i();
}
while(n<0);
}
}

Fiche Memo CM3- Les répétitions
for(i=1;i<=100;i++) // Pour i allant de 1
{ ....} // jusqu’à 100 faire ....
for(i=100;i>=1;i--) // Pour i allant de 100
{ ....} // jusqu’à 1 faire ....
while(condition) // Tant que la condition
{ ....} // est vraie faire ....
do // Faire .... jusqu’à ce que
{....} // la condition soit fausse
while(condition);

Les répétitions
Affichage du produit des n premiers entiers positifs
public class produit
{
{
int i, n, produit=1;
n=Lire.i();
for(i=1; i<=n; i++)
produit=produit*i;
System.out.println("Le produit est: "+produit);
}
}

Les répétitions
{
{
n=Lire.i();
i=1;
while(i<=n)
{
produit=produit*i;
i=i+1;
}
}
}

Les répétitions
{
{
n=Lire.i();
i=1;
do
{
produit=produit*i;
i=i+1;
}
while(i<=n);
}
}

Les répétitions - Exercice
Somme d’une suite de notes
Programme qui calcule la somme d’une suite de notes saisies
au clavier jusqu’à ce que la note -1 soit entrée.
public class moyenne
{
{
int note, somme=0;
do
{
System.out.println("Saisir une note ou -1");
note=Lire.i();
if(note!=-1)
somme=somme+note;
}
while(note!=-1);
System.out.println("La somme des notes est: "+somme);
}
}

Un joli dessin!!!
Afficher le motif suivant dont la taille est saisie par l’utilisateur.
Pour taile=3 Pour taille=4 Pour taille=5
* * *
** ** **
*** *** ***
**** ****
*****
int i,j,taille;
System.out.println("Saisir la taille du dessin");
taille=Lire.i(); // Saisie de la taille
for(i=1;i<=taille;i++) // Boucle décrivant les lignes
{ for(j=1;j<=i;j++) // Boucle décrivant les colonnes
System.out.print("*"); // Affichage *
System.out.println(); // Retour à la ligne
}

Un joli dessin!!!
Afficher le motif suivant dont la taille est saisie par l’utilisateur.
Pour taile=3 Pour taille=4 Pour taille=5
*** **** *****
** *** ****
* ** ***
* **
*
int i,j,taille;
//Saisie de la taille
for(i=1;i<=taille;i++) //Boucle décrivant les lignes
{ for(j=1;j<=taille;j++) //Boucle décrivant les colonnes
if(j<i)
System.out.print(" "); // Affichage espaces
else
System.out.print("*"); // Affichage étoiles
}

Exemple de menu
int x,y,z,choix;
char op;
do
{
System.out.println("1. Saisir x");
System.out.println("2. Saisir y");
System.out.println("3. Calculer la somme");
System.out.println("4. Quitter");
System.out.println("Quel est votre choix");
choix=Lire.i();
switch(choix)
{
case 1: { x=Lire.i(); break;}
case 2: { y=Lire.i(); break;}
case 3: { z=x+y; break;}
}
}
while(choix!=4);

L’algorithme d’Euclide - Calcul du PGCD
Méthode:
Si a ≥ b alors PGCD(a, b) =
- b si b divise a (a%b == 0),
- PGCD(b, r) où r est le reste de la division de a par b
(r = a%b)

// Déclaration et saisie de a et b
// Echange de a et b si b>a
while(b>0)
{
r=a% b;
a=b;
b=r;
}
System.out.println("Le PGCD est "+a);

// Déclaration et saisie de a et b
// Echange de a et b si b>a
do
{
r=a% b;
a=b;
b=r;
}
while(b>0);
System.out.println("Le PGCD est "+a);

Recherche d’un entier entre 1 et 100
Ecrire un prog permettant de rechercher un nombre aléatoire
entre 1 et 100 généré par l’ordinateur.
Réel aléatoire entre 0 inclu et 1 exclu: Math.random()
Réel aléatoire entre 0 inclu et b exclu: b*Math.random()
Réel aléatoire entre a inclu et b exclu:
a+(b-a)*Math.random()
Entier aléatoire entre a inclu et b-1 inclu:
(int)(a+(b-a)*Math.random())

Idée: Saisir un nombre tant que le nombre saisi n’est pas celui
de l’ordinateur
int ordi, joueur;
ordi=(int)(1+100*Math.random());
do
{
System.out.println("Proposer votre nombre");
joueur=Lire.i();
}
while(joueur!=ordi);
System.out.println("Bravo, vous avez trouvé");

Une amélioration du jeu: A chaque étape l’ordinateur devra
dire si votre nombre est trop grand ou trop petit
int ordi, joueur;
do
{
joueur=Lire.i();
if(joueur>ordi)
System.out.println("Votre nbre est trop grand");
if(joueur<ordi)
System.out.println("Votre nbre est trop petit");
}
System.out.println("Bravo, vous avez trouvé");

Encore une amélioration: Indiquer le nbre de coups utilisés
pour gagner
int ordi, joueur, coups;
coups=0;
do
{
joueur=Lire.i();
coups=coups+1;
if(joueur>ordi)
if(joueur<ordi)
}
System.out.println("Bravo, vous avez trouvé en "+coups+"coups")

Encore une amélioration: Limiter le nbre de coups à 7 coups
int ordi, joueur, coups;
coups=0;
do
{System.out.println("Proposer votre nombre");
joueur=Lire.i();
coups=coups+1;
if(joueur>ordi)
if(joueur<ordi)
}
while(joueur!=ordi && coups<7);
if(joueur==ordi)
System.out.println("Bravo, vous avez trouvé en "+coups+"coups"
else
System.out.println("Perdu");

Exercice

Les tableaux
Un tableau est une structure qui peut contenir plusieurs
éléments du même type
Le nombre d’éléments du tableau est la taille du tableau
Les éléments sont repérés par un ou plusieurs indices de
type int (ou char)
Le nombre d’indices est la dimension du tableau
Tableau à 1 dimension de taille 10 contenant des entiers
1 3 5 7 9 0 2 4 6 8
0 1 2 3 4 5 6 7 8 9 Indices du tableau
Tableau à 2 dimensions à 2 lignes et 10 colonnes
1 3 5 7 9 0 2 4 6 8
0 2 4 6 8 1 3 5 7 9
0
1

Les tableaux
Déclaration d’un tableau
Réserve une adresse mémoire
Tableau 1D: Type des éléments tab[];
Tableau 2D: Type des éléments tab[][];
Création d’un tableau
Définit la taille du tableau
Tableau 1D: tab=new Type des éléments[Nbre cases];
Tableau 2D: tab=new Type des éléments[nblig][nbcol];
Déclaration et allocation de tableaux
int tab[]; // Déclaration tableau 1D d’entiers
tab= new int[10]; // Définition de la taille du tableau
//*************************************
double tab[][]; // Déclaration tableau 2D
tab= new double[2][10]; // Définition de la taille

Les tableaux
Accès à la i-ième case d’un tableau 1D: tab[i-1]
1 3 5 7 9 0 2 4 6 8
0 1 2 3 4 5 6 7 8 9 Indices i
Remplissage d’un tableau 1D
tab[0]=1;
tab[1]=3;
tab[2]=5;
...
tab[9]=8;

Les tableaux
for(i=0;i<=9;i++) //Boucle pour parcourir les cases
{ System.out.println("Saisir la case "+i);
tab[i]=Lire.i();
}
Affichage d’un tableau 1D
for(i=0;i<=9;i++)
System.out.print(tab[i]+" ");
System.out.println();

Les tableaux
Accès à la case d’un tableau 2D sur la i-ième ligne et j-ième
colonne : tab[i-1][j-1]
1 3 5 7 9 0 2 4 6 8
0 2 4 6 8 1 3 5 7 9
0
1
int tab[][]; // Déclaration tableau 2D d’entiers
tab= new int[2][10]; // Définition de la taille du tableau
tab[0][0]=1; tab[1][0]=0;
tab[0][1]=3; tab[1][1]=2;
tab[0][2]=5; tab[1][2]=4;
........ ........
tab[0][9]=8; tab[1][9]=9;

Les tableaux
int tab[][]; // Déclaration tableau 1D d’entiers
tab= new int[2][10]; // Définition de la taille du tableau
for(i=0;i<=1;i++) // Boucle pour décrire les 2 lignes
for(j=0;j<=9;j++) // Boucle pour décrire les 10 colonnes
{ System.out.println("Saisir ligne "+i+" et colonne "+j);
tab[i][j]=Lire.i();
}
Affichage d’un tableau 2D
for(i=0;i<=1;i++) // Boucle pour décrire les 2 lignes
{ for(j=0;j<=9;j++) // Boucle pour décrire les 10 colonnes
System.out.print(tab[i][j]+" ");
}

Les tableaux
1 3 5 7 9 .... 2 4 6 8
Recherche d’un élément dans un tableau 1D
int i,element,tab[];
// Déclaration tableau 1D d’entiers
.......... // Remplissage du tableau
System.out.println("Entrer l’élément à rechercher");
element=Lire.i();
for(i=0;i<=99;i++) // Boucle pour décrire les 100 cases
if(tab[i]==element)
System.out.println("Trouvé");

Les tableaux
Recherche d’un élément dans un tableau 1D
boolean trouve;
int i,element,tab[]; // Déclaration tableau 1D d’entiers
System.out.println("Entrer l’élément à rechercher");
element=Lire.i();
trouve=false;
i=0;
while(i<=99 && trouve==false)
{ if(tab[i]==element)
trouve=true;
else
i=i+1;
}
if(trouve==true)
System.out.println(element+" est trouvé en position "+i);
else
System.out.println(element+" n est pas dans le tableau");

Les tableaux
1 3 5 7 9 .... 2 4 6 8
Recherche du maximum d’un tableau 1D
int i,maxi,tab[];
maxi=tab[0];
for(i=1;i<=99;i++) // Boucle pour décrire le tableau
if(tab[i]>maxi)
maxi=tab[i];
System.out.println("Le maximum du tableau est "+maxi);

Les tableaux
1 3 5 7 9 .... 2 4 6 8
Recherche de la position du maximum d’un tableau 1D
int i,maxi,posi,tab[];
maxi=tab[0];
posi=0;
for(i=1;i<=99;i++) // Boucle pour décrire le tableau
if(tab[i]>maxi)
{maxi=tab[i]; posi=i;}
System.out.println("La position du maximum du tableau est "+p

Les tableaux
Tri à bulles d’un tableau 1D
Video.Tri.à.bulles.mp4

Les tableaux
bool tab_en_ordre = false;
int taille = tab.length; //donne le nbre de cases du tablea
while(!tab_en_ordre)
{
tab_en_ordre = true;
for(int i=0 ; i < taille-1 ; i++)
if(tab[i] > tab[i+1])
{ //échange de tab[i] et tab[i+1]
tab_en_ordre = false;
}
taille--;
}

Les tableaux
bool tab_en_ordre;
int taille = tab.length;
do
{
tab_en_ordre = true;
if(tab[i] > tab[i+1])
{ //échange de tab[i] et tab[i+1]
tab_en_ordre = false;
}
taille--;
}
while(!tab_en_ordre);

Les tableaux
Tri par insertion d’un tableau 1D
Video.Tri.par.insertion.mp4

Les tableaux
Tri par insertion d’un tableau 1D
int taille = tab.length; //donne le nbre de cases du tablea
{ k=i;
while(k>=0 && tab[k]>tab[k+1])
{
//échanger tab[k] et tab[k+1]
k=k-1;
}
}

Fiche Memo CM5- Les tableaux
int tab[],i;
tab=new int[100]; // Déclaration tableau 1D d’entiers
for(i=0;i<=99;i++) // Affichage
System.out.print(tab[i]+" ");
int tab[][],i,j;
tab=new int[100][50]; // Déclaration tableau 2D d’entiers
for(i=0;i<=99;i++) // Affichage
{ for(j=0;j<=49;j++)
System.out.print(tab[i][j]+" ");
}

Les chaı̂nes de caractères
Une chaı̂ne de caractères (de type String) est une suite
ordonnée de caractères (de type char): Exemple:
”abcdefghijk000lmnopqrst123uvwxyz” est une chaı̂ne de
caractères (entourée de guillemets ”...”)
Rappel:
- Un caractère est stocké dans une variable de type char.
Exemple: char car=’e’; (entouré de ’...’) - les caractères sont
classés par le code ASCII
Déclaration d’une chaı̂ne de caractères
String nom variable;
Déclaration
String chaine;

La table ASCII

Une chaı̂ne de caractères (de type String) est une suite
ordonnée de caractères (de type char): Exemple:
”abcdefghijk000lmnopqrst123uvwxyz” est une chaı̂ne de
caractères (entourée de guillemets ”...”)
Déclaration d’une chaı̂ne de caractères
String nom variable;
Déclaration
String chaine;
Déclaration d’une chaı̂ne vide
String chaine=""; // Deux guillements consécutifs
// (sans espace)

Affectation
variable=”texte”;
Affectation
String chaine1,chaine2,chaine3;
chaine1="Bonjour";
chaine2=""; // Chaine vide
chaine3=chaine1;
Affichage d’une chaı̂ne
String chaine1;
chaine1="Bonjour";
System.out.printl(chaine1);

nombre de caractères d’une chaı̂ne (ou longueur)
variable.length()
Longueur d’une chaine
int longueur;
String chaine;
chaine="Bonjour";
longueur=chaine.length(); //Nombre de caractères
System.out.println("Il y a "+longueur+" caractères dans la ch

i-ième caractère d’une chaı̂ne
variable.charAt(i-1) (de type char)
variable.charAt(0) est le premier caractère de la chaı̂ne variable
variable.charAt(1) est le second caractère de la chaı̂ne variable
i-ième caractère d’une chaı̂ne
char c;
String chaine;
chaine="Bonjour";
c=chaine.charAt(3);
System.out.println("le 4-ième caractère est"+c);

Juxtaposition de deux chaı̂nes (concaténation)
chaine1+chaine2
Juxtaposition de deux chaı̂nes
String chaine1,chaine2,chaine3,chaine4;
chaine1="Bonjour";
chaine2=" jourBon";
chaine3=chaine1+chaine2;
System.out.println(chaine3);// Affiche Bonjour jourBon
chaine4=chaine2+chaine1;
System.out.println(chaine4);// Affiche jourBonBonjour

Test d’égalité de deux chaı̂nes
chaine1.equals(chaine2) renvoie true si les contenus sont
égaux, et false sinon
Test d’égalité de deux chaı̂nes
String chaine1,chaine2;
chaine1="Bonjour";
chaine2="Bonjour";
// A NE PAS FAIRE
if(chaine1==chaine2)
System.out.println("les adresses sont égales");
// A FAIRE
if(chaine1.equals(chaine2))
System.out.println("les contenus des chaines sont égaux");

Les méthodes

Suppression des ’a’ dans une chaı̂ne
int i, longueur;
longueur=chaine1.length();
chaine2="";
for(i=0;i<=longueur-1;i++)
if(chaine1.charAt(i)!=’a’)
chaine2=chaine2+chaine1.charAt(i);
System.out.println(chaine2);

Remplacement des ’a’ par des ’o’ dans une chaı̂ne
int i, longueur;
longueur=chaine1.length();
chaine2="";
for(i=0;i<=longueur-1;i++)
if(chaine1.charAt(i)!=’a’)
chaine2=chaine2+chaine1.charAt(i);
else
chaine2=chaine2+’o’;
System.out.println(chaine2);

Les fonctions
Une fonction est un bout de code qui a un nom et qui peut
être appelée depuis le reste du programme.
Exemples de fonctions prédéfinies: Math.pow(a,b),
Math.abs(a), Math.random(), Math.sqrt(a), ...
Intérêts des fonctions
Meilleure lisibilité et concision (évite d’écrire plusieurs fois
le même code
Niveau d’abstraction plus élevé (un nom remplace une
partie complexe du programme)
Gain de place mémoire
Modification plus aisée
Partage de fonctions (biibliothèque de fonction)
Récursivité

Déclaration d’une fonction
On déclare une fonction à l’extérieur du main mais à l’intérieur
de class. Je conseille de les déclarer juste après le programme
principal.
public class programme
{
public static void main(String args[])
{
// Programme principal
}
// Déclaration des fonctions
}

Deux types de fonction
Fonction qui renvoie une valeur (Math.sqrt(),
Math.random(), périmètre(), moyenne(),...)
Fonction qui ne renvoie pas une valeur (affichage d’un
tableau, ...)

Déclaration d’une fonction qui renvoie une valeur
public static type Nomfonction(paramètres formels)
{ //instructions de la fonction
return valeurrenvoyée; }
* type est le type de la valeur renvoyée
* Nomfonction est le nom de la fonction
* Paramètres formels sont les données nécessaires pour la
déclaration de la fonction (ils restent donc sans valeur)
Appel de la fonction
variable=Nomfonction(parametres effectifs);
//renvoie la valeur de la fonction
* Les paramères effectifs sont les paramètres sur lesquels la
fonction est exécutée
* Lors de l’exécution les paramètres formels sont
remplacés par les paramètres effectifs

Les fonctions
Fonction qui renvoie le maximum de deux entiers
public static int maximum(int a, int b)
{int maxi; // Variable locale
if(a>b)
maxi=a;
else
maxi=b;
return maxi; // Renvoie le maximum de a et b
}
Les variables locales sont connues seulement dans la
fonction
Appel de la fonction qui renvoie le maximum de deux entiers
int x=1,y=2,max;
max=maximum(x,y); // Appel de la fonction sur x et y
System.out.println(max); // affichage de 2

Les fonctions
Fonction qui renvoie la moyenne de 2 réèls
public static double moyenne(double a, double b)
{double moy; // Variable locale
moy=(a+b)/2;
return moy; // Renvoie la moyenne de a et b
}
Appel de la fonction qui renvoie la moyenne
double x=1.5,y=2.5,moy;
moy=moyenne(x,y); // Appel de la fonction sur x et y
System.out.println(moy); // affichage la moyenne
Il y a ici deux variables moy !!!!!!!!!!!

Les fonctions
Déclaration d’une fonction qui ne renvoie pas de valeur
public static void Nomfonction(paramètres formels)
{
//instructions de la fonction
//il n’y a pas le return
}
Nomfonction(parametres effectifs);
// C’est une instruction qui ne renvoie pas de valeur
// Elle se contente d’exécuter les instructions de la fonction

Les fonctions
Fonction qui affiche le maximum de deux entiers (sans le
renvoyer)
public static void maximum(int a, int b)
{int maxi; // Variable locale
if(a>b)
maxi=a;
else
maxi=b;
System.out.println("Le max de "+a+" et "+b+" est: "+maxi);
// Affiche le maximum de a et b
}
Appel de la fonction qui affiche le maximum de deux entiers
int x,y;
x=1;
y=2;
maximum(x,y); // Appel de la fonction sur x et y

Les fonctions
Peut-on modifier un paramètre de fonction?
-Les paramètres de types int, char, double, boolean, String
ne peuvent pas être modifiés au cours de l’exécution d’une
fonction.
On dit que les paramètres sont passés par valeur.
-Les paramètres de types tableaux 1D ou 2D peuvent être
modifiés.
On dit que les paramètres sont passés par références (ou
variable).

Les fonctions
Tentative de modification d’un paramètre passé par valeur
public static int ajoutun(int a)
{ a=a+1;
return a;
}
int x;
x=1;
y=ajoutun(x); // Appel de la fonction sur x
// A la fin, y=2 et x=1

Les fonctions
Tentative de modification d’un paramètre passé par valeur
public static int ajoutun(int a)
{ a=a+1;
return a;
}
int x;
x=1;
x=ajoutun(x); // Appel de la fonction sur x
// A la fin, x=2 Ici la modification est réalisée
// (mais c’est en trichant!!!)

Les fonctions
Modification d’un paramètre passé par référence
public static void modif(int tab[])
{ tab[0]=1;
tab[1]=2;
tab[2]=3;
}
int T[];
T=new int[3];
T[0]=0;T[1]=1;T[2]=2;
modif(T); // Appel de la fonction sur T
// A la fin, T[0]=1 et T[1]=2 et T[2]=3

Les fonctions - La récursivité
Une fonction est récursive si elle s’appelle elle même.
Il y a toujours un cas de base sans appel récursif, et le cas
général où intervient la récursivité.
Fonction récursive pour calculer n! = (n-1)! * n
public static int facto(int n)
{
if(n==0)
return 1; // Cas de base
else
return n*facto(n-1); // Cas général de la récursivité
}
Appel de facto
int n,resu;
n=10;
resu=facto(n); // Appel de la fonction récursive facto

Partant d’un couple de lapins, combien de couples obtiendrons-nous après un nombre donné de mois sachant que
chaque couple produit chaque mois un nouveau couple, lequel ne devient productif qu’après deux mois.
Fonction récursive pour calculer les nombres de Fibonacci
f0 = 1, f1 = 1, fn = fn−1 + fn−2
public static int fibo(int n)
{
if(n==0 || n==1)
else
return fibo(n-1)+fibo(n-2); // Cas général
}
Appel de fibo
int n,resu;
n=10;
resu=fibo(n); // Appel de la fonction récursive fibo

Fonction récursive pour calculer les coefficients binomiaux
Ck
n = Ck−1
n−1 + Ck
n−1
public static int coeff(int n,int k)
{
if(k==0 || k==n)
else
return coeff(n-1,k-1)+coeff(n-1,k); // Cas général
}
Appel de coeff
int n,k,resu;
n=10;k=3;
resu=fibo(n,k); // Appel de la fonction récursive coeff

coursjavaDiapo.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à coursjavaDiapo.pdf

Similaire à coursjavaDiapo.pdf (20)

coursjavaDiapo.pdf