Année universitaire: 2025-2026

Pr. Nouhaila IDRISSI, Ph.D.

Département d’Informatique,
Faculté des Sciences El Jadida, UCD
ENSIAS 2020-2021
[Link]@[Link]
 Chapitre 1 — Concepts de Base de la POO

nouhaila_idrissi@[Link]
ENSIAS 2020-2021

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 2

Qu'est-ce que la Programmation Orientée Objet ?

• Un paradigme de programmation centré sur la création d'objets qui combinent données (attributs) et comportements (méthodes)
pour représenter des concepts réels ou abstraits dans votre code.

Paradigme centré sur les objets:

Les objets encapsulent à la fois l'état (données) et le comportement (méthodes), à l'image des entités du monde réel.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 3

Qu'est-ce que la Programmation Orientée Objet ?

• Un paradigme de programmation centré sur la création d'objets qui combinent données (attributs) et comportements (méthodes)
pour représenter des concepts réels ou abstraits dans votre code.

Paradigme centré sur les objets:

Les objets encapsulent à la fois l'état (données) et le comportement (méthodes), à l'image des entités du monde réel.

Modélisation de concepts reels:

Permet de transposer facilement des concepts du monde réel en structures de code logiques et intuitives.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 4

Qu'est-ce que la Programmation Orientée Objet ?

Avantages clés:

üModularité Diviser pour régner

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 5

Qu'est-ce que la Programmation Orientée Objet ?

Avantages clés:

üModularité

üRéutilisabilité du code

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 6

Qu'est-ce que la Programmation Orientée Objet ?

Avantages clés:

üModularité

üRéutilisabilité du code

üMaintenabilité améliorée

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 7

Qu'est-ce que la Programmation Orientée Objet ?

Avantages clés:

üModularité

üRéutilisabilité du code

üMaintenabilité améliorée

üOrganisation plus intuitive des programmes complexes.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 8

Historique de la POO

Procedia Engineering, 2014

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 9
Approche Fonctionnelle vs Approche Orientée Objet

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 10

Approche Fonctionnelle vs Approche Orientée Objet

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 11

Approche Fonctionnelle vs Approche Orientée Objet

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 12

Approche Fonctionnelle vs Approche Orientée Objet

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 13

 Chapitre 2 — Éléments du Langage Java

nouhaila_idrissi@[Link]
ENSIAS 2020-2021

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 14

Java — Présentation

• Java est un langage de programmation orienté objet créé par Sun Microsystems (maintenant Oracle) en 1995. Son principe fondateur
"Write Once, Run Anywhere" permet d'exécuter le même code sur n'importe quelle plateforme disposant d'une JVM.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 15

Java — Présentation

• Java est un langage de programmation orienté objet créé par Sun Microsystems (maintenant Oracle) en 1995. Son principe
fondateur "Write Once, Run Anywhere" permet d'exécuter le même code sur n'importe quelle plateforme disposant d'une
JVM.
• Bytecode et JVM:
Le code source est compilé en bytecode (.class) qui s'exécute sur la JVM, assurant la portabilité entre systèmes
d'exploitation et architectures.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 16

Java — Présentation

• Java est un langage de programmation orienté objet créé par Sun Microsystems (maintenant Oracle) en 1995. Son principe fondateur
"Write Once, Run Anywhere" permet d'exécuter le même code sur n'importe quelle plateforme disposant d'une JVM.

Bytecode et JVM:
Le code source est compilé en bytecode (.class) qui s'exécute sur la JVM,
assurant la portabilité entre systèmes d'exploitation et architectures.
Typage fort et sécurité:
Le typage statique permet de détecter les erreurs à la compilation plutôt qu'à
l'exécution, renforçant la robustesse des applications.
Garbage Collection:
Gestion automatique de la mémoire qui libère le développeur de
l'allocation/désallocation explicite des objets, réduisant les fuites mémoire.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 17

Java — Présentation

• Java est un langage de programmation orienté objet créé par Sun Microsystems (maintenant Oracle) en 1995. Son principe fondateur
"Write Once, Run Anywhere" permet d'exécuter le même code sur n'importe quelle plateforme disposant d'une JVM.
Bytecode et JVM:
Le code source est compilé en bytecode (.class) qui s'exécute sur la JVM,
assurant la portabilité entre systèmes d'exploitation et architectures.
Typage fort et sécurité:
Le typage statique permet de détecter les erreurs à la compilation plutôt qu'à
l'exécution, renforçant la robustesse des applications.
Garbage Collection:
Gestion automatique de la mémoire qui libère le développeur de
l'allocation/désallocation explicite des objets, réduisant les fuites mémoire.
Éditions Java (SE, EE, ME):
Java SE (Standard Edition) pour applications de bureau, Java EE (Enterprise Edition) pour applications d'entreprise, et Java ME (Micro
Edition) pour appareils embarqués.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 18

Architecture JVM — Vue d'ensemble

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 19

Java vs C++ — Différences clés

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 20

Java vs C++ — Différences clés

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 21

Java vs C++ — Différences clés

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 22

Java vs C++ — Différences clés

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 23

Installation : Java & Environnements de Développement Intégrés (EDI)

• Le JDK : Notre Boîte à Outils Java

Aller sur le site d'Oracle et télécharger la version appropriée pour le système
d'exploitation (Windows, macOS, Linux):
[Link]

