Fiche de Révision : Java

Table des matières

1 Le Casting (Conversion de type) 2

2 Comparaison et Égalité 2

3 Scanning (Entrées Utilisateur) 2

4 Les Boucles (Loops) 3

5 Les Tableaux (Arrays) 4

6 ArrayList (Tableau Dynamique) 5

7 LinkedList (Liste Chaînée) 6

8 Les Méthodes (Fonctions) 6

9 Les Méthodes Statiques (static) 7

10 Classes et Objets (POO) 8

11 Modificateurs et Mot-clé Static 9

12 Le Polymorphisme 10

13 L’Héritage 11

14 Comprendre les Relations UML (Pour l’Examen) 12

15 Les Classes Abstraites (abstract) 13

16 Les Interfaces 14

17 Gestion des Exceptions (Erreurs) 15

18 La Génération Aléatoire (Random) 16

19 La Méthode toString() 16

20 Validation dans le Constructeur 17

1
1 Le Casting (Conversion de type)
Définition : Le casting est le procédé qui consiste à convertir une valeur d’un type de données
vers un autre type (primitif ou objet).

Les manipulations principales

— 1. Widening Casting (Implicite) : Passage d’un petit type vers un plus grand type.
Se fait automatiquement sans perte de données.
int monInt = 9;
double monDouble = monInt ; // Devient 9.0 automatiquement

— 2. Narrowing Casting (Explicite) : Passage d’un grand type vers un plus petit type.
Doit être fait manuellement avec (type) car il y a risque de perte de données.
double monDouble = 9.78;
int monInt = ( int ) monDouble ; // Devient 9 ( partie decimale
tronquee )

— 3. Casting d’Objets (Polymorphisme) :

// Upcasting ( Implicite : Enfant vers Parent )
Object obj = new String ( " Bonjour " ) ;

// Downcasting ( Explicite : Parent vers Enfant )

if ( obj instanceof String ) {
String str = ( String ) obj ;
}

— 4. Parsing (String vers Primitif ) : Utilisation des classes Wrapper.

String texte = " 123 " ;
int nombre = Integer . parseInt ( texte ) ;

2 Comparaison et Égalité
Principe : En Java, il faut distinguer la comparaison d’identité (mémoire) de la comparaison
de contenu.

Égalité : == vs .equals()
— == : Compare les références mémoire (adresses) pour les objets, ou les valeurs brutes
pour les types primitifs.
— .equals() : Compare le contenu sémantique des objets (doit être redéfinie pour les
classes personnalisées).
String s1 = " Java " ;
String s2 = new String ( " Java " ) ; // Nouvelle reference memoire

// Comparaison
boolean ref = ( s1 == s2 ) ; // false ( adresses differentes )
boolean val = s1 . equals ( s2 ) ; // true ( contenu identique )

3 Scanning (Entrées Utilisateur)

Outil : La classe [Link] permet de lire l’entrée standard ([Link]).

2
Différence : next() vs nextLine()
— next() : Lit la chaîne jusqu’au premier séparateur (espace, tabulation). Le curseur
reste sur la même ligne si d’autres mots suivent.
— nextLine() : Lit toute la ligne restante jusqu’au saut de ligne (\n) et positionne le
curseur à la ligne suivante.
Scanner sc = new Scanner ( System . in ) ;

// Entree utilisateur : " Hello World "

String a = sc . next () ; // Lit " Hello "
String b = sc . nextLine () ; // Lit " World " ( le reste )

Le Piège du Buffer (nextInt + nextLine)

Si vous utilisez nextInt() (ou next()) avant nextLine(), le caractère "Entrée" (\n) reste
dans le buffer et est consommé immédiatement par le nextLine() suivant, qui semble alors être
ignoré.
Solution : Consommer le saut de ligne restant manuellement.
System . out . print ( " Age : ␣ " ) ;
int age = sc . nextInt () ;
// Ici , le \ n est encore dans le buffer

// SOLUTION : Vider le buffer

sc . nextLine () ;

