Algorithmique et initiation à la programmation Java

DEUST 2
Rattrapage java
O. Auzende
2010 - 2011

2
1. INTRODUCTION .................................................................................................... 3
2. ELEMENTS DE PROGRAMMATION JAVA .......................................................... 3
Notion de variable ................................................................................................................................................. 3
Affectation ............................................................................................................................................................. 3
Types de données primitifs en Java ..................................................................................................................... 4
Exercices ................................................................................................................................................................ 5
Test if … else .......................................................................................................................................................... 5
Exercices ................................................................................................................................................................ 5
Tableaux ................................................................................................................................................................. 6
Boucles ................................................................................................................................................................... 6
Sauts ....................................................................................................................................................................... 8
Exercices ................................................................................................................................................................ 8
3. JAVA, LANGAGE A OBJETS ............................................................................... 9
Classes et instances ................................................................................................................................................ 9
Attributs et méthodes d’instances ...................................................................................................................... 11
Attributs et méthodes de classes ........................................................................................................................ 11
4. LES PAQUETAGES JAVA .................................................................................. 12
Qu’est-ce qu’un paquetage ? .............................................................................................................................. 12
java.lang ............................................................................................................................................................... 12
Exercices .............................................................................................................................................................. 13
java.util ................................................................................................................................................................ 13
Exercices .............................................................................................................................................................. 13
La notion d’héritage ............................................................................................................................................ 15
Les interfaces ....................................................................................................................................................... 15
Les classes d’exceptions ...................................................................................................................................... 15
Exercices .............................................................................................................................................................. 15

Langage à Objets : Java
3
1. Introduction
Java est un langage de programmation, développé par la société SUN depuis 1995 pour assurer la portabilité
des programmes sur une large gamme de machines.
La plupart des langages de programmation ne permettent pas d’écrire des applications (non destinées au Web)
portables : en effet, les applications ne peuvent être exécutées que sur un seul système d’exploitation, celui de
la machine sur laquelle les codes sources ont été compilés (exemples : les applications C, C++, Fortran, Pascal).
Pour assurer la portabilité des applications java, le code source d’une application est transformé par un
compilateur appelé javac en un « pseudo-code » non exécutable, qui est le même quel que soit le système
d’exploitation de l’ordinateur sur lequel on travaille.
Transféré sur un autre système d’exploitation, le pseudo-code est lu par un interpréteur appelé java, qui ne
vérifie plus la syntaxe des instructions mais exécute directement le pseudo-code.
Les applications java sont alors portables.
Schéma :
SUN fournit un ensemble compilateur + interpréteur + librairies d’utilitaires pour chaque système
d’exploitation.
2. Eléments de programmation Java
Notion de variable
La notion de variable en informatique est assez proche de la notion mathématique.
En mathématiques, x = 5 veut dire que la variable x vaut 5.
En informatique, x est le contenu d’un emplacement-mémoire dont la taille (nombre de bits qui composent cet
emplacement) dépend de ce qu’on veut y stocker (un caractère prend moins de place qu’un entier, un entier
prend moins de place qu’un réel…). Le contenu de cet emplacement-mémoire peut constamment être changé.
On précise donc (syntaxe java) :
int x ; (réservation de place-mémoire pour un entier)
x = 5 ; (on y met la valeur 5)
x = 7 ; (on remplace 5 par 7 dans le même emplacement mémoire)
float y ; (réservation de place-mémoire pour un réel)
y = 3.5 ; (on y met la valeur 3.5)
Ces lignes peuvent être résumées en :
int x = 5 ; x = 7 ; (réservation de place-mémoire pour un entier. On y met la valeur 5 puis 7)
float y = 3.5 ; (réservation de place-mémoire pour un réel et on y met la valeur 3.5)
Affectation
Les instructions x = 5 ; x = 7 ; y = 3.5 ; donnent des valeurs aux emplacements-mémoire x et y.
Ces instructions sont appelées des affectations.
L’écriture a = b correspond à a  b et doit se lire a “reçoit” la valeur de b.