Ø Comment vérifier ?

Ouvrez votre terminal ou invite de commande et tapez :

javac -version
java -version

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 24

Installation : Java & Environnements de Développement Intégrés (EDI)

• L’EDI :
IntelliJ IDEA (Community Edition) : Très intelligent, excellent pour la productivité. C'est un
favori dans l'industrie.
Eclipse : Un vétéran très puissant et extensible, entièrement gratuit et open-source.
NetBeans : Un autre EDI robuste et officiellement soutenu par la communauté Apache.

1. Accédez au site web de JetBrains et téléchargez la dernière version d'IntelliJ IDEA.

[Link]

2. Cliquez sur Télécharger.

3. Vous serez redirigé vers une page contenant les liens de téléchargement d'IntelliJ IDEA.
Vérifiez que Windows/MAC est sélectionné.

4. Faites défiler la page jusqu'à l'Édition Communautaire et cliquez sur Télécharger.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 25
Anatomie d'une Classe Java

Ø Structure d'une classe Java:

Une classe est le blueprint pour créer des objets, encapsulant données
(attributs) et comportements (méthodes) dans une seule unité.

• Package : Organisation logique des classes dans un espace de noms

spécifique.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 26

Anatomie d'une Classe Java

Ø Structure d'une classe Java:

Une classe est le blueprint pour créer des objets, encapsulant données
(attributs) et comportements (méthodes) dans une seule unité.

• Package : Organisation logique des classes dans un espace de noms

spécifique.
• Modificateurs d'accès :
public : accessible partout
private : accessible uniquement dans la classe
protected : accessible dans le package et sous-classes
(default) : accessible uniquement dans le package

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 27

Anatomie d'une Classe Java

Ø Structure d'une classe Java:

Une classe est le blueprint pour créer des objets, encapsulant données
(attributs) et comportements (méthodes) dans une seule unité.

• Package : Organisation logique des classes dans un espace de noms

spécifique.
• Modificateurs d'accès :
public : accessible partout
private : accessible uniquement dans la classe
protected : accessible dans le package et sous-classes
(default) : accessible uniquement dans le package
• Constructeur : Méthode spéciale pour initialiser un nouvel objet.
• Getters/Setters : Méthodes pour accéder et modifier les attributs privés.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 28

Structures de contrôles & Syntaxe

Java hérite largement de la syntaxe du C/C++:

- (;) à la fin de chaque ligned’instructions

- {…} pour encadrer un bloc d’instructions
- Opérations de calcul: +; -; *; %
- Les opérateurs d’affectation: =; += ;…
- Les opérateurs de comparaison: !=; <; <= ;==, …
- Les opérateurs logiques: &&; ||; &; |; !;…
- Les symbols des commentaires: // et /*…*/

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 29

Opérateurs en Java

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 30

Opérateurs en Java
int x = 5;

int y = ++x * 2;

int resultat = 10 + 3 * 2;

if (x != null && [Link]() > 0)

{ // Si x est null, [Link]() n'est PAS évalué
→ évite une erreur }

int result = 10 - 3 - 2; // Évalué

comme (10-3)=7, puis 7-2=5

int x = 5; int y = ++x; // ++ est

évalué avant l'affectation

int a = 10, b = 5;
int max = a > b ? a : b; // Évalué
de droite à gauche

int x, y, z; x = y = z = 10;
// z=10 d'abord, puis y=10, puis x=10

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 31

Opérateurs en Java

Exemple 1 :

int a = 5, b = 3, c = 2;
int resultat = ++a * b + c-- % 2;

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 32

Opérateurs en Java

Exemple 1 :

int a = 5, b = 3, c = 2;
int resultat = ++a * b + c-- % 2;

Exemple 2 :
int x = 10, y = 3, z = 2;
int sansParentheses = x + y * z;
int avecParentheses = (x + y) * z;

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 33

Opérateurs en Java

Exemple 1 :

int a = 5, b = 3, c = 2;
int resultat = ++a * b + c-- % 2;

Exemple 2 :
int x = 10, y = 3, z = 2;
int sansParentheses = x + y * z;
int avecParentheses = (x + y) * z;

Exemple 3 :

boolean a = true, b = false, c = true;

boolean resultat = a || b && c;

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 34

Identificateurs et Littéraux
Identificateurs:
- Composés de lettres, chiffres, underscore (_), dollar ($)
- Ne peuvent pas commencer par un chiffre
- Sensibles à la casse (compteur ≠ Compteur)
- Ne peuvent pas être des mots-clés réservés (if, class, while, etc.)

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 35

Identificateurs et Littéraux
Identificateurs:

- Composés de lettres, chiffres, underscore (_), dollar ($)

- Ne peuvent pas commencer par un chiffre
- Sensibles à la casse (compteur ≠ Compteur)
- Ne peuvent pas être des mots-clés réservés (if, class, while, etc.)
Littéraux:

- Entiers : 10, 42, 1_000_000 (avec séparateurs)

- Flottants : 3.14, 2.5f, 1.0e+10
- Caractère : 'A', '\n', '\u0041' (Unicode)
- Chaîne : "Hello", "Bonjour\nMonde”
- Booléen : true, false
- Null : null
- Hexadécimal : 0xFF (255), 0x1A (26)

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 36

Identificateurs et Littéraux

Conventions de nommage

