Les bibliothèques

des classes en
Rajae El Ouazzani

2017-2018
Plan
 Section 1: Les chaines de caractères en Java
 La classe String
 La classe StringBuffer
 Section 2: Les classes Enveloppes
 Section 3: Transtypage
 Section 4: Règles de portée
 Section 5: La classe System
 Section 6: La classe exception
 Le bloc try{...} catch{...}
 La classe Throwable
 La clause finally
 Les exceptions personnalisées
 Gestion de plusieurs exceptions
2017-2018
 Multi-catch
Section 1: Les chaines de caractères
en Java

2017-2018
Les chaines de caractères
 Les chaines de caractères sont traitées par les 2 classes
suivantes:
 La classe String: pour les chaines constantes.
 La classe StringBuffer: pour les chaines variables.

2017-2018
La classe String

2017-2018
 La classe String
 En Java, les chaînes sont gérées par une classe spécifique appelée "String".
Même les littéraux de type chaîne sont gérés de façon interne comme des
objets de cette classe.
 Les chaînes de caractères sont inaltérables: une fois créé un objet String, on
ne peut pas changer sa valeur.
 Les opérations qui permettent de changer les caractères ou la taille d'une
chaîne renvoient un nouvel objet String.
public class VarInaltérable {
public static void main(String[] args) {
String chaine1 = new String("Salam"); Résultat:
System.out.println("La chaine 1: "+chaine1);
La chaine 1: Salam
String chaine2=chaine1.replace('a', 'e');
System.out.println("La chaine 1: "+chaine1);
La chaine 1: Salam
System.out.println("La chaine 2: "+chaine2); La chaine 2: Selem
// la modification n’est pas effectuée sur chaine1
}
2017-2018
}
Autre exemple
public class test {
public static void main(String[] args) {
String chaine1 = new String("Salam");
System.out.println("chaine 1: "+chaine1);
chaine1 = chaine1 + " à tous";
System.out.println("chaine 1: "+chaine1);
}
}
Résultat:
chaine 1: Salam
chaine 1: Salam à tous

2017-2018
 Méthodes de comparaisons [1]
Remarque: On ne peut pas utiliser les opérateurs relationnels (<, >, ==, etc).

Méthode Description
Compare une chaîne de caractère à un autre objet.
int compareTo(Object o)
Renvoie une valeur <0, ==0, ou > 0.
Compare une chaîne de caractère à un autre objet.
int compareTo(String anotherString) Renvoie une valeur <0 ==0 ou > 0. La
comparaison est une comparaison lexicographique.
Compare une chaîne de caractère à un autre objet.
Renvoie une valeur <0 ==0 ou > 0. La
int compareToIgnoreCase(String str)
comparaison est une comparaison lexicographique,
ignorant la casse.
Compare la chaîne a un objet et retourne true en cas
boolean equals(Object anObject)
d’égalité et false sinon.
boolean equalsIgnoreCase(Object Compare la chaîne a un objet et retourne true en cas
anObject) d’égalité et false sinon ( on ignore la casse).
2017-2018
Exemples

String un = new String("exemple");

String deux = new String("exemple");
String trois = new String("EXEMPLE");
if (un == deux) //faux
if(un.equals(deux)) //vrai
if (un.equalsIgnoreCase(trois)) //vrai
if(un.compareTo(trois) > 0) //vrai
if(un.compareTo(deux) ==0) //vrai

2017-2018
Autres méthodes de comparaison [1]
Méthode Description
Teste l’égalité de deux parties de chaînes.
ignoreCase: si true, on ignore la casse.
boolean regionMatches(boolean
toffset: le début de l’offset de la première chaine.
ignoreCase, int toffset, String
other : le nom de la deuxième chaine.
other, int ooffset, int len)
ooffset: le début de l’offset de la deuxième chaine.
len: le nombre de caractères à comparer.
boolean regionMatches(int
toffset, String other, int ooffset, Teste l’égalité de deux parties de chaînes.
int len)

2017-2018
 Exemple
String str1 = "Salam à tous";
String str2 = "Bonjour à Tous";

/* Tester l’égalité des caractères de l’indice 8 dans str1 avec les

caractères de l’indice 10 dans str2 sans prendre en considération la
casse, "true" ignore la casse */
boolean test = str1.regionMatches(true, 8, str2, 10, 4);
System.out.println("Régions égales="+test); // Régions égales = true

/* En considérant la même casse des lettres */

test = str1.regionMatches(8, str2, 10, 4);
System.out.println("Régions égales="+test); // Régions égales = false
2017-2018
Exercice
 Ecrire un programme qui permet de trier un tableau de String.
Ce tableau contient des prénoms de personnes.
 Afficher les éléments du tableau avec les longueurs
correspondantes.

Résultat
Brahim : 6 lettres
Imane : 5 lettres
Karim : 5 lettres
Mariam : 6 lettres
Mohamed : 7 lettres
Samira : 6 lettres

2017-2018
 Solution
public class StringExemple{
public static void main(String a[]){
String prénoms [ ] = {"Mariam", "Mohamed", "Karim", "Samira", "Imane", "Brahim"}, var;
for(boolean ok = false; !ok; ){
ok=true;
for(int i = 0; i < prénoms.length-1; i++){
Résultat
if(prénoms[i].compareTo(prénoms[i+1])>0){
Brahim : 6 lettres
var = prénoms [i];
Imane : 5 lettres
prénoms [i] = prénoms [i+1]; Karim : 5 lettres
prénoms [i+1] = var; Mariam : 6 lettres
ok = false; Mohamed : 7 lettres
} Samira : 6 lettres
}
}
for(int i = 0; i <prénoms.length;i++)
System.out.println (prénoms[i] + " : "+prénoms [i].length()+" lettres");
}
} 2017-2018
Méthodes pour caractère et sous-chaîne[2]
Méthode
char charAt(int i)
String substring(int d)
String substring(int d, int f)
boolean startsWith(String prefix)
boolean startsWith(String prefix, int d)
boolean endsWith(String suffix)
2017-2018
Description
Retourne le caractère à l’indice
spécifié en paramètre.
Sous-chaîne depuis d jusqu’à la
fin
Sous-chaîne depuis d jusqu’au
caractère d’indice f non inclus.
Renvoie true si prefix est un
préfixe de la chaîne
Renvoie true si prefix est un
préfixe de la chaîne à partir de d.
Retourne true si suffix est un
suffixe de la chaîne.
 Exemple
