Algorithmique et initiation à la programmation Java

Transcription

DEUST 2
Rattrapage java
O. Auzende
2010 - 2011
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
2
Langage à Objets : Java
1. Introduction
Java est un langage de programmation, développé par la société SUN depuis 1995 pour assurer la por tabilité
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)
por tables : 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 inter pr éteur appelé java, qui ne
vérifie plus la syntaxe des instructions mais exécute directement le pseudo-code.
Les applications java sont alors por tables.
Schéma :
SUN fournit un ensemble compilateur + inter pr éteur + libr air ies d’utilitair es pour chaque système
d’exploitation.
2. Eléments de programmation Java
Notion de variable
La notion de var iable 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 ;
x = 5 ;
x = 7 ;
float y ;
y = 3.5 ;
(réservation de place-mémoire pour un entier)
(on y met la valeur 5)
(on remplace 5 par 7 dans le même emplacement mémoire)
(réservation de place-mémoire pour un réel)
(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 “r eçoit” la valeur de b.
3
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
o
o
o
o
o
o
o
boolean
char
byte
short
int
long
float
double
: true et false
: caractère
: petit entier stocké sur 8 bits
: entier court stocké sur 16 bits
: entier “normal” stocké sur 32 bits
: entier long stocké sur 64 bits
: réel simple stocké sur 32 bits
: 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 conver sion 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 +
4
Compilation : commande javac Programme.java (création du pseudo-code)
Exécution : commande java Programme (interpréation du pseudo-code)
Exercices
o
o
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é.
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.
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é de deux variables a et b en écrivant :
if (a == b) … qui se lit : si (a = b) ...
On teste l’inégalité de deux variables a et b en écrivant :
if (a != b) … qui se lit : si (a ≠ b) ...
Conjonction, disjonction
La conjonction ET s’écrit &&
Ainsi, tester si (a=b) et (c=d) s’écrit : if
((a==b)
&& (c==d))
La disjonction OU s’écrit | |
Ainsi, tester si (a=b) ou (c=d) s’écrit : if ((a == b) | | (c == d))
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 :
public class Programme1 {
public static void
int a = new
int b = new
int c = new
main(String[] args) {
Random().nextInt(100) ;
5
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
int min ;
if ...
// détermination du minimum de a,b et c
System.out.println("le minimum de a, b et c est " + min);
}
}
2) Ecrivez un programme qui génère aléatoirement trois nombres a, b et c entre 1 et 50 et qui dit si l’un de ces
trois nombres est supérieur à 45.
Tableaux
Les tableaux sont des collections de variables de même type, en nombr e fixé.
On doit d’abord les déclar er , puis faire l’allocation de mémoir e nécessair e avant de les utiliser.
Exemples :
int [] t ;
t = new int[20] ;
char [] tab ;
tab = new char[40] ;
String [] t1 ;
t1 = new String[10] ;
//
//
//
//
//
//
déclaration
création de
déclaration
création de
déclaration
création de
d’un tableau d’entiers t
t en mémoire
d’un tableau tab de caractères
tab en mémoire
d’un tableau t1 de chaînes
t1 en mémoire
On accède à l’élément d’indice i de t par t[i], les indices commençant à 0.
Une fois qu’un tableau est créé, sa taille ne peut plus êtr e changée.
Exemple : Tableau.java, du dossier tableau, crée un tableau des mois de l’année et le fait afficher.
public class Tableau {
String[] t = new String[12] ;
t[0]="janvier"; t[1]="fevrier"; t[2]="mars"; t[3]="avril";
t[4]="mai"; t[5]="juin";t[6]="juillet"; t[7]="aout";
t[8]="septembre"; t[9]="octobre"; t[10]="novembre";
t[11]="decembre";
System.out.println("Les mois de l'annee sont : ");
System.out.println(t[0]); System.out.println(t[1]); System.out.println(t[2]);
System.out.println(t[9]); System.out.println(t[10]);System.out.println(t[11]);
}
}
Boucles
Boucle for
La boucle for permet de répéter un certain nombre de fois des instructions. Elle s’écrit :
for (initialisation; test_continuation; incrémentation) {instructions;}
o L’initialisation permet de préciser la variable qui contrôle la boucle et de l’initialiser. Exemple : int i=0
o Le test de continuation dit quel est le test qui doit être vérifié pour que la boucle continue. Exemple : i < 20
o L’incrémentation précise comment évolue la variable de contrôle. Généralement on écrit i++ qui veut dire
i=i+1 (on passe de i à i+1, donc d’une valeur de la variable à la suivante).
Exemple : Tableau1.java, du dossier tableau1, permet de réduire les instructions à une seule boucle :
public class Tableau1 {
String[] t = new String[12] ;
t[0]="janvier"; t[1]="fevrier"; t[2]="mars"; t[3]="avril";t[4]="mai";
t[5]="juin"; t[6]="juillet"; t[7]="aout"; t[8]="septembre"; t[9]="octobre";
t[10]="novembre";t[11]="decembre";
System.out.println("Les mois de l'annee sont : ");
for (int i = 0 ; i < 12; i++) { System.out.println(t[i]); }
}
}
6
Dans le programme Tableau2.java, du dossier tableau2, on utilise deux boucles for : une pour initialiser le
tableau, l’autre pour le faire afficher :
double[] t = new double[20] ;
for (int i = 0 ; i < 20 ; i++) {
t[i] = i ;
}
for (int i = 0; i < 20 ; i++) {
System.out.print(t[i] + " * ");
}
}
}
La variable i est déclarée dans chaque boucle.
o Entre les deux boucles, i n’existe pas
o On dit que sa portée se limite à la boucle en cours
Dans le programme Tableau2b.java du même dossier tableau2, la variable i est déclarée dans le main.
o La portée de i est alors la méthode main toute entière (i est connu dans tout le main).
public class Tableau2b {
double[] t = new double[20] ;
int i ;
for (i = 0 ; i < 20 ; i++) {
t[i] = i ;
}
for (i = 0; i < 20 ; i++) {
}
System.out.println("\n ---> i vaut maintenant " + i) ;
}
}
Boucle while
La boucle while permet de répéter des instructions tant qu’un test est vérifié.
Elle s’écrit :
while (test) {
instructions ;
}
Les instructions doivent modifier au moins une
variable intervenant dans le test, pour que le while ne
boucle pas indéfiniment.
Exemple : afficher les éléments d’un tableau de nombres t tant que ces éléments sont inférieurs à 20.
int i = 0 ;
while (t[i] < 20) {
System.out.print(t[i] + " ") ;
i++ ;
}
i est modifié dans les instructions, donc t[i] correspond à chaque passage à un élément différent
du tableau t.
Attention cependant à ne pas dépasser la taille du tableau !
Si le tableau est de taille n, il faut écrire :
int i = 0 ;
while ((i < n) && (t[i] < 20)) {
// && est la notation pour ET
System.out.print(t[i] + " ") ;
i++ ;
}
Boucle do … while
Elle permet de faire exécuter une première fois des instructions puis de recommencer tant qu’un test est vérifié.
Elle s’écrit :
do
{
instructions ;
}
while (test);
Ces instructions doivent modifier au moins une
variable du test, pour que le do … while ne
boucle pas indéfiniment.
7
Exemple : afficher le 1er élément du tableau t, puis les suivants tant qu’ils sont inférieurs au premier :
int i = 0 ;
do
{
System.out.print(t[i]+ " ");
i++ ;
}
while ((i<n)&&(t[i]<t[0]));
Sauts
break
L’instruction break permet de sauter tous les cas suivants, en reprenant l’exécution directement après le test ou
la boucle (on saute donc tous les cas suivants).
Exemple : afficher les éléments du tableau t tant qu’ils sont inférieurs à 20. On arrête donc dès qu’on rencontre
un élément supérieur ou égal à 20.
C’est équivalent à la boucle while ci-dessous :
for (int i = 0 ; i < n ; i++) {
if (t[i]<20) {
System.out.print(t[i]+" * ");
}
else {
break ;
}
}
int i = 0 ;
while ((i<n) && (t[i] < 20)) {
System.out.print(t[i]+" * ") ;
i++ ;
}
continue
L’instruction continue permet de sortir d’un pas d’itération en reprenant l’exécution à l’itération suivante. On
arrête donc les instructions de l’itération en cours pour passer directement à la suivante.
Exemple : afficher tous les éléments du tableau t qui sont différents de 20.
Deux versions, selon que l’on teste si t[i] est égal à 20 ou est différent de 20 :
for (int i = 0 ; i < n ; i++) {
if (t[i] == 20) {
continue ;
}
else {
}
}
for (int i = 0 ; i < n ; i++) {
if (t[i] != 20) { System.out.print(t[i]+ " * ");
}
else {
continue ;
}
}
return
L’instruction return permet de sortir d’une méthode sans nécessairement attendre la fin de celle-ci. Cette
instruction ne peut donc pas figurer directement dans le main, mais sera très largement utilisée par la suite.
Exercices
1) Ouvrez le fichier Tableau3.java du dossier tableau3 avec WordPad.
double[] t ;
int n = 20 ;
t = new double[n] ;
for (int i = 0 ; i < n ; i++) {
t[i] = i ;
}
for (int i = 0; i < n ; i++) {
}
}
}
(1)
Ajoutez après la ligne (1) une boucle while pour faire afficher les éléments du tableau t tant que ceux-ci sont
inférieurs à 12. Compilez et exécutez.
8
2) Faites exécuter plusieurs fois de suite le programme Tableau4 du dossier tableau4. Ouvrez ensuite le fichier
avec WordPad :
int n=20 ;
double[] t = new double[n] ;
java.util.Random r = new java.util.Random();
for (int i = 0 ; i < n ; i++) {
t[i] = r.nextInt(50) ;
}
for (int i = 0; i < n ; i++) {
}
}
}
(1)
(2)
(3)
Ce programme fait appel à un générateur de nombres aléatoires appelé r, qui est créé par la ligne (1) :
java.util.Random r = new java.util.Random();
r génère successivement 20 nombres entiers tous compris entre 0 et 50 car à la ligne (2) r.nextInt(50)
fournit à chaque fois un entier aléatoire compris entre 0 et 50
3) Ajoutez après la ligne (3) une boucle do … while pour faire afficher le premier élément du tableau tab, puis
les éléments suivants tant que ceux-ci sont inférieurs ou égaux au premier élément. Compilez et exécutez.
3. java, langage à objets
Classes et instances
Un programme java peut ne contenir qu’une seule classe, comme on l’a vu jusqu’à présent. Cette classe, qui
contient alors la méthode main, constitue à elle toute seule toute l’application. Mais java est avant tout un
“langage à objets”, ce qui veut dire qu’une classe peut aussi être un moule à partir duquel on peut fabr iquer
des objets qu’on appelle des instances.
On souhaite créer des « objets » comportant :
o un entier n qui représente la taille d’un tableau
o un tableau t de n entiers comportant les entiers 1, 2, 3, … n
Exemple de deux tels objets :
La classe (encore embryonnaire) correspondant à ces objets est la suivante :
class ObjetTableau { // début de la classe
int n ;
// deux attributs : n entier
int[] t ;
// et t tableau d’entiers
}
// fin de la classe
Cette description signifie que tout objet de la classe ObjetTableau, dès qu’il ser a cr éé, comportera
automatiquement deux var iables (qu’on appellera des attr ibuts) n et t.
9
Une classe correspond donc à la description d’un ensemble d’objets ayant une structure de données
commune. Les objets créés selon ce modèle sont appelés des instances de la classe.
Pour donner des valeurs aux attributs, donc remplir n et t, on doit ajouter dans la classe ObjetTableau une
méthode spécifique appelée constructeur :
class ObjetTableau {
int n ;
int[] t ;
// début de la classe
// deux attributs : n et t
ObjetTableau(int a) {
// le constructeur
n = a ;
// n prend la valeur a
t = new int[n] ;
// on réserve la place pour t
for (int i=0 ; i < n ; i++) {
t[i] = i+1 ;
// remplissage de t
}
}
// fin du main
}
// fin de la classe
Créer des objets de la classe ObjetTableau se fait ailleurs, dans une autr e classe qui sert de programme
principal :
public class ProgObjet {
public static void main (String args[ ]) {
ObjetTableau obj1 = new ObjetTableau(6);
}
}
// début de classe
// le main
// fin du main
// fin de classe
Ce programme crée bien les deux objets en mémoire, mais n’affiche RIEN.
o On ajoute donc à la première classe une méthode void affiche() affichant les éléments du tableau t
et une méthode int inferieurs(int p) calculant le nombre d’éléments du tableau t inférieurs à p
int n ;
int[] t ;
// début de la classe
// deux attributs : n et t
n = a;
t = new int[n] ;
for (int i=0;i<n;i++) {
t[i] = i+1 ;
}
}
//
//
//
//
le constructeur
n prend la valeur a
on réserve la place pour le tableau t
remplissage du tableau
// fin du constructeur
void affiche() {
System.out.println("affichage des elements");
for (int i = 0; i < n; i++){
}
System.out.println("");
}
int inferieurs(int p) {
int compteur = 0 ;
for (int i = 0; i < n; i++){
if (t[i]<p) compteur++ ;
}
return compteur ;
}
}
o
// fin de la classe
On ajoute à la seconde classe, les instructions demandant aux deux objets créés d’effectuer leurs deux
méthodes :
public class ProgObjet {
// classe principale
obj1.affiche();
10
// main
// affichage de obj1
}
// on recherche le nb d’elements < 3
System.out.print("Nb elements inferieurs a 3 : ");
System.out.println(obj1.inferieurs(3)) ;
// nb d’elements < 3
obj2.affiche();
// on recherche le nb d’elements < 4
System.out.print("Nb elements inferieurs a 4 : ");
System.out.println(obj2.inferieurs(4)) ;
// nb d’elements < 4
}
// fin du main
// fin de classe
Les méthodes affiche et inferieurs ne peuvent être exécutées que par des objets : ce sont des méthodes
d’instances.
void affiche() affiche les éléments, mais ne calcule rien, d’où son type de valeur de retour : void
int inferieurs(int p) calcule le nombre d’éléments de t strictement inférieurs à p
o int (valeur de retour) indique que le résultat est un entier (valeur du compteur)
o int p est l’argument de la méthode
o return permet de renvoyer la valeur du compteur
Le fichier comporte deux classes : ObjetTableau et ProgObjet. Il y aura donc deux fichiers compilés.
Il s’agit d’une application, car il y a dans une des classes une méthode appelée main.
La classe principale est celle qui comporte la méthode main ; elle doit impérativement être déclarée public. On
l’appelle souvent aussi classe maître de l’application.
Le fichier doit porter le nom de cette classe maître, suivi de l’extension .java. Ce sera donc ici ProgObjet.java
Attributs et méthodes d’instances
Une classe peut être un moule permettant de construire des objets (ce n’est pas obligatoire).
Mais un objet est nécessairement créé à partir d’une classe, à l’aide d’un constructeur de cette classe ; on dit
alors que l’objet est une instance de la classe et qu’il est du type de la classe.
Un objet comporte des attr ibuts d’instance et dispose de méthodes d’instance, définis dans la classe.
Ainsi, dans la classe ObjetTableau,
o n et t sont des attributs d’instance
o les méthodes void affiche() et int inferieurs(int p) sont des méthodes d’instance
Attributs et méthodes de classes
Une classe peut aussi comporter des attr ibuts de classe et des méthodes de classe. Ils sont signalés par le
mot-clé static et existent dès le début de l’application, même si aucun objet de la classe n’a encore été créé.
Seule exception : le constr ucteur est une méthode de classe, même s’il n’est pas précédé de static.
Exemple d’utilisation d’un attribut de classe et d’une méthode de classe pour compter les objets créés :
Attribut de classe : static int nbobjets
o initialisé au lancement de l’application
o modifié dans le constructeur
Méthode de classe : static void nombreObjets()
o appelée dans le programme principal sur le nom de la classe : ObjetTableau.nombreObjets();
11
static int nbobjets = 0;
// initialisation du compteur
int n ; int[] t ;
n = a;
t = new int[n] ;
for (int i=0;i<n;i++) {
t[i] = i+1 ; }
nbobjets++ ;
// incrémentation du compteur
}
void affiche() {
System.out.print("affichage d'un objet : ");
for (int i = 0; i < n; i++){
}
}
static void nombreObjets() { // méthode de classe
System.out.println("Nombre d'objets : " + nbobjets) ;
}
}
public class ProgObjet1 {
// début de classe
// le main
ObjetTableau.nombreObjets() ; // appel à la méthode de classe
obj1.affiche();
obj2.affiche();
}
// fin du main
}
// fin de classe
4. Les paquetages Java
Qu’est-ce qu’un paquetage ?
Les paquetages (packages) sont des librairies de classes, de classes d’exceptions et d’inter faces regroupées
selon leur fonction. La documentation concernant chaque paquetage est stockée sous forme de pages HTML
dans le dossier docs du JDK.
java.lang
Le paquetage java.lang est le seul paquetage dont l’emploi ne doit jamais être déclaré. Il comprend notamment la
classe Object, la classe System, les classes enveloppantes, la classe Math et la classe Str ing.
La classe Object est à l’origine de toutes les classes. Si on ne précise pas de clause d’héritage en définissant une
nouvelle classe, celle-ci hérite de Object.
La classe System contient des variables et des méthodes du système.
Les classes enveloppantes : les variables des types de données primitifs (int, char, double, etc) sont les seuls
éléments qui ne sont pas des objets dans Java. Mais on peut, en cas de besoin, les transformer en objets à l’aide
de classes enveloppantes suivantes :
type
nature
classe enveloppante
boolean
true ou false
Boolean
char
caractère 16 bits
Character
byte
entier 8 bits signé (petit entier)
Byte
short
entier 16 bits signé (entier court)
Short
int
entier 32 bits signé (entier)
Integer
long
entier 64 bits signé (entier long)
Long
float
virgule flottante 32 bits (réel simple)
Float
double
virgule flottante 64 bits (réel double)
Double
12
Exemples d’utilisation :
int n = 5 ;
Integer obj1 = new Integer(n) ;
double f = 1/3 ;
Double obj2 = new Double(f) ;
//
//
//
//
n n’est pas
obj1 est un
f n’est pas
obj2 est un
un objet
objet
un objet
objet
La classe Math contient les méthodes nécessaires (méthodes de classe) pour les calculs mathématiques.
Exemple : double j = -3.145 ; double k = Math.abs(j) ;
La classe Str ing contient de très nombreuses méthodes d’instance pour le traitement des chaînes de caractères.
Exercices
1) Compilez le fichier Test1.java du dossier test1, dont le texte est donné ci-dessous, et faites-le exécuter.
Regardez ce que renvoie chaque méthode.
public class Test1 {
public static void main(String args[]) {
String s1 = "Bonjour" ;
System.out.println("s1 vaut "+s1+" et est de longueur
"+s1.length());
char c = s1.charAt(3) ;
System.out.println("La caractere au 3eme indice est : " +c) ;
String s2 = s1.toUpperCase();
if (s1.equalsIgnoreCase(s2)) {
System.out.println("s1 et s2 sont equivalents");
}
String s3=" et bonne journee" ;
String s4 = s2.concat(s3) ;
System.out.println("s4 vaut : " + s4);
String s5 = "bon" ;
int pos = s4.indexOf(s5) ;
if (pos == -1)
System.out.println("s4 ne contient pas s5");
else System.out.println("s4 contient s5 a l’indice "+pos);
String s6 = s4.substring(3, 8);
System.out.println("entre les indices 3 et 8 de s4 on trouve "+s6);
}
}
2) Ecrivez un programme qui initialise une chaîne de caractères s avec « Le sanglot long des violons de
l’automne berce mon coeur d’une langueur monotone », qui la découpe en mots et fait afficher un mot par ligne.
java.util
Le paquetage java.util contient des classes utilitaires : Calendar , Gr egor ianCalendar , Random…
Pour utiliser une partie d’un paquetage autre que java.lang, on utilise le mot-clé impor t :
o import java.util.GregorianCalendar ;
on se donne le droit d’utiliser la classe GregorianCalendar (qui permet de créer des objets de type date (jourmois-année-heure-minute-seconde…)
o import java.util.Random ;
on se donne le droit d’utiliser la classe Random
o import java.util.* ;
on se donne le droit d’utiliser toutes les classes du paquetage
Exercices
Le fichier UtilAleatoire.java du dossier utilaleatoire est le suivant :
class TableauAleatoire {
static int max = 100 ;
int nb ;
int t[] ;
// déclare que l’on veut utiliser la classe Random
//
//
//
//
entier qui donne la valeur maximale des nombres
aléatoires qui seront générés (variable de classe)
variable d’instance : nombre d'éléments du tableau
variable d’instance : un tableau d'entiers
13
TableauAleatoire(int m) {
// le constructeur
nb = m ;
t = new int[nb] ;
Random r = new Random() ;
// crée le générateur de nombres aléatoires
for (int i = 0 ; i < nb ; i++) {
t[i] = r.nextInt(max) ; // entier aléatoire entre 0 et max
}
}
void affiche() {
// méthode d'instance réalisant l'affichage du tableau
// affiche les réels du tableau t séparés par des espaces
for (int i = 0; i < nb ; i++) {
System.out.print(t[i]+ "
") ;
}
// un saut de ligne pour terminer
}
}
public class UtilAleatoire {
// le programme principal
TableauAleatoire obj1 = new TableauAleatoire(50) ; // un objet
obj1.affiche() ;
// appel de affiche() sur l’objet
}
}
1) Ajoutez à la classe TableauAleatoire deux méthodes d’instance int maximum() et int minimum() renvoyant
respectivement le plus grand et le plus petit élément du tableau t.
Pour tester les méthodes, modifiez la classe UtilAleatoire de la manière suivante :
TableauAleatoire obj1 = new TableauAleatoire(50) ;
obj1.affiche() ;
System.out.println("Maximum : " + obj1.maximum()) ;
System.out.println("Minimum : " + obj1.minimum()) ;
}
}
2) Ajoutez à la classe TableauAleatoire une méthode d’instance int somme()renvoyant la somme des éléments
du tableau t. Complétez le main en conséquence :
obj1.affiche() ;
System.out.println("Somme : " + obj1.somme()) ;
}
}
3) Ajoutez à la classe TableauAleatoire une méthode d’instance int compteegaux(int p) renvoyant le nombre
d’éléments du tableau t égaux à p. Complétez le main en conséquence pour faire afficher le nombre d’éléments
égaux à 50, puis à 60 :
obj1.affiche() ;
System.out.println("Somme : " + obj1.somme()) ;
System.out.println("Nb elem egaux a 50 : " + obj1.compteegaux(50)) ;
System.out.println("Nb elem egaux a 60 : " + obj1.compteegaux(60)) ;
}
}
14
La notion d’héritage
On déclare qu’une classe dérive d’une autre classe par :
class classe-fille extends classe-mère {
...
}
Si une classe B dérive d’une classe A, elle hérite des champs et des méthodes de A.
Un objet de la classe fille est donc un objet de la classe mère (éventuellement complété par des champs et des
méthodes supplémentaires), mais la réciproque est fausse.
Toutes les classes héritent de la classe Object. Si on précise pas de clause d’héritage dans la définition d’une
classe, par défaut, elle hérite de Object.
Les méthodes héritées d’une classe mère A peuvent être redéfinies dans la classe fille B. Cette possibilité de
redéfinir les méthodes est appelée le polymor phisme : un objet de type A et un objet de type B sont capables de
répondre au même message, mais en faisant appel à des méthodes de contenus différents.
Les interfaces
Une interface est une sorte de classe spéciale, dont toutes les méthodes sont déclarées public et abstract (sans
code). En fait, une interface pr opose des ser vices, mais sans donner le code permettant d’exécuter ces services.
Une classe qui souhaite utiliser une interface le signale par le mot implements :
class B implements C {…} ;
On dit alors qu’elle implémente l’interface. Dans la classe B, on doit alors donner le code de toutes les
méthodes de l’interface.
Une classe B peut hériter d’une classe A et implémenter une ou plusieurs interfaces :
class B extends A implements C, D {...} ;
class A
interface C, D
extends
implements
class B
Les méthodes des interfaces C et D doivent alors obligatoir ement être définies dans la classe B.
Les classes d’exceptions
Lorsqu’une méthode est exécutée, il peut se produire des erreurs. On dit alors qu’une exception est levée. Une
exception est un objet, instance d’une des nombreuses sous-classes de la classe Exception.
Chaque méthode qui risque de provoquer une ou des erreur(s) le signale par le mot thr ows suivi de la nature des
erreurs susceptibles de se produire.
Lorsqu’on veut utiliser une méthode risquant de provoquer des erreurs, on englobe l’appel à cette méthode dans
un bloc tr y (pour capturer l’erreur) et on précise ce qu’on fera en cas d’erreur dans une clause catch.
Exemple :
try
{
fichier.read() ;
}
catch (IOException) {
System.out.println(" erreur de lecture ") ;
return ;
}
Les différentes classes d’erreurs possibles sont spécifiées dans chaque paquetage.
Exercices
Rechercher dans la documentation le paquetage java.util.
1) Combien comporte-t-il d’interfaces ?
2) Combien comporte-t-il de classes ?
3) Combien comporte-t-il de classes d’exceptions ?
4) De quelle classe la classe GregorianCalendar est-elle fille ?
5) De combien de constructeurs cette classe dispose-t-elle ?
6) Combien de méthodes d’instance cette classe propose-t-elle ?
7) Combien de méthodes de classe cette classe propose-t-elle ?
15
petite-fille ?

Algorithmique et initiation à la programmation Java

Transcription

Documents pareils

Organigramme Direction communication

Les Variables

Exercice 08 - Jacques BAPST

IUT Bordeaux 1

Sujet de TD

Documentation Java Objectifs - UTC

Série N°1 - Toubkal-it

Séance 3 (2 h 40 min) : TP 1

Module I5 – Java Corrigé TP4 RT I – Gestion de flux de caractères

Master bio-info : Java Année 2013-2014 TP 3