- Classes : PascalCase (MaClasse, CompteBancaire)

- Méthodes/attributs : camelCase (calculerMontant, nomUtilisateur)
- Constantes : UPPER_SNAKE_CASE (MAX_VALUE, PI)
- Packages : minuscules, domaines inversés ([Link])

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 37

Types Primitifs de Java

byte petitNombre = 100; // Très économique en mémoire (-128 à 127)

short nombreCourt = 30_000; // Plus grand que byte (-32,768 à 32,767)
int nombre = 2_000_000_000; // Le plus utilisé (-2³¹ à 2³¹-1)
long grandNombre = 9_000_000_000_000_000L; // Énorme ! (avec L à la fin)

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 38

Types Primitifs de Java

float prix = 19.99f; // Simple précision (avec f à la fin)

double distance = 384_400.567; // Double précision - le plus utilisé

boolean estVrai = true;

boolean estFaux = false;
boolean estMajeur = (age >= 18); // Résultat d'une comparaison

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 39

Variables : Déclaration et Portée

• Une variable est un emplacement mémoire nommé qui stocke une valeur d'un type spécifique. La déclaration d'une variable réserve cet
espace mémoire.
int age;
String nom = "Pierre";
double prix = 19.99;

• Variables locales : Déclarées dans une méthode ou un bloc. Portée limitée au bloc où elles sont déclarées. Doivent être initialisées avant utilisation.

