Structure générale d'un programme java

// 1. Déclaration du package (facultative si non utilisé)

package monpackage; Les packages en Java sont des conteneurs
qui regroupent des classes, interfaces et sous-
// 2. Import des bibliothèques nécessaires packages. Ils servent à organiser les fichiers
import [Link]; source et à éviter les conflits de noms entre
différentes classes. Un package peut être vu
// 3. Déclaration de la classe principale comme un répertoire dans lequel les fichiers
public class MonProgramme { sont organisés.

// 4. Méthode principale : point d’entrée du programme

public static void main(String[] args) {

// 5. Instructions du programme
[Link]("Bonjour, monde !");

}
}
public class Point
{
Encapsulation des
private int x ; // 
private int y ; //  données (private)
attribut : propre à chaque instance // Variable d’instance
attribut : propre à chaque instance // Variable d’instance

// Les méthodes de la classe

public void initialise (int abs, int ord) {x = abs ;y = ord ;}

public void deplace (int dx, int dy) {x += dx ;y += dy ;}

public void affiche () {[Link] ("Les coordonnees " + x + " " + y) ; }

}
L'encapsulation est un concept de programmation orientée objet qui consiste à cacher les
détails internes d'une classe et à ne permettre l'accès aux données qu'à travers des
méthodes publiques (getters et setters).
Cela garantit que les données sont modifiées uniquement de manière contrôlée.
 Comment utilisé la classe Point constructeur
Soit la classe Point Depuis un autre classe
dispose de la méthode main()
Point a = new Point();
Réservation d’emplacement pour une L’emplacement pour l’objet
référence à un objet de type Point. proprement dit sera alloué sur une
demande explicite
public class Point
{

private int x ; // 
private int y ; // 
attribut : propre à chaque instance // Variable d’instance
attribut : propre à chaque instance // Variable d’instance
x
// Les méthodes de la classe
public void initialise (int abs, int ord) {x = abs ;y = ord ;} a
public void deplace

public void affiche () {

(int dx, int dy) {x += dx ;y += dy ;}

[Link] ("Les coordonnees " + x + " " + y) ; }

y
} a.x = 10 ; // erreur : x est privé
 La notion de constructeur