System . out . print ( " Nom : ␣ " ) ;

String nom = sc . nextLine () ; // Fonctionne correctement maintenant

4 Les Boucles (Loops)

Principe : Exécuter un bloc de code de manière répétée.

1. La Boucle For (Nombre d’itérations connu)

— For Classique : Utilise un index.
for ( int i = 0; i < 5; i ++) {
System . out . println ( " Index ␣ : ␣ " + i ) ;
}

— For-Each (Enhanced For) : Pour parcourir tableaux ou collections sans index.

String [] fruits = { " Pomme " , " Poire " };
for ( String f : fruits ) {
System . out . println ( f ) ;
}

2. La Boucle While (Conditionnelle)

— While : La condition est vérifiée avant l’exécution. Si faux dès le début, le code ne
s’exécute jamais.
int i = 0;
while ( i < 5) {
System . out . println ( i ) ;
i ++;
}

3
 — Do-While : Le code s’exécute au moins une fois, car la condition est vérifiée après.
int i = 0;
do {
System . out . println ( i ) ;
i ++;
} while ( i < 5) ;

3. Contrôle de flux
— break : Stoppe immédiatement la boucle entière.
— continue : Saute l’itération actuelle et passe à la suivante.

5 Les Tableaux (Arrays)

Définition : Structure de données de taille fixe stockant des éléments du même type.

1. Déclaration et Initialisation

// Methode A : Taille definie ( valeurs par defaut : 0 , null , false )

int [] tab = new int [5];

// Methode B : Remplissage direct

String [] fruits = { " Pomme " , " Poire " , " Banane " };

2. Manipulation et Propriétés
Attention : La taille se récupère via la propriété .length (sans parenthèses), contrairement
aux Strings (.length()).
tab [0] = 42; // Modification ( Index commence a 0)
int x = tab [0]; // Acces
int taille = tab . length ; // Taille du tableau

3. La classe utilitaire [Link]

Les tableaux natifs sont limités. On utilise cette classe statique pour les opérations complexes.
int [] nombres = {5 , 1 , 3 , 2};

// 1. Affichage ( Indispensable car sysout ( tab ) affiche l ’ adresse )

System . out . println ( Arrays . toString ( nombres ) ) ; // "[5 , 1 , 3 , 2]"

// 2. Tri ( Modifie le tableau original !)

Arrays . sort ( nombres ) ; // nombres devient {1 , 2 , 3 , 5}

// 3. Recherche binaire ( Le tableau DOIT etre trie avant )

int index = Arrays . binarySearch ( nombres , 3) ;

4. Tableaux Multidimensionnels (Matrices)

// Tableau de tableaux
int [][] matrice = {
{1 , 2 , 3} ,
{4 , 5 , 6}
};

4
int val = matrice [1][0]; // Ligne 1 , Colonne 0 -> Valeur 4

6 ArrayList (Tableau Dynamique)

Principe : Une liste redimensionnable automatiquement. Elle ne stocke que des Objets (pas
de types primitifs).
Package : [Link]

1. Déclaration et Wrappers
Pour stocker des primitifs (int, double), il faut utiliser leurs classes Wrappers (Integer,
Double).
// Correct ( Inference de type avec < >)
ArrayList < String > noms = new ArrayList < >() ;
ArrayList < Integer > notes = new ArrayList < >() ;

// INCORRECT : ArrayList < int > est impossible !

2. Méthodes Principales (CRUD)

ArrayList < String > list = new ArrayList < >() ;

// AJOUT
list . add ( " Java " ) ; // Ajoute a la fin
list . add (0 , " Python " ) ; // Insere a l ’ index 0 ( decale le reste a
droite )

// LECTURE
String val = list . get (1) ; // Acces par index ( equivalent a tab [1])
int taille = list . size () ; // ATTENTION : . size () et non . length

// MODIFICATION
list . set (0 , " C ++ " ) ; // Remplace l ’ element a l ’ index 0