String s = "String est immutable";
char resultat = s.charAt(7);
System.out.println(resultat); // affiche: e

System.out.println(s.substring(7) ); // affiche: est immutable

System.out.println(s.substring(7, 10) ); // affiche: est, le caractère de l’indice 10 n’est pas inclus.

String st = "est";
boolean test1 = s.startsWith(st); // false
boolean test2 = s.startsWith(st, 1); // true

test1 = s.endsWith( "immutable" ); //true

test2 = s.endsWith( "immu" ); // false

2017-2018
 Méthodes pour conversions [2]
Méthode Description
String toLowerCase() Retourne une chaîne égale à la chaîne convertie en minuscules.
String toLowerCase(Locale locale) Retourne une chaîne égale à la chaîne convertie en minuscules.
String toString() Retourne une chaîne égale à la chaîne
String toUpperCase() Retourne une chaîne égale à la chaîne convertie en majuscules.
String toUpperCase(Locale locale) Retourne une chaîne égale à la chaîne convertie en majuscules.
Retourne une chaîne égale à la chaîne sans les espaces de
String trim()
début et de fin.
String replace(char ac, char nc)/ Retourne une chaîne où toutes les occurrences de ac sont
String replaceAll(char ac, char nc) remplacés par des nc. S’il n’y a pas de remplacement, la chaîne
elle-même est retournée.

Remarque: A Locale object represents a specific geographical, political, or cultural region. It

uses the Locale to tailor information for the user. For example, displaying a character is a locale-
sensitive operation— the number should be formatted according to the customs and conventions
of the user's native country, region, or culture. [12]
2017-2018
Exemples
String Str = new String("Salam à Tous");
System.out.println(Str.toLowerCase()); // affiche: salam à tous
// Ou bien
Locale defloc = Locale.getDefault(); // utiliser le système Locale par défaut
System.out.println("string value = " + Str.toLowerCase(defloc)); // conversion
// Ou bien
System.out.println(str.toLowerCase(Locale.FRANCE)); // choisir le locale: France

Str = new String(" Salam à Tous ");

System.out.println(Str.trim() ); // affiche: Salam à Tous

System.out.println("Salam".replace('a', 'e')); // affiche: Selem

2017-2018
Méthode Description
static String Construit une chaîne de caractères à partir d’un tableau de
copyValueOf(char[] data) caractères.
Construit une chaîne de caractères à partir d’une partie de
static String tableau de caractères.
copyValueOf(char[] data, data : le vecteur de caractères.
int offset, int count) offset : l’offset initial de la sous chaine.
count : la longueur de la sous chaine.
byte []getBytes(String enc) Convertit la chaîne en tableau de byte.
byte []getBytes() Convertit la chaîne en tableau de byte.
Copie les caractères de la chaîne dans le tableau en
paramètres.
void getChars(int srcBegin, srcBegin : indice du 1er caractère de la chaine à copier.
int srcEnd, char[] dst, int srcEnd : indice qui suit le dernier caractère de la chaine à
dstBegin) copier.
dst : le vecteur destination.
dstBegin : l’offset de début dans le vecteur destination.
Convertit la chaîne de caractères en un tableau de
char []toCharArray()
caractères. 2017-2018
 Exemples
char[] tab={'C', 'O', 'M', 'P', 'I', 'L', 'E', ' ','O', 'N', 'L', 'I', 'N', 'E'}; // tab de caractères
String str = String.copyValueOf(tab, 8, 6 ); /* retourner un String qui contient les
caractères du tableau de l’offset 8 et de longueur as 6 */
System.out.println(str); // affiche la sous chaine: ONLINE

String s= "Cours de Java pour GI";

char[] t = new char[30]; // tab de caractères
s.getChars(9, 13, t, 0); //copie de String de l’indice 9 à 12 dans le tableau de caractères.

System.out.println(s.toCharArray()); // affiche le tableau de caractères à partir du String s.

2017-2018
Méthode
static String valueOf(boolean b)
static String valueOf(char c)
static String valueOf(char[] data)
static String valueOf(char[] data, int Retourne la représentation en chaîne du
offset, int count)
static String valueOf(double d)
static String valueOf(float f)
static String valueOf(int i)
static String valueOf(long l)
static String valueOf(Object obj)
Description
Retourne la représentation en chaîne du
booléen.
Retourne la représentation en chaîne du
caractère.
Retourne la représentation en chaîne du
tableau de caractères.
tableau de caractères (partie) .
Retourne la représentation en chaîne du
double.
Retourne la représentation en chaîne du float.
Retourne la représentation en chaîne du int.
Retourne la représentation en chaîne du long.
Retourne la représentation en chaîne de
l’objet.
2017-2018
 Exemple
String un = String.valueOf(1); // conversion d’un nombre en un String

 Remarque: Tous les objets Java possèdent une méthode toString()

héritée de la classe Objet qui est utilisée par String.valueOf() pour la
présentation sous forme de chaîne.

2017-2018
 Méthodes de recherche [2]