La notion de constructeur permet: Public Point (int abs, int ord)
d’automatiser le mécanisme d’initialisation d’un objet (valeurs {
initiales , toute actions utiles au bon fonctionnement de l’objet. x = abs ;
Un constructeur n’est rien d’autre qu’une méthode, sans y = ord ;
valeur de retour, portant le même nom que la classe. Il
peut disposer d’un nombre quelconque d’arguments
} Error
(éventuellement aucun). Point a = new Point() ;
 Il est appelé automatiquement quand on crée un objet à partir du moment où une
classe dispose d’un
avec new. constructeur, il n’est plus
possible de créer un objet
sans l’appeler.
Point a = new Point(2, 5);
 le mot-clé this
Le mot-clé this fait référence à l’instance courante de la classe dans laquelle il est utilisé. Il peut
être utilisé dans plusieurs contextes :
class Personne {
String nom;

public Personne(String nom) {

[Link] = nom; // '[Link]' fait référence à l'attribut de la classe
}

public Personne() {
this("inconnu"); // 'this' Appeler un autre constructeur dans la
même classe
}

}
doit être la première instruction
 L’héritage
il permet de définir une nouvelle classe, dite classe dérivée,
à partir d’une classe existante dite classe de base.

 Elle pourra modifier ou compléter à volonté

 Une classe dérivée pourra à son tour servir de classe de base
pour une nouvelle classe dérivée.

extends
class Point {
public void initialise (int abs, int ord) { x = abs ; y = ord ; }
super-classe
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public void affiche () { [Link] (« coord" + x + " " + y) ; }
private int x, y ; les membres privés de la classe de base
} ne sont pas membres privés de la classe dérivée.
Point_color  Point + couleur()

class Point_color extends Point {

public void couleur (char couleur) { [Link] = couleur ; }
private char couleur ; } sous-classe
Point_color pc = new Point_color() ;
[Link]() ; [Link] (3, 5) ; [Link] (‘a’) ; [Link]() ;

Un objet d’une classe dérivée accède aux membres publics de sa classe de base
Appels des constructeurs On peux pas combiner this() et super()
dans le même constructeur.
En Java, lorsqu’une classe hérite d’une autre, le constructeur de la classe mère est
appelé automatiquement AVANT celui de la classe fille.
class A { class A {
public A() { public A(String nom) {
S.o.p("Constructeur class A"); S.o.p("Constructeur class A : " + nom);
} }
} } Constructeur class A : ABC
class B extends A { Constructeur class B
public class B extends A {
public B() {
super(); public B() {
S.o.p("Constructeur class B"); super("ABC"); // Appelle explicitement le
} constructeur parent
} S.o.p("Constructeur class B");
Constructeur class A }
Constructeur class B public static void main(String[] args) {new B();}
}
Règle 1: Si un constructeur d’une classe dérivée appelle un constructeur d’une classe de base, il
doit obligatoirement s’agir de la première instruction du constructeur et ce dernier est
désigné par le mot-clé super.
 CAS 3 : Classe A avec constructeur avec paramètre
CAS 1 : Classe A sans constructeur déclaré seulement
class A { class A {
// Aucun constructeur déclaré → Java en ajoute un vide public A(String nom) {…}
}
public class B extends A {  public A() {…}
public B() {
super(); // Appelé automatiquement ici, même si tu ne }
l’écris pas
} class B extends A {
public B() {
CAS 2 : Classe A avec constructeur vide déclaré super("Bonjour"); // Obligatoire
class A {
public A() {…} super() automatique échoue car
} il n’existe pas de constructeur vide
public class B extends A { dans A
public B() {…}
} }
}
 super
Le mot-clé super permet d'accéder aux membres (attributs et méthodes) d’une super-
classe (classe parente). Il est utilisé dans le contexte de l’héritage
Accéder à un constructeur de la super-classe : Accéder à une méthode ou un attribut de la super-
classe
class Personne { class Personne {
public Personne (String nom) { public int X=1;
[Link]("Personne: " + nom); public void affiche() {
} [Link]("class Personne ");
} }
}
class Etudiant extends Personne {
public Etudiant (String nom) { class Etudiant extends Personne {
public int X=2; //Duplication des champs
super(nom); // Appel au public void affiche() {
constructeur de la
super. affiche (); // Appel à la
super-classe
méthode de la super-classe
}
[Link](X +""+super.X);
}
}
}
class Point { Pointol P = new Pointol(); P.affiche_X();

public void affiche()

}

class Pointol extends Point

{ [Link]();
affiche_X()
public void affiche()
{
affiche() ; [Link]() ;
S.o.p (" La couleur est " + couleur) ;
}
}
 surcharge et redéfinition
le même nom, mais avec des paramètres différents  Le même nom

La surcharge d’une méthode ou d’un

 Les mêmes paramètres
 La même valeur de retour
L’héritage
constructeur permet de définir plusieurs
fois une même méthode/constructeur avec
La redéfinition de méthode se produit
des arguments différents. lorsque les sous-classes redéfinissent les
méthodes héritées de leur classe
1- Nombre de paramètres parente. Cela permet aux sous-classes
Somme (int a, int b); de personnaliser le comportement des
Somme (int a, int b, int c);
méthodes héritées pour répondre à
2- Type de données des paramètres leurs propres besoins.
Somme (int a, int b);
Somme (int a, double b);
Cas non valide de surcharge de méthode: Surcharge = même nom, paramètres
différents, peu importe la classe.
int Somme (int a, int b); C’est autorisé dans la même classe ou avec
double Somme (int a, int b); héritage.
class A { class B extends A { redéfinition
public void f(int n) {x} public void f(int n) {y}
} }
class A { class B extends A { surcharge
public void f(int n) {} public void f(double y) {}
} }

class A {
public void f(int n) {} // méthode 1
public void f(float x) {} // méthode 2 (surcharge de f)
}
class B extends A {
public void f(int n) {} // méthode 3 (redéfinition de méthode 1)
public void f(double y) {} // méthode 4 (surcharge avec nouveau type)
}
 final
Déclarer une constante :
Une fois qu'une variable est assignée avec final, sa valeur ne peut pas être modifiée.
final int MAX_AGE = 100; // La valeur de MAX_AGE ne peut pas être changée.

Interdire l'héritage d'une classe :

Si une classe est déclarée final, elle ne peut pas être étendue (pas d'héritage).
final class Personne {
final class A {}
// Cette classe ne peut pas être étendue
} public class B extends A {}

Interdire la redéfinition d'une méthode : class A {

public final void f() {}
Si une méthode est déclarée final, elle ne peut }
pas être redéfinie dans les sous-classes.
class B extends A {

final n’interdit pas la // Erreur de compilation

public void f() {} // interdit : f()
est final dans A
surcharge. }
 static
Le mot-clé static signifie que l'élément appartient à la classe elle-même, et non à une
instance (objet).
Variable static Méthode static Classe static
Imbriquée
class Compteur { class A { class Externe {
static int total = 0; static int carre(int x) static class Interne
// variable partagée par {return x * x; } {
toutes les instances } void direBonjour()
Ne dépend d'aucun objet. {
Compteur() { N’a pas accès aux membres S.o.p("Bonjour !");
total++; non statiques (car il n’y a pas
d’objet).
}
} }
Appelée : [Link](3);
} }
Une seule copie en mémoire, partagée
entre toutes les instances. [Link] obj = new
On peut y accéder via la classe : [Link]();
[Link] [Link]();
static + redéfinition static + surcharge
Une méthode static ne peut pas être Une méthode static peut être
redéfinie (override). surchargée (même nom, mais paramètres
différents).
class A {
// Méthode static
class C {
static void f() { // Méthode 1
S.o.p("A.f()"); } static void f(int x) {
} S.o.p("C.f(int)"); }

class B extends A { // Surcharge (méthode 2)

// Masquage (pas une redéfinition) static void f(double y) {
static void f() { S.o.p("C.f(double)"); }
S.o.p("B.f()"); } }
}
 Le polymorphisme
Le polymorphisme permet à une méthode de se comporter différemment en
fonction de l'objet qui l'appelle.
Le polymorphisme exploite la relation est induite par l’héritage
class Point class Point_Couleur extends Point
{ public Point (int x, int y) {} { public Point_Couleur (int x, int y, char color)
public void affiche () {} public void affiche () { ..... }
} }

Point P = new Point(3, 5) ;

P = new Point_Couleur (4, 8, ‘D’) ;

x=3 x=4
Point P
y=5 Point P y=8

color=‘D’
p de type Point contient la référence à un objet de type Point_Couleur
 class Point class Point_Couleur extends Point
{ public Point (int x, int y) {} { public Point_Couleur (int x, int y, char color)
public void affiche () {} public void affiche () { ..... }
} }

Point p = new Point (3, 5) ;

[Link] () ; //  affiche de la classe Point
p = new Point_Couleur (4, 8, 'D') ;
[Link] () ; //  affiche de la classe Point_Couleur

 le type effectif de l’objet référencé par p au moment de l’appel

(ce type pouvant évoluer au fil de l’exécution)  liaison dynamique
Le polymorphisme + Redéfinition + Surdéfinition

class A { public void f (double x) {} Elle

} ne peut pas accéder aux
méthodes qui existent uniquement
class B extends A { public void f (double x) {} //dans B (méthodes
redéfinition de f de A spécifiques ou
public void f (int n) {} //surchargées qui
surdéfinition de n'existent
f pour A et B pas dans
}
A).  Surcharge → non visible
A a ; B b ; int n ; La référence a (de type A) ne peut
appeler que les méthodes visibles
a.f(n) ; // appelle f (double) de A dans A.
b.f(n) ; // appelle f(int) de B Si ces méthodes sont redéfinies dans B,
alors c’est la version de B qui sera
a = b ; // a contient une référenceexécutée
sur un objet de type B
a.f(n) ; // appelle f(double) de B et non f(int)
 Les classes abstraites