// SUPPRESSION
list . remove (1) ; // Supprime par index
list . remove ( " Java " ) ; // Supprime la 1 ere occurrence de l ’ objet
list . clear () ; // Vide toute la liste

3. Autres manipulations utiles

// Verification
boolean existe = list . contains ( " Java " ) ;
boolean vide = list . isEmpty () ;

// Tri ( Necessite la classe Collections )

Collections . sort ( list ) ; // Tri croissant / alphabetique

// Conversion Liste -> Tableau

String [] tab = list . toArray ( new String [0]) ;

5
7 LinkedList (Liste Chaînée)
Définition : Une liste doublement chaînée. Chaque élément (Node) stocke sa donnée et
l’adresse de l’élément suivant et précédent.
Package : [Link]

1. ArrayList vs LinkedList (La Question d’Exam)

C’est la distinction théorique fondamentale.

Opération ArrayList LinkedList

Accès (get) Rapide (Immédiat) Lent (Doit tout parcourir)
Insertion/Suppr Lent (Décalage mémoire) Rapide (Juste changer les liens)
Usage idéal Lecture fréquente Ajout/Retrait fréquent

2. Méthodes Spécifiques et Classiques

La LinkedList combine les méthodes de l’interface List (accès par index) et celles de Deque
(manipulation des extrémités).
LinkedList < String > train = new LinkedList < >() ;

// 1. AJOUT ( Insertion )
train . add ( " Wagon " ) ; // Ajoute a la fin
train . add (0 , " Locomotive " ) ; // Ajoute a l ’ index specifique
train . addFirst ( " Radar " ) ; // Ajoute au tout debut
train . addLast ( " Queue " ) ; // Ajoute a la toute fin

// 2. SUPPRESSION
train . remove (1) ; // Supprime l ’ element a l ’ index 1 (" Wagon ")
train . remove () ; // Supprime le PREMIER element ( tete de liste )
train . removeFirst () ; // Identique a remove () : supprime le premier
train . removeLast () ; // Supprime le DERNIER element

// 3. NETTOYAGE
train . clear () ; // Vide completement la liste ( size = 0)

3. Fonctionnalité de Pile/File (Stack/Queue)

Grâce à ces méthodes, la LinkedList est souvent utilisée pour implémenter des structures de
données :
— Pile (Stack) : LIFO (Last In First Out) Ñ push() / pop()
— File (Queue) : FIFO (First In First Out) Ñ offer() / poll()

8 Les Méthodes (Fonctions)

Définition : Bloc de code réutilisable qui ne s’exécute que lorsqu’il est appelé.

1. Structure d’une méthode

// Modificateur | Retour | Nom ( Parametres )

public static int additionner ( int a , int b ) {
return a + b ; // Renvoie une valeur ( type int )
}
// Note : Si la methode ne renvoie rien , le type est ’ void ’.

6
2. Dans le fichier Main (Le contexte Static)
La méthode main est toujours static. Par conséquent, toute méthode définie dans la même
classe et appelée directement depuis le main doit aussi être static.
public class Main {

// 1. Methode STATIC : Appel direct possible

static void maMethodeStatic () {
System . out . println ( " Je ␣ suis ␣ static ␣ ! " ) ;
}

// 2. Methode NON - STATIC : Necessite un objet

void maMethodeObjet () {
System . out . println ( " J ’ ai ␣ besoin ␣ d ’ une ␣ instance ␣ ! " ) ;
}

public static void main ( String [] args ) {

// Appel direct ( Ok car les deux sont static )
maMethodeStatic () ;

// maMethodeObjet () ; // ERREUR de compilation !

// Solution pour la non - static : creer un objet

Main obj = new Main () ;
obj . maMethodeObjet () ;
}
}

3. La Surcharge (Method Overloading)

Plusieurs méthodes peuvent avoir le même nom si leurs paramètres sont différents
(nombre ou type).
static int plus ( int x , int y ) { return x + y ; }
static double plus ( double x , double y ) { return x + y ; }