Méthode
int indexOf(int ch)
int indexOf(int ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(int ch)
int lastIndexOf(int ch, int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)2017-2018
Description
Retourne l’indice de la première occurrence
du caractère.
Retourne l’indice de la première occurrence
du caractère à partir de fromIndex.
Retourne l’indice de la première occurrence
de la chaîne.
Retourne l’indice de la première occurrence
de la chaîne à partir de fromIndex.
Retourne l’indice de la dernière occurrence
du caractère.
Retourne l’indice de la dernière occurrence
du caractère à partir de fromIndex.
Retourne l’indice de la dernière occurrence
de la chaîne.
Retourne l’indice de la dernière occurrence
de la chaîne à partir de fromIndex.
 Exemple
String str = "Salam à tous";
// retourne l’indice du caractère 't' à partir de l’indice 4
System.out.println(str.indexOf('t', 4)); // affiche 8
// returne l’indice de l’occurrence du charactère 'l' s’il existe et -1 sinon
System.out.println(str.indexOf('l')); // affiche 2

/* la recherche commence à partir de l’indice 2 et retourne l’indice du 1er caractère

de la sous chaine "tous" et -1 sinon*/
System.out.println(str.indexOf("tous", 2)); // affiche 8
System.out.println(str.indexOf("GI", 2)); // affiche -1

/* Rechercher l’indice de la chaine "ful". La recherche se fait en arrière à partir de

l’indice 18. */
String s = "Java is a wonderful language";
System.out.println(s.lastIndexOf("ful", 18));
2017-2018 // affiche 16
La classe StringBuffer

2017-2018
La classe StringBuffer [3]
 La classe StringBuffer est différente de la classe String, puisque
les objets StringBuffer peuvent être modifiés.
 Plusieurs méthodes importantes différencient la classe
StringBuffer et la classe String.

2017-2018
 Méthodes de longueur [2]
Méthode Description
int length() La longueur de la chaîne (String/StringBuffer).
Renvoie la quantité de mémoire affectée au
StringBuffer. Comme la mémoire affectée à un
objet StringBuffer peut être contrôlée avec le
int capacity()
constructeur StringBuffer (int length), cette
valeur peut être supérieure à la valeur renvoyée
par la méthode length.
Cette méthode redimensionne le tableau, si
void ensureCapacity(int
nécessaire, de façon que la capacité minimale
minCapacity)
de la chaîne soit égale à minCapacity.
La longueur de la chaîne est n ; les caractères
void setLength(int n) éventuellement ajoutés ont une valeur
indéterminée.
2017-2018
 Méthodes de concaténation [2]
Méthode Description
Concatène la représentation en chaîne du booléen. Elle
StringBuffer append(boolean b) sert à ajouter du texte à l’objet StringBuffer. Cette
méthode est fortement surchargée.
StringBuffer append(char c) Concatène la représentation en chaîne du caractère.
Concatène la représentation en chaîne du du tableau de
StringBuffer append(char[] str)
caractères.
StringBuffer append(char[] str, Concatène la représentation en chaîne du tableau de
int offset, int len) caractères.
StringBuffer append(double d) Concatène la représentation en chaîne du double.
StringBuffer append(float f) Concatène la représentation en chaîne du float.
StringBuffer append(int i) Concatène la représentation en chaîne du int.
StringBuffer append(long l) Concatène la représentation en chaîne du long.
StringBuffer append(Object obj) Concatène la représentation en chaîne de l’objet
StringBuffer append(String str) 2017-2018
Concatène la représentation en chaîne de la chaîne.
Exemple
StringBuffer s1 = new StringBuffer(10);
int c = s1.capacity(); //c = 10
int l = s1.length(); //l = 0
s1.append("Bor"); //s1 = "Bor"
s1.append("land"); //s1 = "Borland"
c = s1.capacity(); //c = 10
l = s1.length(); //l = 7
s1.setLength(2); //s1 = "Bo"

StringBuffer s2 = new StringBuffer("Bonour ");

s2.insert (3, 'j'); //s2 = "Bonjour "
s2.insert (3, "jour"); //s2 = "Bonjourjour "
char[] s3 = new char[]{'à',' ','t','o','u','s'};
s2.append(s3, 0, 6); 2017-2018Boujour à tous
// s2 affiche:
 Remarque [4]
String s1 = "Salam" ;
String s2 = "tout le monde !" ;
String s3 = s1 + " " + s2 ;
 Les trois opérations de concaténation s'enchaînent. Une première chaîne de caractères
est créée, concaténation de s1 et " ", puis une deuxième, concaténation de cette
première chaîne et de s2.
 Si l'on n'y prend pas garde, on voit que ces opérations de concaténation peuvent mener
à la création de nombreuses chaînes intermédiaires, ce qui a un coût non négligeable en
calculs et en ressources mémoire, surtout si ces chaînes sont longues. Une bonne
habitude à prendre, est donc de n'utiliser ces opérations de concaténation que dans les
cas où l'on se fiche de consommer trop de ressources (rares), et dans les cas où l'on n'a
que peu de concaténations à faire.
 Dans tous les autres cas (c'est à dire dans tous les cas ou presque), on préfèrera utiliser
un StringBuffer, de la manière suivante.
StringBuffer sb = new StringBuffer() ;
sb.append(s1).append(" ").append(s2) ;
String s3 = sb.toString() ; 2017-2018
 Autre remarque [4]
 La première classe (historiquement) utilisée pour concaténer
efficacement des chaînes de caractères est StringBuffer. La classe
StringBuilder est apparue dans l'API de Java 5, elle n'est donc pas
disponible en version 4 et précédentes. Les méthodes exposées par
ces deux classes sont identiques, on peut donc utiliser l'une ou l'autre
de façon équivalente, du point de vue de la compilation.
 La seule différence entre ces deux classes est que StringBuffer est
une classe synchronisée. Elle doit donc être utilisée en
environnement multithreadé. La conséquence est que son utilisation
est plus coûteuse que StringBuilder qui ne l'est pas.
 Par défaut, on doit donc utiliser StringBuilder. Si la variable
concernée est en concurrence d'accès, alors on doit utiliser
StringBuffer.
2017-2018
 Méthodes de caractère et sous-chaîne [2]
 Ces méthodes sont utilisées aussi avec la classe String.

Méthode
char charAt(int i)
String substring(int d)
String substring(int d, int l)
Description
Retourne le caractère à l’indice spécifié en
paramètre.
Sous-chaîne depuis d jusqu’à la fin
Sous-chaîne depuis d et de longueur l.

2017-2018
Méthodes de conversion et de modification [2]

Méthode Description
String toString() Retourne une chaîne égale à la chaîne.
StringBuffer delete(int start, Enlève tous les caractères compris entre start
int end) (inclus) et end (exclus).
StringBuffer
Enlève le caractère à l’indice index
deleteCharAt(int index)

2017-2018
Exemples
StringBuffer s = new StringBuffer("Salam à vous tous");
// supprimer les caractères de l’indice 8 à l’indice 13
s.delete(8, 13); // s affiche: Salam à tous

s.deleteCharAt(6); // s affiche : Salam tous

2017-2018
Section 2: Les classes Enveloppes

2017-2018
 Présentation [5]
 Les classes enveloppes (Wrappers) sont des classes qui encapsulent les
données de type primitif, afin de pouvoir les utiliser comme des objets
ordinaires.
 Depuis Java 5, les opérations de conversion d'un type primitif vers un objet
d'une classe enveloppe, et la conversion inverse sont devenues
automatique: boxing et unboxing. Les classes enveloppes sont immuables.
Type primitif Classe enveloppe
boolean Boolean
char Character
byte Byte
short Short
int Integer Sous-classes de la
long Long classe Number
float Float
double Double
2017-2018
Les méthodes de format: x xValue()
 Toutes les sous-classes de la classe Number possèdent les méthodes de
format: x xValue(). Elles réalisent les conversions des types primitifs.
 Voila quelques méthodes de ce format:
byte byteValue(), short shortValue(), int intValue(), long longValue() et double
doubleValue().

Exemples:
Integer obj = new Integer(15);
int i = obj.intValue(); // retourner la valeur de ce Integer comme un int
System.out.println("La valeur de i = " + i); // affiche 15

2017-2018
Les méthodes de formats: x X.parseX(String s) et
x X.parseX(String s, int base)
 Toutes les classes enveloppes ont une méthode de format x
X.parseX(String s) qui essaie de convertir une chaîne de caractères en une
donnée de type primitif si c'est possible (elles lèvent une exception
NumberFormatException sinon).
 Pour les types entiers, on a aussi les méthodes de format x X.parseX(String
s, int base) qui essaient de convertir une chaîne de caractères en une
donnée de type primitif, en supposant que la donnée est notée dans la base
base.
Exemples:
// convertir une chaine de caractères de 10, 2, 16, etc.
int a = Integer.parseInt("222", 10); // affiche 222
int b = Integer.parseInt("1010110", 2); // affiche 86 (somme des puissances de 2)

2017-2018
 Remarques: [6]

 obj.intValue() est une méthode non statique. Elle permet d’obtenir la

valeur entière d’un objet obj de type Integer.

 Integer.parseInt() est une méthode statique qui permet de convertir

une chaine de caractères vers un entier sans avoir besoin de créer un
objet de la classe Integer.

2017-2018
La méthode de format: static X X.decode(String s)
 Toutes les classes enveloppes de type entier ont une méthode de format
static X X.decode(String s) qui essaie de convertir une chaîne de caractères
en une donnée de type primitif entier si c'est possible (elles lèvent une
exception NumberFormatException sinon).
 si la chaine commence par un 0 le décodage se fait en octal.
 si la chaine commence par 0x, ou par # le décodage se fait en