Une classe abstraite est une classe qui ne peut pas être instanciée directement.
 Elle peut contenir des méthodes abstraites (sans corps) qui doivent être
implémentées par ses sous-classes.
 Elle ne peut servir que de classe de base pour une dérivation.

abstract class A
{

public void F() {instruction (s);} // F est définie dans A

public abstract void G(int n) ; // G n’est pas définie dans A ;

}
 Les classes abstraites
On peut définir des attributs et des constructeurs.
Les méthodes sont abstraites par défaut (sans implémentation), sauf si
elles sont marquées avec static.
abstract class A
{
String nom;
A (String nom) { [Link] = nom; }
//Les méthodes static appartiennent à la classe elle-même, pas à l’instance.
static void affiche() { S.o.p("Ceci est une classe abstract "); }

public void F() {instruction (s);} // F est définie dans A

public abstract void G(int n) ; // G n’est pas définie dans A ;
}
 Les classes abstraites + L’héritage
Classe dérivée concrète (non abstraite) Classe dérivée abstraite
→ Elle n’est pas obligée de redéfinir toutes
abstract class A { les méthodes abstraites héritées. Elle peut en
abstract void affiche(); laisser certaines non implémentées, et les
public void efg(){...} sous-classes concrètes suivantes devront alors
} le faire
class B extends A { abstract class A {
void affiche() { abstract void X();
abstract void Y();
instruction (s);} }
} abstract class B extends A {
void X() {instruction (s);}
Elle doit implémenter toutes les // Y() n'est pas encore implémentée
}
méthodes abstraites de la classe de class C extends B {
base. void Y() {instruction (s);}
}
 Les interfaces  implements
Une interface définit un contrat que les classes doivent suivre. Elle contient
uniquement des déclarations de méthodes, sans implémentation.
Les classes qui implémentent l'interface doivent fournir une implémentation des
méthodes définies.
Elle ne peut pas avoir de constructeurs ni de variables d'instance (à part les static
final).
Une classe peut implémenter plusieurs interfaces.
public interface A {
[public abstract ] void F(int n) ;
[public abstract ] void G() ;
static final double Pi= 3.14 ;
}