// Java choisit automatiquement la bonne version selon les arguments

9 Les Méthodes Statiques (static)

Définition : Une méthode static appartient à la classe entière. Elle s’exécute sans qu’aucun
objet ne soit créé.

1. Syntaxe d’appel
On l’appelle via le NomDeLaClasse, sans faire de new.
public class Outils {
public static int carre ( int x ) {
return x * x ;
}
}

// --- Dans le Main ---

// Correct ( Appel via la classe )
int res = Outils . carre (5) ;

// Inutile ( mais possible ) de creer un objet pour ca

7
Outils obj = new Outils () ;
obj . carre (5) ; // Mauvaise pratique

2. La Règle d’Or (Restrictions)

C’est l’erreur la plus fréquente : Une méthode statique vit dans un contexte "global".
— Elle NE PEUT PAS accéder aux variables d’instance (non-static).
— Elle NE PEUT PAS utiliser le mot-clé this.
public class Exemple {
int age = 20; // Variable d ’ instance ( liee a un objet )

public static void test () {

// ERREUR DE COMPILATION !
// System . out . println ( age ) ;
// Message : " Cannot make a static reference to the non - static
field age "
}
}

3. Exemples courants
Les méthodes de la classe Math sont toutes statiques : [Link](-5), [Link](25), [Link]().

10 Classes et Objets (POO)

Concept : Une Classe est un plan (blueprint). Un Objet est une instance concrète de ce
plan.

1. Structure d’une Classe (L’Exemple Complet)

Voici une classe standard respectant l’encapsulation.
public class Etudiant {
// A . ATTRIBUTS ( Instance Variables )
// Private = Accessible uniquement dans cette classe ( Encapsulation )
private String nom ;
private int age ;

// B . CONSTRUCTEUR
// - Meme nom que la classe
// - Pas de type de retour ( meme pas void )
// - S ’ execute automatiquement au " new "
public Etudiant ( String nom , int age ) {
// C . Mot - cle " THIS "
// this . nom -> refere a l ’ attribut de la classe
// nom -> refere au parametre de la methode
this . nom = nom ;
this . age = age ;
}

// D . GETTERS ( Accesseurs ) - Pour LIRE une valeur private

public String getNom () {
return this . nom ;
}

// E . SETTERS ( Mutateurs ) - Pour MODIFIER une valeur private

public void setNom ( String nom ) {

8
 this . nom = nom ; // On peut ajouter de la validation ici
}
}

2. Création et Utilisation (Dans le Main)

public class Main {

public static void main ( String [] args ) {
// Instanciation ( Appel du Constructeur )
Etudiant e1 = new Etudiant ( " Alice " , 20) ;

// e1 . nom = " Bob "; // ERREUR ! ( car private )

// Utilisation des Getters / Setters

e1 . setNom ( " Bob " ) ; // Modification
System . out . println ( e1 . getNom () ) ; // Lecture
}
}

Résumé des concepts clés

— Encapsulation : Cacher les données (private) et y accéder via des méthodes publiques
(Getters/Setters) pour sécuriser le code.
— this : Référence l’objet courant. Indispensable quand le nom du paramètre est identique
au nom de l’attribut.
— Constructeur : Sert à initialiser l’objet. Si vous n’en écrivez pas, Java crée un construc-
teur vide par défaut.

11 Modificateurs et Mot-clé Static

1. Les Modificateurs d’Accès (Visibilité)
Ils contrôlent où vos classes, méthodes et variables peuvent être utilisées.

Modificateur Classe Package Sous-classe Monde

public OUI OUI OUI OUI
protected OUI OUI OUI NON
(défaut / sans mot-clé) OUI OUI NON NON
private OUI NON NON NON

— private : Le plus restrictif. Visible uniquement dans ‘ ‘ de la classe.

— (défaut) : Visible par toutes les classes du même dossier (package).
— protected : Comme défaut + visible par les enfants (extends) même s’ils sont dans un
autre dossier.
— public : Visible partout.