hexadécimal.
 sinon le décodage se fait en décimal.
Exemple:
// conversion de chaines de caractères vers des entiers
 System.out.println(Integer.decode("0234")); //2*82+3*81+4*80=156
 System.out.println(Integer.decode("0xabf")); //10*162+11*161+15*160=2751
 System.out.println(Integer.decode("#abf")); // 2751
 System.out.println(Integer.decode("234")); //234
2017-2018
Constantes et méthodes
des classes enveloppes

2017-2018
 1- Boolean :
Il y a deux constantes de type Boolean: Boolean.TRUE et Boolean.FALSE.
2- Character :
Méthode
static boolean isLetter(char c)
static boolean isDigit(char c)
static boolean isLetterOrDigit(char c) Retourne true si c est un chiffre ou une lettre et false sinon.
static boolean isLowerCase(char c)
static boolean isUpperCase(char c)
static boolean isSpaceChar(char c)
static boolean isWhiteSpace(char c)
static boolean
isJavaIdentifierPart(char c)
static boolean
isJavaIdentifierStart(char c)
Description
Retourne true si le caractère c est une lettre et false sinon.
Retourne true si c est un chiffre et false sinon.
Retourne true si c est une lettre majuscule et false sinon.
Retourne true si c est un espace et false sinon.
Retourne true si c est un espace et false sinon.
Retourne true si c est un espace selon Java et false sinon.
'\n': saut de ligne (newline), '\r', retour chariot (retour en
début de la même ligne), '\t' : tabulation, '\f' :saut de page
(form feed)....
Retourne true si c peut faire partie d'un identificateur Java et
false sinon.
Retourne true si c peut être le premier caractère d'un
2017-2018
identificateur Java et false sinon.
 Exemples
char ch1= 'A', ch2= '9', ch3 ='a', ch4 = ' ';
boolean b1 = Character.isLetter(ch1); // b1 a la valeur true
boolean b2 = Character.isLetter(ch2); // b2 a la valeur false
boolean b3 = Character.isUpperCase(ch1); // b3 a la valeur true
boolean b3 = Character. isLowerCase(ch3); // b3 a la valeur true
boolean b4 = Character.isSpaceChar(ch4); // b4 a la valeur true

char ch5 = '3'; ch6 = '/', ch7 = '_';

boolean b5 = Character.isJavaIdentifierPart(ch5); // b5 a la valeur true
boolean b6 = Character.isJavaIdentifierPart(ch6); // b6 a la valeur false
boolean b7 = Character.isJavaIdentifierStart(ch7); // b7 a la valeur true
boolean b8 = Character.isJavaIdentifierStart(ch5); // b8 a la valeur false
2017-2018
3- Number :
3.1 Byte :
La classe Byte possède trois constantes: Byte.MAX_VALUE qui vaut 27-1,
Byte.MIN_VALUE qui vaut -27. et Byte.SIZE qui vaut 8 le nombre de bits de la
représentation d'un byte.
3.2 Short :
La classe Short possède trois constantes: Short.MAX_VALUE qui vaut 215-1,
Short.MIN_VALUE qui vaut -215. et Short.SIZE qui vaut 16 le nombre de bits
de la représentation d'un short.
3.3 Integer :
La classe Integer possède trois constantes: Integer.MAX_VALUE qui vaut 232-1,
Integer.MIN_VALUE qui vaut -232 et Integer.SIZE qui vaut 32 le nombre de bits
de la représentation d'un int.

2017-2018
 Méthodes de la classe Integer