on ne peut pas instancier une interface directement

 Les interfaces  Limitations

interface U1 { void f(int n) ; void h() ; }

//=============================================
interface U2 { void f(double x) ; void h()
int h(); };
//=============================================
public class A implements U1,U2{

public void f(double x) {}

public void f(int n) {}
public void h() {}
int h() ;
 Les classes enveloppes
 manipuler les types primitifs comme des objets.
Boolean Character Byte Short Integer Long Float Double

encapsulent des valeurs du type primitif

boolean char byte short int long float double

Toutes les classes enveloppes disposent d’un

constructeur recevant un argument d’un type primitif
Integer x = new Integer (10) ; //  x contient la référence
à un objet de type Integer encapsulant la valeur 10
Double y = new Double (2.5) ;
 Les classes anonymes
 Définir une classe sans lui donner un nom
A a = new A() { « champs et méthodes
qu’on introduit dans la
classe anonyme dérivée de A » };
 Les classes anonymes
class A {
public void affiche() { S.o.p (" CLASS A") ; } }
public class B {
A a = new A() {
// elle est définie pour un usage unique.
public void affiche (){ S.o.p("Anonyme derive de A"); }
};
[Link]() ;  Anonyme derive de A
A b = new A();
[Link]();  CLASS A
}
Une classe anonyme ne peut pas introduire de nouvelles
méthodes
 Les classes anonymes
Classe normale Classe abstraite Interface
Tu peux redéfinir ce que tu Tu dois redéfinir toutes les Tu dois implémenter toutes
veux. méthodes abstraites. les méthodes
class A{ abstract class A { interface class A {
void x(){S.o.p("A_x");} abstract void x(); abstract void x();
void y(){S.o.p("A_y");} abstract void y(); abstract void y();
void z(){S.o.p("A_y");} void z(){...}; abstract void z();
} } }
class B{ class B { class B {
A a = new A() { A a = new A() { A a = new A() {
void x() { void x() {...} void x() {...}
S.o.p("class B");} void y() {...} void y() {...}
}; void z() {...} void z() {...}
}; };
a.x(); // class B. a.x(); a.x();
a.y(); // A_y } }
a.z(); // A_z
 Les classes générique
Générique : Manipuler des objets ou des variables de types quelconques
class A <T> { T représente un type quelconque (doit obligatoirement
private T contenu; être une classe)
public void setContenu(T contenu) { [Link] = contenu; } class A <T,U>
public T getContenu() { return contenu; }
}

A<String> a = new A<>();  A<String> a = new A<String>();

[Link]("Bonjour");

A<Integer> b = new A<>(); A<Integer> a = new A<Integer>();

[Link](123);
 Méthodes génériques
<T> T loterie (T [] valeurs)
•<T> : paramètre de type générique.
•T loterie(...) : méthode qui retourne un élément de type T.
•T[] valeurs : un tableau de valeurs de type T
On ne peut pas instancier un objet d’un type paramétré

Tx; // référence à un objet de type T (OK)

x = new T() ; // interdit d’instancier un objet de type paramétré T
Limitation
T [] tab ; // référence à un tableau d’objets de type T (OK)
tab = new T [100] ; // interdit
 Interfaces génériques
interface MyInterface<T> { ... }

L’interface Comparable
public interface Comparable<T> {
public int compareTo(T o);
}
La méthode compareTo() permet de comparer l’objet courant (this) à l’objet o reçu en argument et
de renvoyer un entier

 négatif (la valeur -1) l’objet courant est inférieur à l’objet o

 nul (la valeur 0) l’objet courant est égal à l’objet o
 positif (la valeur 1) l’objet courant est supérieur à l’objet o
 Interfaces génériques
interface MyInterface<T> { ... }

L’interface Comparable permet à une classe de définir son propre ordre naturel (tri).

public interface Comparable<T> {

public int compareTo(T o);
}
La méthode compareTo() permet de comparer l’objet courant (this) à l’objet o reçu en argument et
de renvoyer un entier

 négatif (la valeur -1) l’objet courant est inférieur à l’objet o