public void calculerMoyenne() {

int nombreNotes = 5;
double somme = 0.0;
for(int i = 0; i < nombreNotes; i++) {
double note = lireNote();
somme += note;
}
double resultat = somme / nombreNotes;
[Link](resultat);
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 40

Variables : Déclaration et Portée

• Attributs (fields) : Déclarés au niveau de la classe. Accessibles dans toute la classe. Initialisés par défaut si non explicitement initialisés.

public class Etudiant {

private String nom;
private int age;
private boolean estInscrit;

public void afficherInfo() {

[Link]("Nom : " + nom); // Accessible
[Link]("Age : " + age); // Accessible
}
public void initialiserEtudiant() {
nom = "Marie";
age = 20;
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 41

Variables : Déclaration et Portée

• Paramètres : Variables spéciales qui reçoivent des valeurs lors de l'appel d'une méthode. Portée limitée au corps de la méthode.

public class Calculatrice {

public int additionner(int a, int b) {

int resultat = a + b;
return resultat;
}
public void utiliserCalculatrice() {
int x = 5, y = 3;
int somme = additionner(x, y); // x et y sont copiés dans a et b
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 42

Variables : Déclaration et Portée

• Constantes : Déclarées avec le mot-clé final. Une fois initialisées, leur valeur ne peut plus être modifiée.

public class Geometrie {

public static final double PI = 3.14159;
public static final int AGE_MAJORITE = 18;
public static final String NOM_APPLICATION = "MonApp";

public double calculerAireCercle(double rayon) {

return PI * rayon * rayon;
}
public void testerModification() {
// PI = 3.14; // ERREUR COMPILATION : constante !
// AGE_MAJORITE = 21; // IMPOSSIBLE !
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 43

Variables : Déclaration et Portée

• Trouvez les erreurs dans ce code :

public class Test {

public void calcul() {
int x;
int y = 10;
[Link](x + y);
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 44

Variables : Déclaration et Portée

• Quel est le résultat de ce code ?

public class Portee {

public static void main(String[] args) {
int a = 5;
if (a > 0) {
int b = 10;
a = a + b;
}
[Link]("a = " + a);
// [Link]("b = " + b);
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 45

Variables : Déclaration et Portée

• Quelle est la différence entre ces deux codes ?

Code A: Code B:

public class Compte { public class Compte {

private double solde = 0; public void deposer(double montant) {
double solde = 0;
public void deposer(double montant) { solde += montant;
solde += montant; }
} }
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 46

Variables : Déclaration et Portée

• Corrigez ce code pour utiliser une constante correctement :

public class MathUtils {

public double calculerCirconference(double rayon) {
double pi = 3.14159;
return 2 * pi * rayon;
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 47

Variables : Déclaration et Portée

• Corrigez ce code pour utiliser une constante correctement :

public class MathUtils {

public double calculerCirconference(double rayon) {
double pi = 3.14159;
return 2 * pi * rayon;
}
}
Solution:
public class MathUtils {
private static final double PI = 3.14159;

public double calculerCirconference(double rayon) {

return 2 * PI * rayon;
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 48

Variables : Déclaration et Portée

• Quel est le problème avec ce code ?

public class Personne {

private String nom;

public void setNom(String nom) {

nom = nom;
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 49

Variables : Déclaration et Portée
• Quel est le problème avec ce code ?

public class Personne {

private String nom;

public void setNom(String nom) {

nom = nom;
}
}
Solution:
public class Personne {
private String nom;

public void setNom(String nom) {

[Link] = nom;
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 50

Variables : Déclaration et Portée

• Qu'affiche ce code ?

public class Init {

private int valeur;
public void afficher() {
int temp;
[Link]("Attribut: " + valeur);
// [Link]("Local: " + temp);
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 51

Méthodes en Java
• Une méthode en Java est un bloc de code qui exécute une tâche spécifique. Elle regroupe des instructions liées qui sont exécutées lorsque
la méthode est appelée.

Modificateurs d'Accès:
[modificateurs] typeRetour nomMethode([paramètres]) {
public class ExempleModificateurs {
return valeur; // si typeRetour n'est pas void
} public void publique() { } // Accessible partout
protected void protegee() { } // Package + sous-classes
void packagePrivee() { } // Uniquement dans le package
private void privee() { } // Uniquement dans la classe

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 52

Méthodes en Java
Que génère ce code ?

public int probleme(boolean condition) {

if (condition) {
return 1;
}
}

Solution:

public int correct(boolean condition) { public int correct2(boolean condition) {

if (condition) { if (condition) {
return 1; return 1;
} else { }
return 0; return 0;
} // Tous les chemins retournent une valeur // Retour par défaut
} }
N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 53
Surcharge de Méthodes (Overloading)
public class Logger {

public void log(String message) {

[Link]("INFO: " + message);
}

public void log(String message, String niveau) {

[Link](niveau + ": " + message);
}

public void log(String message, int repetition) {

for(int i = 0; i < repetition; i++) {
[Link](message);
}
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 54

Surcharge de Méthodes (Overloading)
public class Logger {

public void log(String message) {

[Link]("INFO: " + message);
}

public void log(String message, String niveau) {

[Link](niveau + ": " + message); public String log(String message) {
} return message;
}
public void log(String message, int repetition) {
for(int i = 0; i < repetition; i++) {
[Link](message); à ERREUR: Pas de surcharge basée seulement sur le type de retour
}
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 55

Membres d'Instance vs Static

• Les membres d'instance appartiennent à chaque objet individuellement, tandis que les membres static sont partagés par tous les objets
de la classe.

public class Compteur {

int compteInstance = 0; // Membre d'instance
static int compteStatic = 0; // Membre static

public Compteur() {
compteInstance++;
compteStatic++;
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 56

Membres d'Instance vs Static
• Méthode d'instance : liée à un objet spécifique, peut accéder aux champs d'instance et manipuler l'état interne de l'objet.
• Méthode static : liée à la classe plutôt qu'à un objet spécifique, ne peut pas accéder directement aux champs d'instance.
class Compteur {
private int valeur = 0; // Variable d'instance
static int nbInstances = 0; // Variable de classe (static)

Compteur() {
nbInstances++;
}

int inc() { Compteur c1 = new Compteur();

return ++valeur; [Link]();
}

static int instances() {

return nbInstances; [Link]();
}
}
N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 57
Membres d'Instance vs Static

class Compteur {
static void methodeStatic() {
[Link]([Link]); à ERREUR! "this" n'existe pas dans un contexte static car aucune instance
} n'est concernée

void methodeInstance() {
[Link]([Link]); à Correct "this" référence l'instance courante
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 58

Variables d'instance vs static
• Les variables d'instance sont propres à chaque objet créé. Elles représentent l'état individuel de l'objet et vivent tant que l'objet existe en mémoire.
• Les variables static appartiennent à la classe et sont partagées par toutes les instances. Elles existent tant que la classe est chargée en mémoire, même sans
objet créé.

public class Personne { class Config {

// Variable static (partagée)
private String nom; static String appName = "MonApp";
private int age;
private String email; // Variable d'instance (individuelle)
int retries = 3;
public Personne(String nom, int age) {
[Link] = nom; // Constante (static final)
[Link] = age; static final String VERSION = "1.0";
} }
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 59

Structures de contrôle
• Structures de décision : permettent d'exécuter différentes portions de code selon des conditions.
• Structures de répétition : permettent d'exécuter plusieurs fois un bloc de code.

switch (jour) { À partir de Java 14+

if (x > 0) { case "LUNDI":
[Link]("Positif"); travail(); String message = switch (jour) {
} else if (x < 0) { break; case "LUNDI" -> "Travail";
[Link]("Négatif"); case "SAMEDI": case "SAMEDI", "DIMANCHE" -> "Repos";
} else { case "DIMANCHE": default -> "Routine normale";
[Link]("Zéro"); repos(); };
} break;
default:
routineNormale();
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 60

Structures de contrôle
À partir de Java 14+, on peut écrire le switch de façon plus fluide.
• Quand un case contient plus d’une instruction:

String jour = "LUNDI"; String jour = "MERCREDI";

String message = switch (jour) { String message = switch (jour) {

case "LUNDI" -> "Début de semaine"; case "LUNDI" -> "Début de semaine";
case "SAMEDI", "DIMANCHE" -> "Weekend"; case "MERCREDI" -> {
default -> "Jour normal"; [Link]("Milieu de la semaine");
}; yield "Courage !";
}
[Link](message); case "SAMEDI", "DIMANCHE" -> "Weekend";
default -> "Jour normal";
};

[Link](message);

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 61

Structures de contrôle

• Les boucles permettent d'exécuter un bloc de code plusieurs fois, tant qu'une condition est vérifiée.

for (int i = 0; i < 5; i++) {

[Link](i + " ");
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 62

Structures de contrôle

• Les boucles permettent d'exécuter un bloc de code plusieurs fois, tant qu'une condition est vérifiée.

for (int i = 0; i < 5; i++) {

[Link](i + " ");
}

for (String element : array) {

[Link](element);
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 63

Structures de contrôle

• Les boucles permettent d'exécuter un bloc de code plusieurs fois, tant qu'une condition est vérifiée.

for (int i = 0; i < 5; i++) { int i = 0;

[Link](i + " "); while (i < 3) {
} [Link]("i = " + i);
i++;
}
for (String element : array) {
[Link](element);
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 64

Structures de contrôle

• Les boucles permettent d'exécuter un bloc de code plusieurs fois, tant qu'une condition est vérifiée.

for (int i = 0; i < 5; i++) { int i = 0;

[Link](i + " "); while (i < 3) {
} [Link]("i = " + i);
i++;
}
for (String element : array) {
[Link](element);
} int i = 0;
do {
[Link]("i = " + i);
i++;
} while (i < 3);

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 65

Structures de contrôle

C’est quoi le problème ?

int i = 0;
while (i < 5) {
[Link](i);
à Oubli de i++ → condition toujours vraie
}

int i = 0;
while (i < 5) {
[Link](i);
i++; à condition finira par devenir fausse
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 66

Structures de contrôle

int i = 0;

while (true) { // boucle infinie volontaire

i++;
if (i == 3) continue; à saute l'itération quand i vaut 3
if (i == 6) break; à quitte la boucle quand i vaut 6
[Link]("i = " + i);
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 67

Librairie Standard

• La librairie standard Java est un ensemble organisé de packages contenant des classes et interfaces couvrant des fonctionnalités
fondamentales.

Les espaces de noms clés incluent :

import [Link].*; // Importé automatiquement (Math, String, System)
• [Link] : Classes fondamentales (String, Math, Object...) import [Link].*; // Collections, Date, Scanner
• [Link] : Collections, dates, random, regex... import [Link].*; // Entrées/Sorties fichiers
• [Link] : API moderne pour dates et heures import [Link].*; // Réseau
• [Link] : API d'entrées/sorties non-bloquantes import [Link].*; // Base de données

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 68

La Classe Math

• Classe utilitaire avec méthodes statiques uniquement

• Opérations mathématiques déterministes
• Constantes : PI, E
• Ne nécessite pas d'import ([Link])

double resultat = [Link](25);

double puissance = [Link](2, 3);
// Arrondi
long arrondi = [Link](3.6);
// Valeur absolue
int absolu = [Link](-7);
// Puissance
double puis = [Link](2, 3);

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 69

La Classe Math
// Fonctions trigonométriques
• Classe utilitaire avec méthodes statiques uniquement double sin = [Link]([Link]/2);
• Opérations mathématiques déterministes
double cos = [Link](0);
• Constantes : PI, E
//Nombres aléatoires
• Ne nécessite pas d'import ([Link])
double alea = [Link]();

double resultat = [Link](25); // Pour usage avancé, préférer :

double puissance = [Link](2, 3); import [Link]; Random

// Arrondi rand = new Random();

long arrondi = [Link](3.6); int valeur = [Link](100);
// Valeur absolue
// Pour cryptographie :
int absolu = [Link](-7);
// Puissance import [Link];
double puis = [Link](2, 3); SecureRandom sr = new SecureRandom();

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 70

Classes Enveloppes (Wrapper) et autoboxing
• Les classes enveloppes (Integer, Double, Boolean...) encapsulent les types primitifs en objets, permettant leur utilisation dans les contextes qui
nécessitent des objets.
• Ces classes sont immuables : leur valeur ne peut pas être modifiée après création.

Integer a = 5;
int n = 10; Integer b = a + 10;
Integer obj = [Link](n); à conversion int → Integer (boxing)
int m = [Link](); à conversion Integer → int (unboxing) [Link](a); // 5 (a n’a pas changé)
[Link](b); // 15

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 71

Classes Enveloppes (Wrapper) et autoboxing
• Les classes enveloppes (Integer, Double, Boolean...) encapsulent les types primitifs en objets, permettant leur utilisation dans les contextes qui
nécessitent des objets.
• Ces classes sont immuables : leur valeur ne peut pas être modifiée après création.

Integer a = 5;
int n = 10; Integer b = a + 10;
Integer obj = [Link](n); à conversion int → Integer (boxing)
int m = [Link](); à conversion Integer → int (unboxing) [Link](a); // 5 (a n’a pas changé)
[Link](b); // 15

• Autoboxing : conversion automatique d'un primitif vers son wrapper

int n = 10;
Integer obj = n; Avant Java 5, il fallait écrire Integer obj = [Link](n);.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 72

Classes Enveloppes (Wrapper) et autoboxing
• Les classes enveloppes (Integer, Double, Boolean...) encapsulent les types primitifs en objets, permettant leur utilisation dans les contextes qui
nécessitent des objets.
• Ces classes sont immuables : leur valeur ne peut pas être modifiée après création.

Integer a = 5;
int n = 10; Integer b = a + 10;
Integer obj = [Link](n); à conversion int → Integer (boxing)
int m = [Link](); à conversion Integer → int (unboxing) [Link](a); // 5 (a n’a pas changé)
[Link](b); // 15

• Autoboxing : conversion automatique d'un primitif vers son wrapper

• Unboxing : conversion automatique d'un wrapper vers son primitif

Integer obj = 20;

int n = obj;

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 73

Classes Enveloppes (Wrapper) et autoboxing
• Les classes enveloppes (Integer, Double, Boolean...) encapsulent les types primitifs en objets, permettant leur utilisation dans les contextes qui
nécessitent des objets.
• Ces classes sont immuables : leur valeur ne peut pas être modifiée après création.

Integer a = 5;
int n = 10; Integer b = a + 10;
Integer obj = [Link](n); à conversion int → Integer (boxing)
int m = [Link](); à conversion Integer → int (unboxing) [Link](a); // 5 (a n’a pas changé)
[Link](b); // 15
• Autoboxing : conversion automatique d'un primitif vers son wrapper
• Unboxing : conversion automatique d'un wrapper vers son primitif
• Parsing : conversion de String vers primitif (parseXxx)
String s = "123";
int n = [Link](s);
double d = [Link]("3.14");
boolean b = [Link]("true");
N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 74
Classes Enveloppes (Wrapper) et autoboxing
• Les classes enveloppes (Integer, Double, Boolean...) encapsulent les types primitifs en objets, permettant leur utilisation dans les contextes qui
nécessitent des objets.
• Ces classes sont immuables : leur valeur ne peut pas être modifiée après création.

Integer a = 5;
int n = 10; Integer b = a + 10;
Integer obj = [Link](n); à conversion int → Integer (boxing)
int m = [Link](); à conversion Integer → int (unboxing) [Link](a); // 5 (a n’a pas changé)
[Link](b); // 15
• Autoboxing : conversion automatique d'un primitif vers son wrapper
• Unboxing : conversion automatique d'un wrapper vers son primitif
• Parsing : conversion de String vers primitif (parseXxx)
int n = 50;
• Formatting : création à partir d'autres types (valueOf) Integer obj = [Link](n);

String s = "3.14";
Double d = [Link](s);
N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 75
Classes Enveloppes (Wrapper) et autoboxing
• Les classes enveloppes (Integer, Double, Boolean...) encapsulent les types primitifs en objets, permettant leur utilisation dans les contextes qui
nécessitent des objets.
• Ces classes sont immuables : leur valeur ne peut pas être modifiée après création.

int n = 10; String s = "42";

Integer obj = [Link](n); à conversion int → Integer (boxing)
int m = [Link](); à conversion Integer → int (unboxing) // parseXxx() → primitif
int n = [Link](s);
• Autoboxing : conversion automatique d'un primitif vers son wrapper
// valueOf() → wrapper
• Unboxing : conversion automatique d'un wrapper vers son primitif
Integer obj = [Link](s);
• Parsing : conversion de String vers primitif (parseXxx)
• Formatting : création à partir d'autres types (valueOf) // Autoboxing fonctionne aussi
Integer auto = n;
// int → Integer automatiquement

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 76

Classes Enveloppes (Wrapper) et autoboxing
Ø Ne jamais utiliser l'opérateur == pour comparer des objets wrapper : il compare les références, pas les valeurs.

Ø Toujours utiliser la méthode equals() pour comparer les valeurs.

Integer a = 127;
Integer a = new Integer(100); Integer b = 127;
Integer b = new Integer(100); Integer c = 128;
Integer d = 128;
[Link](a == b); false → différentes références // Cache interne pour les valeurs -128 à 127
[Link]([Link](b)); true → mêmes valeurs [Link](a == b);
[Link](c == d);

// Toujours utiliser equals pour comparer

[Link]([Link](b));
[Link]([Link](d));

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 77

Classe String et chaînes de caractères

Ø String est immutable : une fois créé, son contenu ne peut pas être modifié. Toute opération sur un String crée un nouvel objet.
Ø Comparaison correcte : utilisez equals() pour comparer le contenu et non == qui compare les références.

String a = "test";
String b = new String("test");

[Link](a == b); false → références différentes

[Link]([Link](b)); true → valeurs identiques

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 78

Classe String et chaînes de caractères

String s = "Java";
String t = [Link](); // crée un nouvel objet "JAVA”

boolean eq = [Link]("Java");

String u = s + " 17"; // crée un nouvel objet "Java 17"

// Pour manipulation intensive, utilisez StringBuilder

StringBuilder sb = new StringBuilder()
.append("Hello")
.append(" ")
.append("World");

String result = [Link]();

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 79

Classe String et chaînes de caractères

• length() : retourne le nombre de caractères

String s = "Java";
int taille = [Link]();

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 80

Classe String et chaînes de caractères

• length() : retourne le nombre de caractères

String s = "Java";
int taille = [Link]();

• charAt(index) : retourne le caractère à la position donnée

char c = [Link](2);

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 81

Classe String et chaînes de caractères
• length() : retourne le nombre de caractères
String s = "Java";
int taille = [Link]();

• charAt(index) : retourne le caractère à la position donnée

char c = [Link](2);

• substring(start, end) : extrait une partie de la chaîne

String sub = [Link](1, 3);

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 82

Classe String et chaînes de caractères
• length() : retourne le nombre de caractères
String s = "Java";
int taille = [Link]();

• charAt(index) : retourne le caractère à la position donnée

char c = [Link](2);

• substring(start, end) : extrait une partie de la chaîne

String sub = [Link](1, 3);

• indexOf(str) : position de la première occurrence

int pos = [Link]("a");

int pos2 = [Link]("z");

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 83

Classe String et chaînes de caractères
• length() : retourne le nombre de caractères
String s = "Java";
int taille = [Link]();

• charAt(index) : retourne le caractère à la position donnée • equals(obj), equalsIgnoreCase(str) : comparaison

char c = [Link](2); String a = "Java";

String b = "java";
• substring(start, end) : extrait une partie de la chaîne
[Link]([Link](b));
String sub = [Link](1, 3); [Link]([Link](b));

• indexOf(str) : position de la première occurrence

int pos = [Link]("a");

int pos2 = [Link]("z");

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 84

Références vs Primitifs

• En Java, il existe deux catégories de types : les types primitifs qui stockent directement leurs valeurs, et les types par référence qui
stockent l'adresse mémoire de l'objet.

Ø Types primitifs: Les valeurs sont stockées directement dans

la variable (int, double, boolean, char, etc.). La variable
contient la valeur elle-même, pas une adresse.

Ø Types reference: Les variables contiennent une référence

(adresse mémoire) vers l'objet. Deux variables peuvent
référencer le même objet.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 85

Références vs Primitifs

• Passage par valeur: En Java, tout est passé par valeur : pour les primitifs, la valeur est copiée; pour les références, c'est l'adresse qui est
copiée (l'objet peut donc être modifié).

void inc(int x) {
x++;
[Link]("x dans la méthode = " + x);
}

public static void main(String[] args) {

int a = 5;
inc(a);
[Link]("a dans main = " + a);
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 86

Références vs Primitifs

• Passage par valeur: En Java, tout est passé par valeur : pour les primitifs, la valeur est copiée; pour les références, c'est l'adresse qui est
copiée (l'objet peut donc être modifié).

void inc(int x) {
x++;
[Link]("x dans la méthode = " + x);
int[] arr1 = {1, 2, 3};
}
int[] arr2 = arr1;
arr2[0] = 99;
public static void main(String[] args) {
[Link](arr1[0]);
int a = 5;
[Link](arr2[0]);
inc(a);
[Link]("a dans main = " + a);
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 87

Références vs Primitifs
• Qu’affiche ce code?

public static void main(String[] args) {

int a = 10;
int b = a;
b++;

int[] tab1 = {1, 2, 3};

int[] tab2 = tab1;
tab2[0] = 99;

[Link]("a = " + a); // ?

[Link]("b = " + b); // ?
[Link]("tab1[0] = " + tab1[0]); // ?
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 88

Références vs Primitifs
• Qu’affiche ce code?

class Point {
int x;
Point(int x) { this.x = x; }
}

Point p1 = new Point(10);

Point p2 = p1;
p2.x = 20;

[Link](p1.x); // ?
[Link](p2.x); // ?

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 89

Entrées/Sorties, main() et Commentaires
• Tout programme Java nécessite une méthode main() comme point d'entrée, et utilise généralement des classes pour l'entrée/sortie (I/O)
et inclut des commentaires pour faciliter la compréhension.
• Méthode main() : Point d'entrée obligatoire pour tout programme Java exécutable. Signature: public static void main(String[] args)

• Types de commentaires : Commentaire sur une ligne (//), bloc de commentaires (/* */), documentation Javadoc (/**...*/)
/**
* Classe Bonjour : affiche un message de bienvenue.
* @author David
* @version 1.0
*/
public class Bonjour { • Génération de documentation avec Javadoc:
/**
javadoc [Link]
* Méthode principale du programme.
* @param args arguments de la ligne de commande
*/
public static void main(String[] args) {
[Link]("Bonjour !");
}
}
N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 90
Entrées/Sorties, main() et Commentaires
• Tout programme Java nécessite une méthode main() comme point d'entrée, et utilise généralement des classes pour l'entrée/sortie (I/O)
et inclut des commentaires pour faciliter la compréhension.
• Méthode main() : Point d'entrée obligatoire pour tout programme Java exécutable. Signature: public static void main(String[] args)

• Types de commentaires : Commentaire sur une ligne (//), bloc de commentaires (/* */), documentation Javadoc (/**...*/)

• Entrées : La classe Scanner du package [Link] permet de lire les entrées de l'utilisateur via la console.
import [Link];

public class LectureInput {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
[Link]("Entrez votre nom : ");
String nom = [Link]();
[Link]("Bonjour " + nom + " !");
[Link]()
}
}
N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 91
Entrées/Sorties, main() et Commentaires
• Tout programme Java nécessite une méthode main() comme point d'entrée, et utilise généralement des classes pour l'entrée/sortie (I/O)
et inclut des commentaires pour faciliter la compréhension.
• Méthode main() : Point d'entrée obligatoire pour tout programme Java exécutable. Signature: public static void main(String[] args)

• Types de commentaires : Commentaire sur une ligne (//), bloc de commentaires (/* */), documentation Javadoc (/**...*/)

• Entrées : La classe Scanner du package [Link] permet de lire les entrées de l'utilisateur via la console.

• Sorties: pour afficher du texte dans la console.

[Link]("Bonjour ");

[Link]("le monde !");

[Link]("J'ai %d pommes et le prix est de %.2f euros.", 5, 1.50);

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 92

Manipulation de fichiers (I/O)
• Java fournit dans le package [Link] (et aussi [Link] pour les versions plus modernes) une série de classes et de flux (Streams) pour gérer les
operations D’I/O.

• Depuis Java 7, le package [Link] introduit :

La classe Paths → pour manipuler les chemins de fichiers/dossiers.
La classe Files → pour effectuer des opérations sur les fichiers et répertoires (lecture, écriture, suppression, copie, etc.).

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 93

Manipulation de fichiers (I/O)
• Java fournit dans le package [Link] (et aussi [Link] pour les versions plus modernes) une série de classes et de flux (Streams) pour gérer les
operations D’I/O.

• Depuis Java 7, le package [Link] introduit :

La classe Paths → pour manipuler les chemins de fichiers/dossiers.
La classe Files → pour effectuer des opérations sur les fichiers et répertoires (lecture, écriture, suppression, copie, etc.).
import [Link];
import [Link];

public class ExemplePaths {

public static void main(String[] args) {
Path chemin = [Link]("C:/Users/Etudiant/Documents/[Link]");

[Link]("Nom du fichier : " + [Link]());

[Link]("Dossier parent : " + [Link]());
[Link]("Chemin absolu : " + [Link]());
[Link]("Nombre d’éléments dans le chemin : " + [Link]());
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 94

Manipulation de fichiers (I/O)
• Java fournit dans le package [Link] (et aussi [Link] pour les versions plus modernes) une série de classes et de flux (Streams) pour gérer les
operations D’I/O.

• Depuis Java 7, le package [Link] introduit :

La classe Paths → pour manipuler les chemins de fichiers/dossiers.
La classe Files → pour effectuer des opérations sur les fichiers et répertoires (lecture, écriture, suppression, copie, etc.).

import [Link].*;

public class ExempleFiles {

public static void main(String[] args) {
Path fichier = [Link]("[Link]");

if ([Link](fichier)) {
[Link]("Le fichier existe !");
} else {
[Link]("Le fichier n’existe pas !");
}
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 95

Manipulation de fichiers (I/O)

• Que fait ce code?

Path nouveau = [Link]("[Link]");

[Link](nouveau);
[Link]("Fichier créé !");

Path dossier = [Link]("MonDossier");

[Link](dossier);
[Link]("Dossier créé !");

Path source = [Link]("[Link]");

Path destination = [Link]("copie_message.txt");

[Link](source, destination, StandardCopyOption.REPLACE_EXISTING);

[Link]("Copie effectuée !");

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 96

Manipulation de fichiers (I/O)
import [Link].*;
import [Link];

public class DemoNIO {

public static void main(String[] args) {
Path fichier = [Link]("[Link]");
try {
[Link](fichier);
[Link]("Fichier créé : " + [Link]());

[Link](fichier, "Bienvenue dans le monde de Java NIO.2 !");

[Link]("Contenu écrit.");

String contenu = [Link](fichier);

[Link]("Contenu du fichier : " + contenu);

[Link](fichier);
[Link]("Fichier supprimé !");
} catch (IOException e) {
[Link]("Erreur : " + [Link]());
}
}
}

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 97

Manipulation de fichiers (I/O)
• En Java, la manipulation des fichiers et des flux d’entrée/sortie (I/O : Input/Output) repose sur deux grandes hiérarchies de classes, selon
le type de données manipulées :

§ octets (bytes) ➜ pour les données binaires,

§ caractères (chars) ➜ pour le texte.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 98

Manipulation de fichiers (I/O)
• En Java, la manipulation des fichiers et des flux d’entrée/sortie (I/O : Input/Output) repose sur deux grandes hiérarchies de classes, selon
le type de données manipulées :

§ octets (bytes) ➜ pour les données binaires,

§ caractères (chars) ➜ pour le texte.

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 99

Paquetages (Packages) en Java

• Un package en Java est un espace de noms (namespace) qui permet de regrouper des classes, interfaces et sous-packages liés par une même
thématique.

package [Link]; import [Link];

public class Calculatrice { public class Test {

public int addition(int a, int b) { public static void main(String[] args) {
return a + b; Calculatrice c = new Calculatrice();
} [Link]([Link](5, 3));
} }
} public class Test {
Projet/
└── src/ public static void main(String[] args) {
└── com/ [Link] c = new [Link]();
└── exemple/ [Link]([Link](5, 3));
└── util/ }
└── [Link] }

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 100

Paquetages (Packages) en Java
package [Link];

class Produit { } // accessible seulement dans le même package

public class Article { } // accessible partout

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 101

Paquetages (Packages) en Java
package [Link];
package moduleB;
class Produit { } // accessible seulement dans le même package
import [Link];
public class Article { } // accessible partout
public class TestAccess {
public static void main(String[] args) {
package moduleA; ClasseProtegee instance = new ClasseProtegee();

public class ClasseProtegee { // 1. Accès Public

public String champPublic = "Accès public OK"; [Link]("1. Public : " + [Link]);
String champParDefaut = "Accès par défaut dans Module A";
void afficherMessageInterne() { // [Link]("2. Par Défaut : " + [Link]);
[Link]("Message de la classe interne de moduleA."); // [Link]();
} }
} }
// 2. Accès Par Défaut (ÉCHEC)

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 102

Exercice

Écrire une classe MotUtils qui permet de :

§ Lire un mot saisi par l’utilisateur.

§ Afficher :

1. Le mot en majuscules
2. Le nombre de lettres
3. Si le mot commence par une voyelle ou une consonne

à Quelle méthode doit être static ? Pourquoi ?

N. Idrissi -- Département d’Informatique, FSJ, UCD - Programmation orientée objet–Java - 103