Méthode Description
Retourne la valeur entière du bit 1 de plus fort poids de la
static int highestOneBit(int i)
représentation de i
Retourne la valeur entière du bit 1 de moins fort poids de la
static int lowestOneBit(int i)
représentation de i
static int
Retourne le nombre de 0 en début de la représentation de i.
numberOfLeadingZeros(int c)
static int
Retourne le nombre de 0 en fin de la représentation de i.
numberOfTrailingZeros (int c)
Retourne la valeur de i à laquelle on a fait subir une rotation
static int rotateLeft(int i, int d) de distance d vers la gauche. Un bit peut aller occuper le bit
de signe.
Retourne la valeur de i à laquelle on a fait subir une rotation
static int rotateRight(int i, int
de distance d vers la droite. Un bit peut aller occuper le bit
d)
de signe.
static int reverse(int i) Retourne la valeur obtenue en inversant l'ordre des bits de i.
static int bitCount(int i) Retourne 2017-2018
le nombre de bits à 1 dans la représentation de i.
 Exemples
int i = 170;
/* retourner la representation en string de la valeur du unsigned integer
représenté par l’argument en base 2 */
String n1=Integer.toBinaryString(i); // n1 a la valeur : 10101010
int n2=Integer.bitCount(i); // compte le nombre de bits égals à 1: 4

// Valeur décimale du bit 1 le plus fort (puisance de 2)

n=Integer.highestOneBit(i); // 27=128
// Valeur décimale du bit 1 le plus faible (puisance de 2)
n=Integer.lowestOneBit(i); //21=2

2017-2018
 Exemple
rotateRight(481, 5)
481 is 0000 0000 0000 0000 0000 0001 1110 0001
481 >>> 5 cuts off the last 5 bits, and adds 5 zeros at the start:
0000 0000 0000 0000 0000 0000 0000 1111 (15)
481 << -5 is the same as 481 << 27, so it cuts off 27 (32-5) leading bits
and adds 27 zeros at the end:
0000 1000 0000 0000 0000 0000 0000 0000 (134217728)

2017-2018
3.4 Long :
 La classe Long possède trois constantes : Long.MAX_VALUE qui
vaut 263-1, Long.MIN_VALUE qui vaut -263 et Long.SIZE qui
vaut 64 le nombre de bits de la représentation d'un long.
 La classe Long a les mêmes méthodes que la classe Integer.
Exemple:
 System.out.println(Long.MAX_VALUE);
 System.out.println(Long.MIN_VALUE);
 System.out.println(Long.SIZE);

2017-2018
3.5 Float :
 La classe Float possède les constantes : Float.MAX_VALUE qui vaut
(3.4028235E38), Float.MIN_VALUE qui vaut (1.4E-45), Float.SIZE qui
vaut 32 le nombre de bits de la représentation d'un Float, Float.NaN une
représentation de NotANumber, Float.POSITIVE_INFINITY qui
représente +∞ et Float.NEGATIVE_INFINITY qui représente -∞ .
 Des méthodes permettent de «voir» un int comme un float et inversement.
Exemple:
 float f1 = 1.2345f;
 System.out.println(Float.MAX_VALUE); // 3.4028235E38
 System.out.println(Float.MIN_VALUE); // 1.4E-45
 System.out.println(Float.SIZE); // 32
 System.out.println(Float.NaN); // NaN
 System.out.println(Float.POSITIVE_INFINITY); // Infinity
 System.out.println(Float.NEGATIVE_INFINITY);
2017-2018 // - Infinity
3.6 Double :
 La classe Double possède les constantes : Double.MAX_VALUE qui vaut
(2-2-52)21023, Double.MIN_VALUE qui vaut 2-1074, Double.SIZE qui vaut
64 le nombre de bits de la représentation d'un Double, Double.NaN une
représentation de NotANumber, Double.POSITIVE_INFINITY qui
représente +∞ et Double.NEGATIVE_INFINITY qui représente -∞ .
 Des méthodes permettent de «voir» un long comme un double et
inversement.
Exemple:
 System.out.println(Double.MAX_VALUE);
 System.out.println(Double.MIN_VALUE);
 System.out.println(Double.SIZE);
 System.out.println(Double.NaN);
 System.out.println(Double.POSITIVE_INFINITY);
 System.out.println(Double.NEGATIVE_INFINITY);
2017-2018
4- Void :
 La classe Void enveloppe le type primitif void. Cette classe est non
instantiable.

5- Boxing, Unboxing :
 L'opération de «boxing» est l'opération qui permet de transformer un type
primitif en un objet de la classe enveloppante. L'opération de «unboxing»
est l'opération qui permet de transformer un objet de classe enveloppante
dans le type primitif qu'elle enveloppe.
Exemples:
 Integer i = new Integer(26); i/2; // unboxing de la classe Integer vers int
 i = 79 ; // boxing de int vers Integer (i est un objet de la classe Interger)

2017-2018
Section 3: Transtypage

2017-2018
 Présentation [3]
 Dans certains cas, il est nécessaire de convertir un type de
variable en un autre type, c’est le transtypage.
 L’exemple suivant montre comment la variable renvoyée par
une méthode, de type int, peut être transtypée en type float :
float f = (float) retourInt();
Remarque:
 Soyez prudent lors des transtypages, car il y a des risques de
perte d’informations. En règle générale, le type cible du
transtypage doit avoir une taille au moins égale au type initial.

2017-2018
Transtypages autorisés
 Le tableau suivant montre les transtypages qui ne risquent
pas de provoquer des pertes d’informations :

Type initial Transtypage

byte short, char, int, long, float, double
short int, long, float, double
char int, long, float, double
int long, float, double
long float, double
float double

2017-2018
Transtypage implicite
 Dans certains cas, un transtypage peut être réalisé
implicitement par le compilateur. Voici un exemple :

if (3 > 'a') {
}

 Dans ce cas, la valeur ‘a’ est convertie en nombre entier

(valeur ASCII de la lettre a) avant d’être comparée au
nombre 3.

2017-2018
Exercice
Qu’est sensé faire le programme suivant ? Corriger le.
public class ExCast {
public static void main(String[] args) {
int a=657,b=70;
double m;
short n;
byte o;
m=(a+b)/2;
n=(a+b)/2;
o=(a+b)/2;
System.out.println("La moyenne est " + m);
System.out.println("La moyenne est " + n);
System.out.println("La moyenne est " + o);
}
} 2017-2018
 Solution