 nul (la valeur 0) l’objet courant est égal à l’objet o
 positif (la valeur 1) l’objet courant est supérieur à l’objet o
public int compareTo(Person other) {
String : trie par ordre alphabétique
return [Link] - [Link];
Int : trie par ordre croissant
}
public int compareTo(Person other) {
return [Link]([Link], [Link]);
}
public int compareTo(Person other) {
// Comparaison lexicographique du nom
return [Link]([Link]);
}
public int compareTo(Person other) {
int result = [Link]([Link]);
if (result == 0) { return [Link]([Link], [Link]); }
return result;
}
public class Personne implements Comparable<Personne> {
String nom;
int age;

public Personne(String nom, int age) { [Link] = nom; [Link] = age; }

@Override
public int compareTo(Personne autre) {
return [Link]([Link], [Link]); //tri par âge
//return [Link]([Link]); // Tri alphabétique
}

List<Personne> personnes = new ArrayList<>();

[Link](new Personne("A", 10));
[Link](new Personne("B", 20));
[Link](new Personne("C", 30));
[Link](personnes); // utilise compareTo()
 Comparaison Comparaison du Comparaison de
d'ordre contenu (valeurs) références
compareTo() equals() ==

compareTo() : La méthode Compare les valeurs des Compare les références des
compareTo() est utilisée pour objets, c'est-à-dire si le objets, c'est-à-dire si deux
comparer deux objets qui contenu de deux objets est variables pointent vers le
implémentent l'interface identique (cela doit être même objet en mémoire.
Comparable. redéfini dans les classes
personnalisées).
Vient de l’interface Utilisé pour les types
Comparable<T>. String s1 = "abc"; primitifs et les objets.
String s2 = "abc";
[Link](s2)
 La classe Object
En Java, toute classe hérite automatiquement (directement ou
indirectement) de la classe Object, même si ce n’est pas écrit explicitement.
class Personne { class Personne extends Object{
... ...
} }
equals(Object o) Vérifie l’égalité logique entre deux objets. Par défaut = ==.
toString() Retourne une représentation texte de l’objet.
public class Personne { public class Personne {
String nom; int age; String nom; int age;
} @Override
Personne P = new Personne (22, " ABC"); public String toString() { return nom + " " + age ; }
S.o.p(P )  [Link]@1c7c054 }
Personne P = new Personne (22, " ABC");
S.o.p(P )  ABC 22  S.o.p([Link]() )
 Les tableaux
 Un ensemble d’éléments de même type désignés par un nom unique, chaque élément étant
repéré par un indice précisant sa position au sein de l’ensemble