2. Le mot-clé static
Définition : Ce qui est static appartient à la Classe elle-même, et non à une instance
(objet) spécifique.
— Variable Static (Partagée) : Il n’y a qu’une seule copie en mémoire, partagée par tous
les objets.
— Méthode Static : Peut être appelée sans créer d’objet (ex : [Link]()).

9
class Compteur {
static int global = 0; // Partage par tous
int personnel = 0; // Propre a chaque objet

public Compteur () {
global ++;
personnel ++;
}
}

// Dans le Main
Compteur c1 = new Compteur () ;
Compteur c2 = new Compteur () ;

// c1 . personnel vaut 1 , c2 . personnel vaut 1

// Compteur . global vaut 2 ( car incremente deux fois sur la meme variable
)

12 Le Polymorphisme
Définition : Capacité d’un objet à prendre plusieurs formes. Concrètement : utiliser une
variable de type Parent pour manipuler un objet de type Enfant.

1. Le Mécanisme : L’Overriding (Redéfinition)

La méthode doit être redéfinie dans la classe enfant (avec @Override).
class Animal {
void cri () { System . out . println ( " ... " ) ; }
}

class Chien extends Animal {

@Override // Remplace la methode du parent
void cri () { System . out . println ( " Wouf ␣ ! " ) ; }
}

2. L’Exécution (La Règle d’Or)

C’est le type de l’OBJET réel (après le new) qui décide quelle méthode s’exécute, pas le
type de la variable.
// Reference Type Parent = Objet Type Enfant
Animal monAnimal = new Chien () ;

// Resultat : Execute la version du CHIEN

monAnimal . cri () ; // Affiche " Wouf !"

3. La Restriction (Le Piège)

Le compilateur ne regarde que le Type de la Référence (gauche). Si une méthode n’existe
pas dans le Parent, vous ne pouvez pas l’appeler, même si l’objet réel est un Enfant.
class Chien extends Animal {
void cri () { ... }
void mordre () { ... } // Specifique au chien
}

10
Animal a = new Chien () ;
a . cri () ; // OK ( Defini dans Animal )

// a . mordre () ; // ERREUR COMPILATION ! Animal ne connait pas " mordre "

// Solution : Faire un casting -> (( Chien ) a ) . mordre () ;

13 L’Héritage
Définition : Mécanisme permettant de créer une nouvelle classe (Enfant/Sous-classe) basée
sur une classe existante (Parent/Super-classe). L’enfant récupère tous les attributs et méthodes
(sauf les private) du parent.

1. Syntaxe et Fonctionnement
On utilise le mot-clé extends. Une classe ne peut avoir qu’un seul parent (pas d’héritage
multiple de classes en Java).
// CLASSE PARENT
class Vehicule {
protected int vitesse ; // protected = accessible par l ’ enfant
public void demarrer () { System . out . println ( " Vroum " ) ; }
}

// CLASSE ENFANT ( Recupere ’ vitesse ’ et ’ demarrer ’)

class Voiture extends Vehicule {
String marque ; // Attribut specifique
}

2. Le mot-clé super
Il sert à accéder aux membres du parent.
— [Link]() : Appelle une méthode du parent (utile si elle a été redéfinie/overridden
dans l’enfant).
— super() : Appelle le constructeur du parent.

3. Les Constructeurs et l’Héritage (CRUCIAL)

C’est le piège classique des examens.
1. Lorsqu’on crée un Enfant, Java DOIT d’abord construire le Parent.
2. Si le parent a un constructeur avec paramètres, l’enfant DOIT l’appeler explicitement
via super(...) à la toute première ligne.
class Parent {
String nom ;
// Constructeur avec parametre
public Parent ( String nom ) {
this . nom = nom ;
}
}

class Enfant extends Parent {

int age ;

public Enfant ( String nom , int age ) {

super ( nom ) ; // OBLIGATOIRE : Appel au constructeur parent
this . age = age ;
}

11
}

autre exemple :
Classe parente