4
On peut affecter à une variable x :
o une valeur : x = 5 ;
o la valeur d’une autre variable : y = 3 ; x = y ;
o le résultat du calcul d’une expression : y = 3 ; z = 4 ; x = y + z ;
Types de données primitifs en Java
En Java, il y a 8 types de données primitifs. Ce sont les types :
o boolean : true et false
o char : caractère
o byte : petit entier stocké sur 8 bits
o short : entier court stocké sur 16 bits
o int : entier “normal” stocké sur 32 bits
o long : entier long stocké sur 64 bits
o float : réel simple stocké sur 32 bits
o double : réel double précision stocké sur 64 bits
L’instruction boolean fini = false ; définit une variable fini de type booléen et de valeur false.
L’instruction int i = 254256 ; définit une variable i de type entier, stockée sur 32 bits et de valeur
254256.
L’instruction long l = 25425645987 ; définit une variable l de type entier long, stockée sur 64 bits et de
valeur 25425645987.
L’instruction float f = 156.256 ; définit une variable f de type flottant, stockée sur 32 bits et de valeur
156.256.
L’instruction double t = 1/3 ; définit une variable t de type réel, stockée sur 64 bits et de valeur
0.333333333…
Opérateurs de cast
L’opérateur de “cast” force la conversion d’un type de données en un autre. Selon le cas, on peut perdre de la
précision.
Exemples :
float f = 156.256 ; int j = (int) f ;  j est alors un entier valant 156
double t = 1/3; float d = (float) t;  t est stocké sur 64 bits, d est stocké sur 32 bits
Première application Java
Ouvrez avec WordPad ou le bloc-notes le fichier Programme.java (attention, première lettre en majuscule) qui
se trouve dans le dossier programme. Comme tous les fichiers source java, c’est un fichier sauvegardé en
format texte uniquement
. Son contenu est :
public class Programme {
public static void main(String args[]) {
int a=25;
int b=76;
System.out.println("a vaut : " + a);
System.out.println("b vaut : " + b);
}
}
Tout programme java est nécessairement contenu dans une classe. Lorsque le programme ne comporte qu’une
seule classe, celle-ci doit être déclarée public afin d’être accessible à tout utilisateur.
Le programme proprement dit figure dans une méthode appelée main nécessairement déclarée sous la forme :
public static void main(String[] args) . Tout programme contenant une méthode main est une application.
Remarques
o static indique que main est une méthode de classe (il y a d’autres types de méthodes)
o String[] args permet de passer des informations à la méthode main, sous forme d’un tableau de
chaînes de caractères de type String[]. On utilise cette possibilité quand on veut passer des paramètres à la
méthode main.
o System.out.println(chaîne) fait afficher à l’écran la chaîne de caractères. Pour construire une
chaîne à partir de plusieurs morceaux, on concatène les morceaux en utilisant le signe +

Langage à Objets : Java
5
Compilation : commande javac Programme.java (création du pseudo-code)
Exécution : commande java Programme (interpréation du pseudo-code)
Exercices
o Ajoutez au main de la classe Programme les lignes permettant de déclarer deux entiers c et d, de calculer
c=a+b et d=a*b, puis de faire afficher les valeurs de c et de d. Compilez et faites exécuter le fichier ainsi
modifié.
o On voudrait à présent que a, b, c et d puissent être des réels de type primitif double et non plus des entiers.
Modifiez la classe Programme en conséquence, en prenant cette fois a=4.56 et b=-8.65. Compilez le fichier
Programme.java ainsi modifié et faites-le exécuter.
o On veut faire afficher en fin de programme « valeur entiere de d : » puis la partie entière de d. Utilisez un
opérateur de cast pour obtenir ce résultat. Compilez le fichier Programme.java ainsi modifié et faites-le
exécuter.
Test if … else
Il permet de faire des traitements différenciés.
Il s’écrit :
if (test) {
instructions;
}
else {
instructions;
}
La clause else est facultative.
On peut avoir simplement :
if (test) {
instructions ;
}
Exemple : fichier Programme1.java du dossier programme1. Deux nombres a et b sont tirés au sort entre 1 et
100, et on veut connaître le plus petit des deux.
import java.util.Random ;
public class Programme1 {
public static void main(String[] args) {
int a = new Random().nextInt(100) ; int b = new Random().nextInt(100) ;
System.out.println("a = " + a);
System.out.println("b = " + b);
int min ;
if (a < b) { min = a; }
else { min = b; }
System.out.println("le minimum de a et b est " + min);
}
}
Egalité, inégalité
Le symbole = étant réservé à l’affectation, on teste l’égalité
if (a == b) … qui se lit : si (a = b) ... de deux variables a et b en écrivant :
On teste l’inégalité
if (a != b) … qui se lit : si (a ≠ b) ...
de deux variables a et b en écrivant :
Conjonction, disjonction
La conjonction
Ainsi, tester si (a=b) et (c=d) s’écrit : if ((a==b) && (c==d))
ET s’écrit &&
La disjonction
Ainsi, tester si (a=b) ou (c=d) s’écrit : if ((a == b) | | (c == d))
OU s’écrit | |
Exercices
1) Transformez le fichier Programme1.java de la manière suivante et complétez-le afin qu’il affiche le
minimum de TROIS nombres a, b et c :
import java.util.Random ;
public class Programme1 {
public static void main(String[] args) {
int a = new Random().nextInt(100) ;
int b = new Random().nextInt(100) ;
int c = new Random().nextInt(100) ;