 les tableaux sont considérés comme des objets

int t[] = new int[5] ; // t référence à un tableau de 5 entiers

int[] t = new int[5] ;
 Les 5 éléments sont initialisés par défaut (comme tous les champs d’un objet) à
une valeur "nulle" (0 pour un int)
 int[] t; Chaque case du tableau contient une référence vers un objet Etudiant.

t = new int[] {1, 2, 3}; Etudiant[] E = new Etudiant[3];

E[0] = new Etudiant("A", 10);
int t[] = {1, 2, 55, 4, 12} ; E[1] = new Etudiant("B", 20);
int t[] = {1, a+b, a*b, 2*b, 12} ; E[2] = new Etudiant("C", 30);

int[] t = new int[5] ;

t[0] = 1 ; t[1] = 2 ; t[2]++ ;

Point [] A = new Point[3] ;

A[0] = new Point (1, 2) ;
A[1] = new Point (3, 4) ;
A[2] = new Point (10, 20) ;
La notation {.....} n’est utilisable que dans une déclaration
 int t[] [] = { {1, 2, 3} , {10, 20} } ; i
j 0 1 2

[Link] 0 1 2 3 A[0].length
for ( i= 0 ; i<[Link] ; i++){ 1 10 20 A[1].length

{for (j=0 ; j<A[i].length ; j++)

j j
[Link] (A[i] [j] + " ") ;
} 0,0 0,1 0,2 0,0

[Link]() ; i 1,0 1,1 1,2 i 1,0 1,1

} 2,0 2,1 2,2 2,0 2,1 2,2

int [] [] t = new int [3][] ; // crée un tableau de trois références à des tableaux d’entiers et place sa référence dans t.

for (int i=0 ; i<3 ; i++)

{ t[i] = new int [i+1] ; // crée un tableau d’entiers de taille i+1 et en place la référence dans t[i].
for (int j=0 ; j<t[i].length ; j++) t[i][j] = 0 ;
}
 Les exceptions
try/catch (essayer/capturer).
Une exception est un événement ou une situation qui interrompt le flux normal
d'exécution d'un programme. try {
// Code qui peut générer une exception
} catch (TypeException1 e1) {
// Traitement si TypeException1 est levée
} catch (TypeException2 e2) {
// Traitement si TypeException2 est levée
} finally {
// (optionnel) Code exécuté dans tous les cas
}
Finally  (Facultatif) Ce bloc est toujours exécuté, qu’il y ait
une exception ou non. Idéal pour libérer des ressources (fichiers,
connexions…).

Exception in thread "main" [Link]: / by zero

at [Link]([Link])
at TestException.<init>([Link])
at [Link]([Link])
 public static void main(String[] args) { Erreur : division par zéro !
try { Bloc finally exécuté.
int a = 1; Out try/catch ...
int b = 0;
int resultat = a / b; // Provoque ArithmeticException
[Link]("Résultat : " + resultat);

catch
} catch (ArithmeticException e) (NullPointerException
{ e) {
[Link]("Erreur : division par zéro !");: division par zéro !");
[Link]("Erreur
} finally { Exception in thread "main"
[Link]("Bloc finally exécuté.");
[Link]: / by zero
} at [Link]([Link])
[Link]("Out try/catch ..."); Bloc finally exécuté.
}

 Si une exception se produit, l'exécution saute le reste du bloc try.

 Si aucune exception ne se produit, les blocs catch sont ignorés.

 Le bloc finally s’exécute toujours, même si une exception non

capturée est levée, ou si on utilise return ou break dans le try.
 throw et throws
lancer manuellement une exception. déclarer qu’une méthode peut lever une
exception.
Utilisé pour lancer une exception de manière throws : Utilisé dans la signature d'une
explicite dans un bloc de code. méthode pour indiquer qu'elle peut lancer
certaines exceptions spécifiques, permettant à
throw new ArithmeticException("Erreur …"); l'appelant de gérer ces exceptions.

public void division() throws ArithmeticException

{ int result = 10 / 0;}
public static void verifier(int valeur) throws IllegalArgumentException {
if (valeur < 0) {
throw new IllegalArgumentException("Valeur négative non autorisée");
}
[Link]("Valeur valide : " + valeur);
}

public static void main(String[] args) {

try {
verifier (10); // OK
verifier (-5); // Provoque une exception
} catch (IllegalArgumentException e) {
[Link]("Erreur capturée : " + [Link]());
}
 la classe de base pour le traitement des erreurs

décrit des erreurs systèmes comme l’ absence de mémoire. Ces

exceptions ne sont en général pas traitées par les programmes

ont une cause externe à votre

programme
Ces exceptions ne sont pas vérifiées à la Les exceptions vérifiées sont vérifiées à la
compilation, ce qui permet au programme de compilation, ce qui oblige le développeur à
continuer sans la gestion explicite de l'exception. gérer ou déclarer ces exceptions.

RuntimeException se produit
toujours en raison d’une erreur
de programmation

décrit des exceptions logicielles à traiter lorsqu'elles surviennent.

La classe Exception ne définit pas ses propres méthodes
 Les Fichiers
Choisir son gestionnaire de flux : + Mise en tampon(Buffered)
– Basé sur des caractères : FileReader FileWriter

– Basé sur des octets : FileInputStream FileOutputStream

try {
FileReader f = new FileReader("[Link]");
try-with-resources
try (FileReader f = new FileReader("[Link]" ) )
} catch (IOException e) {
{
[Link]([Link]()); // lecture éventuelle ici
} } catch (IOException e) {
finally {
[Link]([Link]());
[Link]();
} }

try ( [Link]() est automatiquement appelé, même si une

FileReader f = new FileReader("[Link]"); exception est levée
BufferedReader br = new BufferedReader(f)
)
Lecture : caractère par caractère Lecture : ligne par ligne
int read(): Lit un caractère. Retourne –1 si fin String readLine():
de fichier. FileReader FileReader+ BufferedReader
try {
FileReader FR= new FileReader ("[Link]");
// 1. Ouvre le fichier en mode lecture
(caractères) BufferedReader BR= new BufferedReader (FR);
FileReader f = new FileReader("[Link]");
BufferedReader BR= new BufferedReader (new FileReader ("[Link]"));
int c;
// 2. Lit chaque caractère try{
while ((c = [Link]()) != -1) String ligne ;
// 3. Affiche chaque caractère BufferedReader BR = new BufferedReader (new
Le cast (char) c est nécessaire car read() retourne le code FileReader ("[Link]));
ASCII du caractère
[Link]((char) c);
while ((ligne = [Link]() ) != null) {
} catch (IOException e) {
[Link](ligne ); }
// 4. Gère les erreurs d'accès
[Link]("Erreur d'ouvert");
// 5. Affiche le message d'erreur
} catch (Exception e) { [Link](); }
[Link]([Link]());
}
finally {
finally {
[Link]();
// 6. Ferme le flux (bonne pratique)
}
[Link]();
écriture : caractère par caractère écriture : ligne par ligne
Write Write
FileWriter FileWriter + BufferedWriter
try {
FileWriter FW= new FileWriter ("[Link]");
FileWriter FW = new FileWriter ("[Link]"); BufferedWriter BW= new BufferedWriter (FW);
BufferedWriter BW= new BufferedWriter (new FileWriter ("[Link]"));
[Link]("bonjour tout le monde");
try{
} catch (IOException e) {
BufferedWriter BW = new BufferedWriter (new
[Link]([Link]()); FileWriter ("[Link]));
}
finally { [Link]("bonjour tout le monde");

[Link](); [Link]();

}
} catch (Exception e) { [Link](); }
le contenu ne soit pas entièrement écrit
finally {
dans le fichier (tampon non vidé), [Link]();
le fichier soit endommagé ou incomplet, }
 sérialisation / désérialisation
La sérialisation en Java est le processus de conversion d'un objet en un flux d'octets pour
pouvoir être stocké dans un fichier, envoyé sur un réseau, ou enregistré dans une base de
données. Cette opération permet de sauvegarder l'état d'un objet et de le récupérer plus tard.
Une classe doit implémenter l'interface Serializable pour pouvoir être sérialisée.

FileOutputStream fos = new FileOutputStream("[Link]"); FileInputStream fis = new FileInputStream("[Link]");

ObjectOutputStream fout = new ObjectOutputStream (fos); ObjectInputStream fin = new ObjectInputStream (fis);
 Les Collections
Les collections sont des objets qui permettent de gérer des ensembles d'objets. C’est un
regroupement d'objets sous le nom d'éléments.
ArrayList utilise un tableau dynamique en interne. Il est donc plus rapide pour l'accès
direct (indexation) mais plus lent pour les insertions/suppressions au milieu de la liste,
car cela nécessite un décalage des éléments.
0 1 2 3 4 0 1 2 3 4 5
Aa Bb Cc Ee Ff Aa Bb Xx Cc Ee Ff

LinkedList utilise une liste chaînée (chaque élément pointe vers le suivant). Elle est plus
performante pour les insertions et suppressions, mais l'accès à un élément par index est plus lent
car il faut parcourir la liste.
 LinkedList<Object> M = new LinkedList<Object> () ;
LinkedList<String> M = new LinkedList<String> () ;

LinkedList<Integer> M = new LinkedList<Integer> () ;

LinkedList<Integer> M = new LinkedList<> () ;

Un Iterator est une interface en Java qui permet de parcourir une collection de manière
sécurisée et flexible.
 Elle permet de récupérer chaque élément de la collection sans avoir à utiliser un
index.
Aspect Iterator ListIterator
Direction de parcours Sens unique (avant) ➡️ Double sens (avant ➡️ et arrière ⬅️)
Méthodes disponibles hasNext(), next(), remove() hasNext(), next(), hasPrevious(),
previous(), add(), remove(), set()

Collections compatibles Toutes les collections (List, Set, etc.) Uniquement List
Positionnement Ne donne pas d’index Peut retourner l'index avec
nextIndex() et previousIndex()

Ajout ou modification Ne peut pas ajouter ou modifier (sauf Peut ajouter, modifier et supprimer
supprimer via remove()) des éléments pendant l'itération
ArrayList<String> M = new ArrayList<> () ;
[Link] ("A") ; next() next() next() next() next()
[Link] ("D") ; 0 1 2 3
[Link] ("C") ; Out of
A D C B
rang
[Link] ("B") ;
Iterator<String> I1= [Link](); ListIterator<String> I2=
[Link]();
while([Link]()) while([Link]())
{S.o.p( [Link]() );} {S.o.p( [Link]() );}
créer une ArrayList
mettre à jour un élément extraire une partie de la liste
ajoutez éléments
supprimer un élément comparer deux listes
parcourir tous les éléments
rechercher un élément
insérer un élément
copier une liste dans une autre
récupérer un élément
1. créer une ArrayList, ajoutez éléments (chaînes)
List <String> L = new ArrayList < String >();
ArrayList < String > L = new ArrayList < String >();
LinkedList < String > L = new LinkedList<>();

[Link]("A"); [Link]("B"); [Link]("F"); [Link]("D"); [Link]("C"); [Link]("E");

0 1 2 3 4 5

A B F D C E
2. parcourir tous les éléments de la liste0 1 2 3 4 5
A B F D C E
ArrayList < String > L = new ArrayList < String >();

for (String element : L) {

[Link](element +" - ");
}

Iterator<String> it_1= [Link]();

while( it_1.hasNext() ) {[Link](it_1.next() +" * ");}

ListIterator<String> it_2 = [Link]();

while( it_2.hasNext() ) {[Link](it_2.next() +" + ");}

parcourir tous les éléments de la liste en commençant à la
position spécifiée.
0 1 2 3 4 5
A B F D C E

ListIterator<String> I2 = [Link](2); OK
Iterator <String> I1 = [Link](X); Error

ListIterator<String> I2 = [Link](2);
while([Link]() ) {
[Link]([Link]() +" ");}
 parcourir la liste dans l'ordre inverse
for (int i = [Link]() - 1; i >= 0; i--) { 0 1 2 3 4 5
[Link]([Link](i));
A B F D C E

ListIterator<String> I2 = [Link]([Link]());
while(I2. hasPrevious) {[Link](I2. previous() +" ");}

[Link](list); // Modifie l'ordre de la liste 0 1 2 3 4 5

Iterator<String> I3 = [Link](); E C D F B A
while([Link]()) {[Link]([Link]() +" ");}

LinkedList < String > L = new LinkedList<>();

descendingIterator() est une méthode spécifique à LinkedList
Iterator<String> I4 = [Link]();
3. insérer un élément dans la liste
0 1 2 3 4 5
A B F D C E
[Link](0, "X");

0 1 2 3 4 5 6
X A B F D C E

[Link](5, "Z");

0 1 2 3 4 5 6 7
X A B F D Z C E
4. récupérer un élément (à un index spécifié) à partir
de la liste.
0 1 2 3 4 5
A B F D C E

String element = [Link](0);

[Link](" 1er: "+element);  1er: A

element = [Link](2);
[Link](" 3eme: "+element);  3eme: F
5. mettre à jour un élément par l'élément donné.
0 1 2 3 4 5
A B F D C E

[Link](3, "W");

0 1 2 3 4 5
A B F W C E
6. supprimer un élément de la liste
0 1 2 3 4 5
A B F D C E
[Link](2);  remove(int index) — supprime à une position
0 1 2 3 4
A B D C E

[Link]("B");  remove(Object o) — supprime par valeur

0 1 2 3 0 1 2 3
A D C E 1 2 3 4

[Link]( [Link](1) );
7. rechercher un élément dans la liste.
0 1 2 3 4 5
X B F X C X

if ([Link](" F ")) true/false

[Link](" X "); // renvoie l'indice de la première occurrence de "X"

-1 si l’élément n’existe pas dans la liste.

[Link] (" X ");

10. comparer deux listes.
ArrayList<String> c1= new ArrayList<String>();
ArrayList<String> c2= new ArrayList<String>();

[Link]("A"); [Link]("B"); [Link]("C"); [Link]("D"); [Link]("E");

[Link]("A"); [Link]("B"); [Link]("F"); [Link]("C");

for (String e : c1)

[Link]( ([Link](e) ? "Yes" : "No") );
[Link](c2);
0 1 2 3 4 Yes
A B C D E Yes
Yes
0 1 2 3 No
No
A B F C
 même taille, même ordre, mêmes éléments
ArrayList<Integer> list1 = new ArrayList<>();
[Link](6); [Link](2); [Link](3);

ArrayList<Integer> list2 = new ArrayList<>();

[Link](6); [Link](2); [Link](3); //[Link](3);

boolean eq = [Link](list2);

0 1 2 0 1 2 0 1 2
6 2 3 6 2 3 6 2 3

0 1 2 0 1 2 0 1 2 3
6 2 3 6 3 2 6 2 3 4
 Les Expression LAMBDA
Elle permet de simplifier le code au lieu d’écrire une classe anonyme
Toute lambda est liée à une interface fonctionnelle.
Une interface fonctionnelle est une interface qui contient une seule méthode abstraite.

implémenter une expression lambda pour trouver la somme de deux entiers.

interface Calculer { int sum(int a, int b);}

Calculer A = new Calculer () {
@Override
Calculer A = ( a, b) -> a+b;
public int sum (int a, int b) {
return a+b;
}
};
[Link]( A. sum(2,3) );
[Link]( A. sum(2,3) );
implémenter une expression lambda pour vérifier si une String est vide.

interface Calculer {boolean sum(String X);}

Calculer A = new Calculer () {
@Override
Calculer A = (x) -> [Link]();
public boolean sum (String X) {

return [Link]();

} String str1 = "";

}; String str2 = "Java";
String str1 = "";
String str2 = "Java"; [Link]( A. sum(str1));
[Link]( A. sum(str1)); [Link]( A. sum(str2));
[Link]( A. sum(str2));
implémenter une expression lambda permettant de calculer la racine carrée d'un nombre
donné.
interface Calculer {double sum(double X);}
Calculer A = new Calculer () {
@Override
Calculer A = (x) -> [Link](x);
public double sum (double X) {

return [Link](x);

}
}; [Link]( A. sum(4));
[Link]( A. sum(4));
implémenter une expression lambda pour concaténer deux chaînes.
interface Calculer {String sum(String x, String y);}
Calculer A = new Calculer () {
@Override
Calculer A = (x,y) -> x+y;
public String sum (String x, String y) {

return x+y;

}
}; String S1 = "ABC ";
String S1 = "ABC "; String S2 = "EFG ";
String S2 = "EFG ";
[Link]( A. sum(s1,s2));
[Link]( A. sum(s1,s2));
世界に痛みを 神羅天征
[Link]