1

Programmation oriontée objet

Librairie Standard,
Classes Enveloppes, chaines de
caractères et fichiers
 Librairie Standard, Classes Enveloppes, 1

chaines de caractères et fichiers

 l'API de la Librairie

 entetes de l'API

 La classe Math

 Classes enveloppes pour Types Primitifs

 La classe String (Les chaines de

caractères)

 La classe File (Les fichiers texte)

 1

Eléments de la librairie standard

 l'API de la Librairie

 entetes de l'API

 La classe Math

 Classes enveloppes pour Types Primitifs

 Classes et méthodes

 Méthode = (fonction ou
procédure) = une collection
d'instructions qui effectue une
tâche complexe (utile)
Une méthode est identifiée par
son nom

 Classe = un conteneur de
méthodes
Les méthods qui servent un
but similaire sont stockées
dans la meme classe
Une classe est identifiée par
son nom
 2

API de la Librairie
 Utiliser les méthodes prédéfinies pour votre programme.
("reinvent the wheel", NON !)

 Example:
 Utiliser les méthodes de calcul mathématiques prédéfinies.

 Utiliser les structures de données usuelles prédéfinies -- listes, piles,

files, arbres.
(gain en temps, en pérformance, ...)

 Les méthodes sont définies dans des classes (types de données

complexes).

 Les classes sont des enveloppes qui regroupent plusieurs méthodes

relatives à un sujet donné. Classe Math, String, Integer, etc.
 7

La Classe Math

 Quelques méthodes usuelles de la classe Math :

 public static int abs(int num)
 Retourne la valeur absolue de num.
 public static double abs(double num)
 Retourne la valeur absolue de num.

 public static int max(int x, int y)

 Retourne la plus grande valeur de x et y.
 public static double max(double x, double y)
 Retourne la plus grande valeur de x et y.
 8

La Classe Math

 Quelques méthodes usuelles de la classe Math (suite):

 public static int min(int x, int y)
 Retourne la plus petite valeur de x et y.
 public static double min(double x, double y)
 Retourne la plus petite valeur de x et y.
 public static double pow(double num, double power)
 Retourne num élevée à la puissance power.

 public static double random()

 Retourne une valeur uniformement distribuée entre 0.0 et 1.0,
mais n'incluant pas 1.0.
 public static double sqrt(double num)
 Retourne la racine carré num.
 9

La Classe Math
 Les méthodes de la classe Math sont des méthodes "static"
(méthodes de classe).
 Appel : Le nom de la classe Math suivi du point (.) suivi du nom
de la méthode.
int position1 = 15, position2 = 18;
int distanceApart = [Link](position1 - position2);

Appel de méthode: [Link]éthode (Liste des arguments)

discriminant = [Link](b, 2) - (4 * a * c);

X1 = ((-1 * b) + [Link](discriminant)) /
(2 * a);
X2 = ((-1 * b) - [Link](discriminant)) /
(2 * a);
 11

La Classe Math

 Les classes contiennent aussi des varaibles, des

constantes, etc.

 La classe Math contient la constante mathématique

de nom PI:
 Pi,  = perimeter/diameter = 3.14159265358979323846

 Type double

 Constante (valeur fixe).

changement de valeur ==> erreur de compilation.

 variable de classe , utilisation ([Link]).

 12

Classes enveloppes Pour Types Primitifs

 Une classe enveloppe est une classe relative à un type primitif lui
ajoutant plus de fonctionalités.
 Classes enveloppes de quelques types primitifs de Java:
Classe enveloppe Type Primitif
Integer int
Long long
Float float
Double double
Character char

 Exemple: Fonctions de conversions (String <--> Nombres) aux

interfaces graphiques.

 Classe enveloppe string  number number  string