public class EXCast {
public static void main(String[] args) {
int a=657,b=70;
double m;
short n;
byte o;
m=(double)(a+b)/2;
n=(short) ((a+b)/2);
o=(byte) ((a+b)/2);
System.out.println("La moyenne est " + m);//363.5
System.out.println("La moyenne est " + n);// 363
System.out.println("La moyenne est " + o);// 107
}
}
Sans le premier cast, m affiche
2017-2018 363.0
Section 4: Règles de portée

2017-2018
 Définition [3]
 Les règles de portée déterminent où une variable est reconnue
dans un programme. Les variables appartiennent à deux
catégories de portée principales :
 Variables globales : Variables reconnues tout au long du
programme.
 Variables locales : Variables reconnues uniquement dans le
bloc de code où elles sont déclarées.

 La règle de portée générale : une variable déclarée dans un

bloc de code n’est visible que dans ce bloc et dans les blocs
qui y sont imbriqués.

2017-2018
Exemple:
class Portée {
int x = 0;
void méthode1() {
int y;
y = x; //correct
}
void méthode2() {
int z = 1;
z = y; //incorrect!
}
}
2017-2018
Section 5: La classe System

2017-2018
 La classe System
 La classe System permet d’accéder aux ressources indépendantes de la plate-
forme du système. C’est une classe déclarée comme final, qui ne peut donc
pas donner naissance à des sous-classes. Ses méthodes et variables sont
également déclarées comme statiques, ce qui lui permet d’être disponible
sans être instanciée.
 Les méthodes de la classe System sont utiles dans de nombreux cas.
 Une fonction importante consiste à obtenir l’heure du système avec la
méthode currentTimeMillis.
 Il est également possible d’extraire et de modifier les ressources du
système avec les méthodes Get et Set.
 La classe System permet de forcer la récupération de l’espace mémoire
des objets qui ne plus utilisés (Garbage collection) avec la méthode gc;
 Enfin, la classe System permet aux développeurs de charger des
bibliothèques de liens dynamiques avec la méthode loadLibrary.
2017-2018
 Exemples
// Obtenir l’heure actuelle du système en millisecondes
System.out.print("Temps actuel en millisecondes="+ System.currentTimeMillis());

// Démarrer le GarbageCollector pour nettoyer le disque des objets qui ne sont plus
utilisés
System.gc();
System.out.println("Nettoyage completé.");
Résultat:
System.out.println("Démarrage du programme"); Program starting...
// Charger une bibliothèque dans le dossier Windows/System32 Loading Library...
Library Loaded.
System.out.println("Chargement de la bibliothèque");
Runtime.getRuntime().loadLibrary("C:/Windows/System32/crypt32.dll");
System.out.println("Bibliothèque chargée.");
2017-2018
System.getProperties().list(System.out); /* Affiche les proporiétés du système
courant*/
-- listing properties --
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=C:\Program Files\Java\jre6\bin
java.vm.version=11.0-b15
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
user.country=FR
sun.java.launcher=SUN_STANDARD
sun.os.patch.level=Service Pack 2
java.vm.specification.name=Java Virtual Machine Specification
user.dir=E:\workspace_java\test
java.runtime.version=1.6.0_10-b33
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.version=1.6.0_10
java.ext.dirs=C:\Program Files\Java\jre6\lib\ext;C:...
sun.boot.class.path=C:\Program
2017-2018 Files\Java\jre6\lib\resour…
Syntaxe: public static String setProperty(String key, String value)
key – Le nom du système.
value – La valeur du système.

// Modifier la valeur de l’environnement Java en "Java Runtime 1.6.0"

System.out.println(System.getProperty("java.runtime.version" ));
System.setProperty("java.runtime.version", "Java Runtime 1.6.0");
System.out.println(System.getProperty("java.runtime.version" ));

Résultat:
1.6.0_10-b33
Java Runtime 1.6.0

2017-2018
Suite
 L’aspect le plus utile de la classe System est les variables qu’elle
déclare, qui permettent d’avoir une interaction avec le système.
On y trouve les variables in, out et err.
 La variable in représente le flux d’entrée standard du système,
alors que la variable out représente le flux de sortie standard. La
variable err est le flux d’erreur standard.
 Les flux sont décrits en détail dans la section consacrée au
paquet des E/S.
Exemple:
 System.out.println("File opened...");
 System.err.println("File opening failed:");
 Nous allons voir la variable in dans le chapitre des flux des
entrée-sortie.
2017-2018
Section 6: La classe exception

2017-2018
Présentation [7]
 Une exception est une erreur qui se produit dans un programme
et qui conduit le plus souvent à son arrêt.
 Dans cette section, nous allons gérer/capturer les exceptions.
 Le principe consiste à repérer un morceau de code (par exemple,
une division par zéro) qui pourrait générer une exception, de
capturer l'exception correspondante et enfin de la traiter, c'est-à-
dire d'afficher un message personnalisé et de continuer
l'exécution du programme.
 Java contient une classe nommée Exception dans laquelle sont
répertoriés différents cas d'erreurs.

2017-2018
 Le bloc try{...} catch{...} [7]
 Exemple:
int j = 20, i = 0;
System.out.println(j/i);
System.out.println("Salam à tous!");
 L’exécution de ce code fait apparaître sur la console un message
d'erreur Java (en rouge) comme celui de la figure suivante.

 Lorsque l'exception a été levée, le programme s'est arrêté !

 D'après le message affiché dans la console, le nom de l'exception qui a
été déclenchée est ArithmeticException.
Définition [8]: Un thread désigne un point d'exécution dans le programme. En fait, le
langage Java est multi-thread, c'est à dire qu'il peut exécuter du code à plusieurs
endroits de façon indépendante. Exemple : dans un traitement de texte, un thread
s'occupe de ce que tape l'utilisateur, un 2017-2018
autre est en charge de souligner les erreurs.
 Nouvelle écriture
 Nous allons capturer l’erreur avec un bloc try{…}catch{…}, puis réaliser