class Animal {
void parler () {
System . out . println ( " L ’ animal ␣ fait ␣ un ␣ son . " ) ;
}
}

Classe enfant qui redéfinit la méthode

class Chien extends Animal {

@Override
void parler () {
System . out . println ( " Le ␣ chien ␣ aboie . " ) ;
}

void p a r le r Co m me U n An i ma l () {
super . parler () ; // appel de la m t h o d e de la classe parent
}
}

14 Comprendre les Relations UML (Pour l’Examen)

Pour résoudre un exercice de modélisation, il faut savoir traduire les flèches du schéma en
code Java. Voici les trois cas présents dans votre exercice :

1. L’Héritage (Flèche triangulaire)

Signification : "Est un" (Is-A).
Code : Mot-clé extends.
// " La Voiture est un Vehicule "
public class Voiture extends Vehicule { ... }

2. La Composition (Losange NOIR/PLEIN)

Signification : Relation de vie ou de mort (Forte). La partie ne peut pas exister sans le
tout. Si on détruit le véhicule, on détruit ses roues.
Code : L’objet interne est instancié (new) DANS le constructeur du contenant.
public class Vehicule {
private Roue roue ; // Attribut de type Roue

public Vehicule () {
// C ’ est le Vehicule qui cree sa propre Roue .
// Si le vehicule meurt , la roue disparait avec lui .
this . roue = new Roue () ;
}
}

12
3. L’Agrégation (Losange BLANC/VIDE)
Signification : Relation d’appartenance (Faible). L’objet peut exister ailleurs. Le proprié-
taire existe avant d’avoir une voiture, et existera après l’avoir vendue.
Code : L’objet externe est passé en paramètre (via constructeur ou setter). Il vient de l’ex-
térieur.
public class Vehicule {
private Proprietaire proprietaire ;

// Le proprietaire est cree ailleurs et passe ici .

public void setProprietaire ( Proprietaire p ) {
this . proprietaire = p ;
}
}

Résumé visuel pour l’examen

Symbole Concept Traduction Java
đ (Triangle) Héritage class A extends B
♦ (Noir) Composition this.x = new X(); (Interne)
♢ (Blanc) Agrégation this.x = param_x; (Externe)

15 Les Classes Abstraites (abstract)

Définition : Une classe abstraite est une "ébauche" ou un modèle incomplet. Elle ne peut
pas être utilisée directement pour créer des objets.

1. Les Deux Règles Fondamentales

— Interdiction d’instancier : On ne peut PAS faire new MaClasseAbstraite().
— Contrat pour les enfants : Si la classe contient une méthode abstraite, les classes
enfants DOIVENT obligatoirement fournir le code de cette méthode (l’implémenter),
sinon elles doivent être abstraites aussi.

2. Exemple Concret : La Forme Géométrique

Imaginez une classe Forme. On peut calculer la surface d’un cercle ou d’un carré, mais calculer
la surface d’une "Forme" générique n’a pas de sens mathématique. C’est là qu’on utilise abstract.
// 1. La Classe Abstraite ( Le concept )
abstract class Forme {
// Methode CONCRETE ( Normale ) : Partagee par tous les enfants
void afficherType () {
System . out . println ( " Je ␣ suis ␣ une ␣ forme . " ) ;
}

// Methode ABSTRAITE : Pas de corps { } , juste un point - virgule .

// " Je ne sais pas comment calculer , mais mes enfants le sauront ."
abstract double calculerSurface () ;
}

// 2. La Classe Enfant ( La concretisation )

class Carre extends Forme {
double cote ;

public Carre ( double c ) { this . cote = c ; }

13
 @Override
// OBLIGATOIRE : On doit donner le code ici
double calculerSurface () {
return cote * cote ;
}
}

3. Utilisation (Polymorphisme)
Même si on ne peut pas faire new Forme(), on peut utiliser Forme comme type de variable.
// Forme f = new Forme () ; // INTERDIT ( Erreur compilation )

Forme f = new Carre (5.0) ; // OK ( Polymorphisme )