Integer [Link](<string>) [Link](<#>)
Long [Link](<string>) [Link](<#>)
Float [Link](<string>) [Link](<#>)
Double [Link](<string>) [Link](<#>)
Classes enveloppes pour Types primitifs

String => valeur

 La classe enveloppe de chaque type de données
primitif a une méthode parseType() pour 'parser'
une représentation en "string" & retourne la valeur
litérale.

[Link]("42") => 42
[Link]("true") => true
[Link]("2.71") => 2.71
//…
 14

Classes enveloppes pour Types primitifs

 Examples de Conversions - strings aux nombres:

String anneeStr = "2002";
String noteStr = "13.5";
int year = [Link](anneeStr);
double note = [Link](noteStr);

 Rappel - pour convertir une string à un type numérique,

utiliser [Link] tel que XXX est le nom de la
classe enveloppe du type numerique utilisé.
 Examples de Conversions - nombres aux strings:
int annee = 2002;
double score = 78.5;
String yearStr = [Link](annee);
String noteStr = [Link](note);
 Primitifs & enveloppes

 Java a une Classe enveloppe pour chacun des huits

types de données primitives :
Type Classe Type Classe
Primitif enveloppe Primitif enveloppe

boolean Boolean float Float

byte Byte int Integer
char Character long Long
double Double short Short
 15

Classes enveloppes pour Types primitifs

 Pour trouver la plus petite et la plus grande valeur

possible pour un type primitif, utiliser la classe enveloppe
du type et accéder les valeurs constantes nomées
MAX_VALUE et MIN_VALUE de la classe enveloppe. Par
example:

Integer.MAX_VALUE : 2147483647
Double.MAX_VALUE : 1.7976931348623157E308
Float.MIN_VALUE : 3.4028235E38
 Rappel: classes et méthodes

 Méthode = une collection

d'instructions qui effectue
une tache complexe
(utile)
Une méthode est
identifiée par son nom

 Classe = un conteneur de
méthodes
Les méthods that serves
a similar purpose sont
stored in the same class
Une classe est identifiée
par son nom
 Organization de la librarie Java

 La librarie Java Standard

consiste en un nombre de
packages
Chaque package consiste
d'un nombre de classes
(qui fournissent une
fonctionalité similaire)

 La librarie Java standard

est appelée java
 Un package nommé xxx
dans la librarie Java
standard est nommé
[Link]
 Organization de la librarie Java (suite.)
 Quelques packages couramment utilisées :

• [Link]: Fournit des classes qui sont fondamentales au

design du language de programmation Java.
Site web officiel :
[Link]
g/[Link]
 Organization de la librarie Java (suite.)
 Représentation schematique de la Librarie standard
Java:
 Organization de la librarie Java (suite.)
 Une classe nommée yyy dans le package [Link] est
nommée [Link]

Example:
• La classe Math dans le package [Link] est connu en
tant que [Link]
• The class Double dans le package [Link] est connu en
tant [Link]
• The class Stack dans le package [Link] est connu en
tant que [Link]
• The class Scanner dans le package [Link] est connu en
tant [Link]
 Organization de la librarie Java (suite.)

 Note:

• C'est une convention Java que le nom d'une classe

Java commence par une lettre majuscule
• C'est aussi une convention Java que le nom d'une
méthode commence par une lettre miniscule
 Utilisation des méthodes de la librairie
standard de java: importation d'une classe

 Régle d'usage:

• Si un programme Java veut utiliser une méthode

dans la libraie Java, le programme Java doit en
premier importer la classe qui le contient

La clause import doit etre la premiére instruction dans un

programme (avant la définition de toute classe)

 Syntaxe pour importer une classe de la librarie Java :

import nomClasse ;
 Utilisation des méthodes de la librairie
standard de java: importation d'une classe

 Examples:

import [Link];
import [Link];
import [Link];
import [Link];
// Aprés la clause import , on peut écrire le code du
//programme (la définition de la classe)
// Ce programme peut maintenant utiliser toutes les
//méthodes definies dans les classes Math, Double,
//ArrayList et Scanner
 Utilisation des méthodes de la librairie
standard de java: importation d'une classe

class MonProgramme
{
public static void main(String[] args)
{
double a;
a = [Link](2.0);
[Link](a);
}
}
 Importation de toutes les classes
dans un package

 Quelques programmes Java complexes peuvent

utiliser plusieurs méthodes différentes contenues
dans plusieurs classes différentes dans le même
package
Ce serait douleureux d'écrire une longue liste de
clauses "import "

Example: import [Link];

import [Link];
import [Link]; ...
 Importation de toutes les classes
dans un package (suite)

 Il existe un raccourci pour importer toutes les classes

contenues dans dans un package:

import [Link].* ; // importer toutes les classes dans

//le package [Link]
import [Link].* ; // importer toutes les classes dans le
//package [Link]
 Méthodes Fréquenment utilisées : Le
package [Link]

 Selon la Régle d'usage:

• Si un programme Java veut utiliser une méthode

dans la libraie Java, le programme Java doit en
premier importer la classe qui le contient

On doit importer [Link] si on veut utiliser la

méthode [Link]()
 Méthodes Fréquenment utilisées : Le
package [Link]

On aurait du écrire:
import [Link]; // On DOIT importer cette classe pour utiliser
//[Link]
public class Abc
{
double a, b, c, x1, x2; // Définit 5 variables
a = 1.0;
b = 0.0;
c = -4.0;
Méthodes Fréquenment utilisées : Le
package [Link]

x1 = ( -b - [Link]( b*b - 4*a*c ) ) / (2*a);

x2 = ( -b + [Link]( b*b - 4*a*c ) ) / (2*a);
[Link]("a = "); [Link](a);
[Link]("b = "); [Link](b);
[Link]("c = "); [Link](c);
[Link]("x1 = ");
[Link](x1);
[Link]("x2 = ");
[Link](x2); }
 Méthodes Fréquenment utilisées : Le
package [Link]

 Mais.... Parce que:

• Le package [Link] contient des classes qui sont fondamentales

au design du language de programmation Java.

Toutes les classes dans le package [Link] sont

automatiquement incluses dans chaque programme
Java (le compilateur Java est programmé à le faire)

C'est pourquoi nous n'avions pas besoin d'importer

[Link] dans notre program.
 Utilisation des méthodes de la librairie
standard de java

 Régle d'usage:

• Si un programme Java veut utiliser une méthode

dans la libraie Java, le programme Java doit en
premier importer "import" la classe qui le contient
• Toutes les classes dans le package [Link] ont
déjà été importés dans un programme Java (On peut
utiliser les méthodes dans ces classes sans la clause
import )
 Les chaines de caractères

La classe String
La classe String

 Un objet de la classe String représente une chaine de

caractères.
 String a deux operateurs en outre, + and += (utilisés
pour la concatenation).
 Les litéraux (Strings)

 Un "Litéral" string = objet anonyme de la classe

String qui est une "chaine constante" défini comme
texte en double quotes.
 Création d'un Litéral string : pas besoin ils sont “juste
là.”
 Les litéraux (Strings--suite)

 peuvent être affectés aux variables String.

 peuvent être passées aux méthodes en tant que
paramétres.
 ont des méthodes qu'on peut appeler:

String nomFichier = "[Link]";

button = new JButton("écran suivant ");
if ("Start"equals(cmd)) ...
 Les litéraux (Strings--suite)

 le texte de la string peut inclure les

caractéres “d'échappement” .
 Example:
 \\ pour \
 \n retour à la ligne

String s1 = "POO en Java”;

String s2 = "C:\\jdk1.4\\docs";
String s3 = "Hello\n";
 Examples de "Litéral" String

//affecter un litéral à une variable String

String nom = “Rachid”;

//Appel d'une méthode sur un litéral String

char prmierInitial = “Rachid”.charAt(0);

//Appel d'une méthode sur une variable String

char prmierInitial = [Link](0);
 Immuabilité
 Une fois créee, une string ne peut pas être modifiée:
aucune de ses méthodes ne peut changer la string.

 De tels objets sont appelés immuable.

 Les objets immuables sont pratiques parce que

plusieurs références de même type peuvent faire
référence au même objet en toute sécurité: aucun
danger de changer un objet à une réference sans
que les autres ne le sachent.
 Strings Vides
 Une string vide n'a aucun caractére; sa longueur
est 0.
String s1 = ""; Strings vides
String s2 = new String();
 Ne pas confondre avec une string non initialisée :

String msgErreur; msgErreur

est null
Méthodes — length, charAt
int length ();  Retourne le nombre de caractères
dans la string
char charAt (k);
 Retourne le caractère à la k-ème
position

Les positions des Caractéres

dans mes strings commecent de
l'indice 0

Retourne:
"Oracle".length(); 6
"Hind".charAt (2); 'n'
Méthodes — Egalité

boolean b = [Link](mot2);
retourne true si la string mot1 est égale à mot2
boolean b = [Link](word2);
retourne true si la string mot1 est égale à mot2,
ignorant la casse
b = “Java”.equals(“Java”);//true
b = “Java”.equals(“java”);//false
b = “Java”.equalsIgnoreCase(“java”);//true

if([Link](“java”))
[Link](“POO en “ + langage);
Méthodes — Comparisons
int diff = [Link](mot2);
retourne la “différence” mot1 - mot2
int diff = [Link](mot2);
retourne la “différence” mot1 - mot2, ne tenant pas
compte de la casse
Habituellement les programmeurs ne se
préoccupent pas de la valeur numérique de la
“différence” mot1 - mot2, mais juste de son
signe, si la différence est négative (mot1 précéde
mot2), zéro (mot1 et mot2 sont égaux) ou positive
(mot1 devance mot2). Souvent utilsée dans les
instructions conditionnelles.
if([Link](mot2) > 0){
//mot1 vient aprés mot2…
}
Comparison (Examples)

//différences négatives
diff = “c”.compareTo(“java”);//c avant j
diff = “java”.compareTo(“java EE”);//java est
//plus courte que java EE

//différences zéro
diff = “java”.compareTo(“java”);//equal
diff = “poo”.compareToIgnoreCase(“POO”);//equal

//différences positives
diff = “info”.compareTo(“INFO”);//i après I
diff = “FAC”.compareTo(“BAC”);//F après B
diff = “Java 9”.compareTo(“Java”);// Java 9 est
plus longue
Méthodes — Comparaisons

boolean b = [Link](s2);
retourne true si la string s1 est égale à s2

boolean b = [Link](s2);
retourne true si la string s1 est la même que s2, ignorant la
casse

int diff = [Link](s2);

retourne la “différence” s1 - s2

int diff = [Link](s2);

retourne la “différence” s1 - s2, ignorant la casse
Méthodes — Concaténation

String resultat = s1 + s2;

concaténe s1 and s2

String resultat = [Link] (s2);

meme chose que s1 + s2

resultat += s3;
concaténe s3 à result

resultat += num;
convertit num à String et la concaténe à resultat
Traiement de fichiers (texte)
La classe File
 Entrée/Sortie (E/S)
import [Link].*;
 Créer un objet File pour obtenir des informations sur un fichier sur le
disque dur. (Cela ne crée pas un nouveau fichier sur le disque dur.)
File f = new File("[Link]");
if ([Link]() && [Link]() > 1000) {
[Link]();
}

Method name Description

canRead() retourne si le fichier peut etre lu
delete() supprime le fichier du disque
exists() si le fichier existe sur le disque
getName() returne le nom du fichier
length() returne le nombre d'octeets dans le fichier
renameTo(file) changee le nom du fichier
 Lecture des fichiers
 Pour lire un fichier, passer un File lors de la construction
d'un Scanner.
Scanner nom = new Scanner(new File("nom fichier"));

 Example: (en 2 temps)

File file = new File("donné[Link]");
Scanner input = new Scanner(file);

 ou (plus court):
Scanner input = new Scanner(new
File("donné[Link]"));
 Chemins de fichiers
 chemin absolu:

C:\Users\az\Documents\TDtp1\Fic

 chemin relatif:

[Link]
Module/[Link]
 Supposé être relatif au répertoire courant:
Scanner input = new Scanner(new File("data/[Link]"));

Si notre programme est dans H:/rep ,

Scanner cherchera dans H:/rep/data/[Link]
 Erreurs Compilateur avec fichiers
import [Link].*; // pour File
import [Link].*; // pour Scanner

public class ReadFile {

public static void main(String[] args) {
Scanner input = new Scanner(new File("[Link]"));
String text = [Link]();
[Link](text);
}
}

 Le programme ne parvient pas à compiler avec l'erreur

suivante:
[Link][Link] unreported exception
[Link];
must be caught or declared to be thrown
Scanner input = new Scanner(new File("[Link]"));
^
 La clause throws
 La clause throws : throws FileNotFoundException
- Ajoutée à l'entete de toute méthode qui traite les fichiers.

 Syntaxe:
public static type name(params) throws typeExcpt {

 Example: clause throws ajoutée à l'entete de la méthode main

public class ReadFile {

public static void main(String[] args)
throws FileNotFoundException {
...
...
}
}

 throws Exception est aussi valable. Nous l'utiliserons aux

travaux dirigés et aux travaux pratiques.
 Jetons d'entrée
 token: Une unité d'entrée de l'utilisateur, séparés par des
éspaces.
 Un Scanner divise le contenu d'un fichier en jetons (token).
 Si un fichier d'entrée contient ce qui suit:
23 3.14
"Zayd Reda"
Le Scanner peut interpréter les tokens en tant que types comme suit:
Token Type(s)
23 int, double, String
3.14 double, String
"Zayd String
Reda" String
 Fichiers et curseur d'entrrée
 Considerons un fichier mé[Link] qui contient ce texte:
16.2 23.5
19.1 7.4 22.8

18.5 -1.8 14.9

 Un Scanner voit tout le contenu comme un flux de

caractères:
16.2 23.5\n19.1 7.4 22.8\n\n18.5 -1.8 14.9\n
^

 curseur d'entrrée: La position courante du Scanner.

 Consommation des jetons
 consommation des entrées: Lire le contenu et avancer le
curseur.
 Appelant nextInt etc. déplace le curseur au-delà du token (jeton)
courant.

16.2 23.5\n19.1 7.4 22.8\n\n18.5 -1.8 14.9\n

^

double d = [Link](); // 16.2

16.2 23.5\n19.1 7.4 22.8\n\n18.5 -1.8 14.9\n
^

String s = [Link](); // "23.5"

16.2 23.5\n19.1 7.4 22.8\n\n18.5 -1.8 14.9\n
^
 Tests du Scanner pour entrées
valides
Méthode Déscription
hasNext() retourne true s'il existe un token suivant
hasNextInt() retourne true s'il existe un token suivant
et peut etre lu en tant que int
hasNextDouble() retourne true s'il existe un token suivant
et peut etre lu en tant que double
 Ces méthodes du Scanner ne consomme pas l'entrée;
Ils donnent l'information à propos du token suivant (le type du token suivant) .
 Utile pour savoir ce qu'est l'entrée (input) à venir, et pour éviter les crashes.

 Ces procédés peuvent être aussi bien utilisés avec un Scanner de console.
 Lorsqu'elles sont appelées sur la console, elles bloquent parfois (en attente d'une
entrée).
 Fichier d'entrée (question)
 Rappellons le fichier d'entrée mé[Link]:
16.2 23.5
19.1 7.4 22.8

18.5 -1.8 14.9

 Ecrire un programme qui compte le nombre de prises de

température effectuées.
 Fichier d'entrée (réponse 2)
// Compte le nombre de fois (de prises de températures) que les
temperatures ont été enregistrées dans le fichier d'entrée.

import [Link].*; // pour File

import [Link].*; // pour Scanner

public class Temperatures {

public static void main(String[] args)
throws FileNotFoundException {
Scanner input = new Scanner(new File("mé[Link]"));
int c=0;
while([Link]())
{[Link]();c++;}
[Link](c);
}
}
 Fichier d'entrée (question 3)
 Calculer le nombre de jours de prises de température.

 Les prises de températures d'un jour sont inscrites sur la

meme ligne.

 La fin d'une ligne est caracrtrisée par \n.

 Nous ne disposons d'aucun moyen pour savoir que nous avons

consommé une ligne.
 Line-based Scanners

Méthode Déscription
nextLine() retourne la ligne d'entrée suivante entiérement (du
curseur au\n)
hasNextLine() retourne true s'il existe plus de lignes d'entrées à lire
(toujours true pour les entrées de la console)

Scanner input = new Scanner(new File("file name"));

while ([Link]()) {
String line = [Link]();
traiter cette ligne;
}
 Consuming lines of input
23 3.14 Zayd Reda "Hello" world
45.2 19

 Le Scanner lit les lignes comme suit:

23\t3.14 Zayd Reda\t"Hello" world\n\t\t45.2 19\n
^
 String line = [Link]();
23\t3.14 Zayd Reda\t"Hello" world\n\t\t45.2 19\n
^
 String line2 = [Link]();
23\t3.14 Zayd Reda\t"Hello" world\n\t\t45.2 19\n
^
 Chaque caractére \n est consomé mais non retourné.
 Fichier d'entrée (réponse 2)
// Compte le nombre de jour que les temperatures ont été
enregistrées dans le fichier d'entrée (une ligne de prises de
températures = 1 jour).

import [Link].*; // pour File

import [Link].*; // pour Scanner

public class Temperatures {

public static void main(String[] args)
throws FileNotFoundException {
Scanner input = new Scanner(new File("mé[Link]"));
int c=0;
while([Link]())
{[Link]();c++;}
[Link](c);
}
}
Sortie des fichiers
La classe Printwriter
 Utilisation de la classe PrintWriter pour écrire des
données dans un fichier

La classe PrintWriter peut etre utilisée pour l'écriture

et la sauvegarde de données dans un fichier.
Example:
L'instruction suivante crée, ouvre, et lie le fichier
referencé par file avec la variable PrintWriter nommée
outputFile .

File file = new File("donné[Link]");

PrintWriter outputFile = new PrintWriter(file); Warning: si le fichier existe déjà, il
sera éffacé et remplacé par un
nouveau fichier.
Passer la réference de
l'objet file au constructeur
de la classe PrintWriter .

62
 Utilisation de la classe PrintWriter pour écrire des
données dans un fichier

 Après ouverture du fichier par un objet de la classe

PrintWriter , le méthodes print, println, et/ou printf
seront utilisées pour écrire lers données dans ce
fichier.

 print, println seront utilisées de la meme façon

qu'elles le sont avec [Link] pour l'affichage des
données sur la fenetre de la console.

63
 Utilisation de la classe PrintWriter pour écrire des
données dans un fichier

 Après avoir utilisé un fichier on doit le fermer utilisant

la méthode close.

Example:
La méthode close
[Link]( ); de l'objet
PrintWriter .

64
 Utilisation de la classe PrintWriter pour écrire des
données dans un fichier

Exemple:

public static void ecrire(String[] t,File f) throws IOException{

PrintWriter out=new PrintWriter(f);

for(String el:t) [Link](el);

[Link]();

65
 Utilisation de la classe PrintWriter pour écrire des
données dans un fichier

Pour écrire les données dans un fichier texte:

1. Inclure l'instruction import [Link].*; avant les définitions des classe du

fichier source.
2. Mettre la clause throws IOException dans l' entete de toute méthode
qui crée un objet PrintWriter ou appelle une méthode qui crée un objet
PrintWriter.

 throws Exception est aussi valable. Nous

l'utiliserons aux travaux dirigés et aux travaux
pratiques.

66
 1

Programmation oriontée objet

Librairie Standard,
Classes Enveloppes, chaines de
caractères et fichiers

Supports de présentation
[Link]
[Link]
[Link]
[Link]