un traitement en conséquence.
public static void main(String[] args) {
int j = 20, i = 0; // initialiser deux variables de type int
try {
System.out.println(j/i); // isoler le code susceptible de lever une exception.
} catch (ArithmeticException e) { // le code lève une exception, e est un objet.
System.out.println("Division par zéro !"); // code à exécuter en cas d’erreur
}
System.out.println("Salam à tous !");
}
 Résultat:

2017-2018
Explications
 Déroulement du programme:
 Nous initialisons deux variables de type int, l'une à 0 (i=0) et
l'autre à un nombre quelconque (j=20).
 Nous isolons le code susceptible de lever une exception:
System.out.println(j/i);.
 Une exception de type ArithmeticException est levée lorsque le
programme atteint cette ligne.
 Le bloc catch contient justement un objet de type
ArithmeticException en paramètre. Nous l'avons appelé e.
 L'exception étant capturée, l'instruction du bloc catch s'exécute !
 Le message d'erreur personnalisé s'affiche alors à l'écran.

2017-2018
 Remarque [7]
 L'objet -e- de la clause catch peut servir à préciser notre message grâce
à l'appel de la méthode getMessage() ou printStackTrace().

Méthodes
String getMessage( )
void printStackTrace( )
void printStackTrace(PrintStream s)
Rôle
lecture du message d’erreur.
affiche l'exception et l'état de la pile
d'exécution au moment de son appel.
Idem mais envoie le résultat dans un flux.

Exemple:
System.out.println(e.getMessage()); // il affiche: / by zero
e.printStackTrace(); // il affiche

2017-2018
 La clause finally [7]
public static void main(String[] args){
try {
System.out.println(1/0);
} catch (ArithmeticException e) {
System.out.println("Division par zéro !" + e.getMessage()); //e.printStackTrace();
}
finally{
System.out.println("action faite systématiquement");
}
}
 Grâce à la clause finally, un morceau du code est exécuté quoi qu'il arrive. Cela est
surtout utilisé lorsque vous devez vous assurer d'avoir fermé un fichier, une
connexion à une base de données ou un socket (une connexion réseau).

2017-2018
 Les exceptions personnalisées
 Nous allons créer une classe Ville pour créer des objets de cette
classe.

 La classe Ville contient les attributs: ville, pays, nbreHabitants.

 Lors de la création d’objets de la classe Ville, nous allons mettre en

œuvre une exception afin d'interdire la création d'un objet Ville avec
un nombre d'habitants négatif.

2017-2018
 La classe Ville
 Exemple:
public class Ville {
private String ville;
private String pays;
private long nbreHabitants;
public Ville(){ // constructeur sans paramètres / constructeur par défaut
ville="Inconnue";
pays="Inconnu";
nbreHabitants=0;
}
public Ville(String ville,String pays, long nbreHabitants ){ //constructeur avec param
this.ville = ville ;
this.pays = pays ;
this.nbreHabitants = nbreHabitants ;
}
} 2017-2018
 Suite
public String getville(){
return ville;
}
public String getpays(){
return pays;
}
public long getnbreHabitants(){
return nbreHabitants;
}
public String toString(){ // ressemble à la méthode présentation
return "La ville " + getville() + " se trouve au " + getpays() + " et elle a " +
getnbreHabitants() + " habitants";
}
}
Remarque: toString() est une méthode prédéfinie en Java, nous allons la
surcharger pour afficher la description de la ville.
2017-2018
Démarche
L’exception à traiter: nombre d’habitants négatif.

 Pour interdire la création d'un objet Ville avec un nombre

d'habitants négatif, nous allons suivre les étapes suivantes:
1) créer une classe héritant de la classe Exception:
NombreHabitantException (par convention, les exceptions ont
un nom se terminant par « Exception ») ;
2) capturer l’erreur et renvoyer l'exception levée à notre classe
NombreHabitantException;
3) ensuite, gérer les exceptions qui pourraient survenir avec un
bloc try{…}catch{…}.

2017-2018
 Etape 1
 La classe NombreHabitantException hérite de la classe Exception :

class NombreHabitantException extends Exception{

public NombreHabitantException(){
System.out.println("Vous utilisez un nombre d'habitants négatif !");
}
}

2017-2018
 Etape 2
 Dans le constructeur avec paramètres de la classe Ville : "si l'utilisateur
crée une instance de Ville avec un nombre d'habitants négatif, créer
un objet de type NombreHabitantException".

public Ville(String ville,String pays, long nbreHabitants) throws NombreHabitantException {

if(nbreHabitant < 0)
throw new NombreHabitantException();
else {
this.ville = ville ;
this.pays = pays ;
this.nbreHabitants = nbreHabitants ;
}
}

2017-2018
Remarques
 throws NombreHabitantException nous indique que si une erreur est
capturée (if(nbreHabitant < 0)), celle-ci sera traitée en tant qu'objet de
la classe NombreHabitantException. Elle indique aussi à la JVM que
le constructeur de notre objet Ville est potentiellement dangereux et
qu'il faudra gérer les exceptions possibles.
 throws : ce mot clé permet de signaler à la JVM qu'un morceau de
code (une méthode, une classe, etc) est potentiellement dangereux et
qu'il faut utiliser un bloc try{…}catch{…}. Il est suivi du nom de la
classe qui va gérer l'exception.
 throw: celui-ci permet tout simplement de lever une exception
manuellement en instanciant un objet de type Exception (ou un objet
hérité). Dans l'exemple de notre ArithmeticException, il y a quelque
part dans les détours de Java un throw new ArithmeticException().
2017-2018
 Etape 3
 On gère les exceptions qui pourraient survenir dans cette instruction
avec un bloc try{…}catch{…}

public static void main(String[] args) {

Ville v = null; // v est utilisée partout dans la méthode main
try {
v = new Ville("Meknès","Maroc", 1000000);
} catch (NombreHabitantException e) { }
System.out.println("La ville " + getville() + " se trouve au " + getpays() + " et elle a " +
getnbreHabitants() + " habitants");
}

2017-2018
 Suite
 La méthode main après la surcharge de la méthode toString().