f . afficherType () ; // Affiche " Je suis une forme "
double s = f . calculerSurface () ; // Calcule 25.0 ( version du Carre )

16 Les Interfaces
Définition : Une interface est un contrat absolu. Elle ne définit que ce que l’objet doit
faire, mais jamais comment il le fait.
Contrairement à l’héritage de classe (limitée à 1 parent), une classe peut implémenter plusieurs
interfaces.

1. Syntaxe et Règles
— Mot-clé : interface pour la définir, implements pour l’utiliser.
— Méthodes : Sont implicitement public abstract (pas de corps { }).
— Variables : Sont implicitement public static final (des constantes).
// 1. Le Contrat ( Interface )
interface Volant {
void decoller () ; // " Tu dois savoir decoller "
}

interface Nageur {
void nager () ; // " Tu dois savoir nager "
}

// 2. L ’ Implementation ( Classe )
// Une classe peut cumuler plusieurs interfaces ( virgule )
public class Canard implements Volant , Nageur {

@Override
public void decoller () {
System . out . println ( " Le ␣ canard ␣ s ’ envole " ) ;
}

@Override
public void nager () {
System . out . println ( " Le ␣ canard ␣ nage " ) ;
}
}

14
2. Le Piège de la Visibilité (Exam Alert)
Dans une interface, les méthodes sont public par défaut.
Dans une classe, si vous oubliez le mot public devant la méthode réécrite, la visibilité devient
"package-private" (plus faible), ce qui provoque une erreur de compilation.
interface Test {
void action () ; // public
}

class Essai implements Test {

// ERREUR : " Cannot reduce the visibility of the inherited method "
void action () { ... }

// CORRECTION :
public void action () { ... }
}

3. Comparaison : Interface vs Classe Abstraite

Critère Classe Abstraite Interface
Relation "Est un" (Identité) "Peut faire" (Capacité)
Méthodes Peut avoir du code concret 100% Abstraites (généralement)
Héritage Un seul parent (extends) Multiples interfaces (implements)
Attributs Tout type (int, String...) Constantes uniquement

17 Gestion des Exceptions (Erreurs)

Principe : Mécanisme permettant de gérer les erreurs d’exécution (runtime) pour éviter que
le programme ne plante brutalement (crash).

1. La structure Try-Catch-Finally
C’est le filet de sécurité de base.
— try : Contient le code "dangereux" susceptible d’échouer.
— catch : Capture l’erreur et exécute le code de secours.
— finally : S’exécute TOUJOURS, qu’il y ait eu une erreur ou non (utile pour fermer des
fichiers, connexions BDD, etc.).
try {
String txt = null ;
System . out . println ( txt . length () ) ; // Provoque N ul l P o i n t e r E x c e p t i o n
}
catch ( N ul l P o i n t e r E xc e p t i o n e ) {
System . out . println ( " Erreur ␣ capturee ␣ : ␣ " + e . getMessage () ) ;
}
finally {
System . out . println ( " Ce ␣ message ␣ s ’ affiche ␣ quoiqu ’ il ␣ arrive . " ) ;
}

2. Throw vs Throws (Confusion fréquente)

— throw (L’action) : Sert à déclencher manuellement une exception.
— throws (La déclaration) : Se place dans la signature de la méthode pour avertir que cette
méthode est dangereuse.

15
// 1. On signale le danger avec " throws "
public void verifierAge ( int age ) throws Exception {
if ( age < 18) {
// 2. On declenche l ’ erreur avec " throw "
throw new Exception ( " Acces ␣ refuse ␣ : ␣ Mineur " ) ;
}
}

3. Types d’Exceptions (Hiérarchie)

1. Unchecked Exceptions (RuntimeException) :
Exemples : ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsExcep-
tion.
Le compilateur ne vous oblige pas à les gérer. Elles indiquent souvent un bug de logique.
2. Checked Exceptions (Exception) :
Exemples : IOException, SQLException.
Le compilateur oblige (souligne en rouge) à mettre un try-catch ou à ajouter throws.
Ce sont des erreurs externes au programme.