public static void main(String[] args) {

Ville v=null;
try {
v= new Ville("Meknès","Maroc", 1000000);
} catch (NombreHabitantException e) {
e.printStackTrace();
}
System.out.println(v.toString());
}

2017-2018
 Exemple
 En remplaçant « 1000000 » par « -1000000 » dans la création de l’objet v,
l’exception est levée pour le nombre d'habitants négatif, puis on obtient
aussi une NullPointerException.

 Explication:
1) Lorsqu’on a ajouté un nombre d’habitants négatif, une exception est levée
et l'instanciation de v a échoué !
2) La clause catch{} capture l’erreur et un objet NombreHabitantException
est créé.
3) A l'instruction «System.out.println(v.toString());», l’objet v est null !
4) Donc, une NullPointerException est donc levée !
2017-2018
 Meilleure solution
 Pour résoudre ce problème, on utilise la clause finally avec, à l'intérieur,
l'instanciation d'un objet Ville par défaut si celui-ci est null :
public static void main(String[] args) {
Ville v = null;
try {
v = new Ville("Meknès", "Maroc", -1000000);
} catch (NombreHabitantException e) { }
finally{
if(v == null)
v = new Ville(); // ce code n'est pas dangereux. Le nombre est initialisé à 0.
}
System.out.println(v.toString());
}

2017-2018
 Programme complet
1) La classe NombreHabitantException:

public class NombreHabitantException extends Exception{

public NombreHabitantException(){
System.out.println("Vous utilisez un nombre
d'habitants négatif !");
}
}

2017-2018
2) La classe Ville:

public class Ville {

private String ville;
private String pays;
private long nbreHabitants;

public Ville(){ // constructeur sans paramètres / par défaut

ville="Inconnue";
pays="Inconnu";
nbreHabitants=0;
}

2017-2018
public Ville(String ville,String pays, long nbreHabitants )
throws NombreHabitantException{ //constructeur avec param
if(nbreHabitants < 0)
throw new NombreHabitantException();
else {
this.ville = ville ;
this.pays = pays ;
this.nbreHabitants = nbreHabitants ;
}
}

2017-2018
public String getville(){
return ville;
}

public String getpays(){

return pays;
}

public long getnbreHabitants(){

return nbreHabitants;
}

public String toString(){ // ressemble à présentation()

return "La ville "+getville()+ " se trouve au " + getpays()
+ " et elle a " + getnbreHabitants() + " habitants";
}

2017-2018
 public static void main(String[] args) {
Ville v = null, w = null; // 2 objets Ville
try {
v = new Ville("Meknès", "Maroc", 1000000);
w = new Ville("Fès", "Maroc", -1000000);
} catch (NombreHabitantException e) { }
finally{
if(v == null) v = new Ville(); //Le nombre est initialisé à 0
if(w == null) w = new Ville();
}
System.out.println(v.toString());
System.out.println(w.toString());
}
} // fermeture de la classe Ville

2017-2018
 Gestion de plusieurs exceptions [7]
 Supposons que nous voulons lever une deuxième exception si le nom de
la ville fait moins de 3 caractères.
 Nous allons répéter les 3 étapes précédentes sur le nom de la ville.
 Etape 1: création de la classe NomVilleException:
public class NomVilleException extends Exception {
public NomVilleException(String message){
super(message);
}
}
 utilisé super ? Avec cette surcharge du constructeur, nous pourrons
afficher notre message d'erreur en utilisant la méthode getMessage().

2017-2018
Etape 2: Réécriture du constructeur
 Réécriture du constructeur avec paramètres de la classe ville:

public Ville(String ville, String pays, long nbreHabitants) throws

NombreHabitantException, NomVilleException{
if(nbreHabitants < 0)
throw new NombreHabitantException();
if(ville.length() < 3)
throw new NomVilleException("le nom de la ville est inférieur à 3
caractères ! nom = " + ville);
else {
this.ville = ville ;
this.pays = pays ;
this.nbreHabitants = nbreHabitants ;
}
2017-2018
}
 Etape 3: Gestion des 2 exceptions
 public static void main(String[] args) {
Ville v = null;
try {
v = new Ville("Me", "Maroc", 1000000);
}
catch (NombreHabitantException e1) { //Gestion du nombre d'habitants
e1.printStackTrace();
}
catch(NomVilleException e2){ //Gestion de l'exception sur le nom de la ville
System.out.println(e2.getMessage());
}
finally{
if(v == null) v = new Ville();
}
System.out.println(v.toString());
}
2017-2018
 Joindre les 2 exceptions
 public static void main(String[] args) {
Ville v = null;
try {
v = new Ville("Me", "Maroc", -1000000);
}
catch (NombreHabitantException e1) { e1.printStackTrace(); }
catch(NomVilleException e2){ System.out.println(e2.getMessage()); }
finally{
if(v == null) v = new Ville();
}
System.out.println(v.toString());
}

2017-2018
 Multi-catch [7]
 Depuis Java 7, il est possible de catcher plusieurs exceptions dans une seule
instruction catch. Ceci se fait grâce à l'opérateur « | » qui permet d'informer la JVM
que le bloc de code est susceptible d'engendrer plusieurs types d'exception.
public static void main(String[] args){
Ville v = null;
try {
v = new Ville("Ca", "Maroc", 4000000);
}
//Gestion de plusieurs exceptions différentes
catch (NombreHabitantException | NomVilleException e){
System.out.println(e.getMessage());
}
finally{
if(v == null) v = new Ville();
}
System.out.println(v.toString());
2017-2018
}
 Références
[1] : http://refg.tu-sofia.bg/JavaCours/OOP.html
[2] : http://imss-www.upmf-
grenoble.fr/prevert/Prog/Java/CoursJava/ChainesDeCaracteres.html
[3] : http://www.i3s.unice.fr/~riveill/cours/langage/99-java-intro.pdf
[4]: http://blog.paumard.org/cours/java/chap03-object-string-string.html
[5] : http://imss-www.upmf-grenoble.fr/prevert/Prog/Java/CoursJava/enveloppes.html
[6]: http://www.coderanch.com/t/377888/java/java/intValue-ParseInt
[7]: http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-en-
java/les-exceptions
[8]: http://java.developpez.com/faq/java/?page=langage_threads

2017-2018