18 La Génération Aléatoire (Random)

Outil : La classe [Link] permet de générer des valeurs aléatoires (int, double,
boolean).

1. Méthodes Principales
— nextInt() : Un entier quelconque (positif ou négatif).
— nextInt(n) : Un entier entre 0 (inclus) et n (exclu).
— nextDouble() : Un décimal entre 0.0 et 1.0.

2. Exemple et Formule de plage [Min, Max]

Pour obtenir un nombre entre 5 et 10 (inclus), il faut appliquer une petite formule mathé-
matique.
import java . util . Random ;

Random rand = new Random () ;

// A . Basique : Entre 0 et 99
int x = rand . nextInt (100) ;

// B . Plage specifique [ Min , Max ]

// Formule : rand . nextInt (( Max - Min ) + 1) + Min ;
int min = 5;
int max = 10;
int y = rand . nextInt (( max - min ) + 1) + min ;

System . out . println ( " Valeur ␣ : ␣ " + y ) ;

19 La Méthode toString()
Problème : Par défaut, si vous affichez un objet avec [Link](obj), Java
affiche son adresse mémoire (ex : Etudiant@15db9742). Ce n’est pas lisible.

16
 Solution : Il faut redéfinir (Override) la méthode toString() héritée de la classe Object
pour retourner une chaîne de caractères descriptive.

1. Implémentation
On place cette méthode à l’intérieur de la classe.
public class Livre {
String titre ;
double prix ;

public Livre ( String titre , double prix ) {

this . titre = titre ;
this . prix = prix ;
}

// On redefinit la methode par defaut

@Override
public String toString () {
return " Livre ␣ [ Titre = " + titre + " ,␣ Prix = " + prix + " $ ] " ;
}
}

2. Résultat Avant / Après

public class Main {

public static void main ( String [] args ) {
Livre b = new Livre ( " Harry ␣ Potter " , 20.0) ;

// SANS la methode toString ( Par defaut ) :

// Affiche : " Livre@6d06d69c "

// AVEC la methode toString ci - dessus :

System . out . println ( b ) ;
// Affiche : " Livre [ Titre = Harry Potter , Prix =20.0 $ ]"
}
}

20 Validation dans le Constructeur

Principe : Un objet ne doit jamais être créé dans un état incohérent (ex : âge négatif, nom
vide).
Pour éviter cela, on vérifie les paramètres au tout début du constructeur. Si une valeur est
invalide, on lance une exception avec throw pour stopper immédiatement la création de
l’objet.

1. Implémentation (Le "Gardien")

L’exception la plus courante pour ce cas est IllegalArgumentException (Unchecked).
public class CompteBancaire {
private double solde ;

public CompteBancaire ( double soldeInitial ) {

// Etape 1 : Validation
if ( soldeInitial < 0) {
// Si invalide , on lance l ’ erreur .
// Le constructeur s ’ arrete ICI . L ’ objet n ’ est PAS cree .

17
 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Le ␣ solde ␣ de ␣ depart ␣ ne ␣
peut ␣ pas ␣ etre ␣ negatif ␣ ! " ) ;
}

// Etape 2 : Affectation ( Seulement si Etape 1 est OK )

this . solde = soldeInitial ;
}
}

2. Conséquence dans le Main

Si l’exception est lancée, la ligne new échoue. La variable ne référencera aucun objet.
public static void main ( String [] args ) {
try {
// Tentative de creation avec valeur interdite
CompteBancaire c = new CompteBancaire ( -100.0) ;
System . out . println ( " Compte ␣ cree ␣ ! " ) ; // Ne s ’ affichera JAMAIS
}
catch ( I l l e g a l A r g u m e n t E x c e p t i o n e ) {
System . out . println ( " Erreur ␣ : ␣ " + e . getMessage () ) ;
// Affiche : " Erreur : Le solde de depart ne peut pas etre
negatif !"
}
}

18