Java pour Débutants

Livre d'exercices — Les fonctions

Version simplifiée et expliquée pas à pas

Dans l'univers d'Epicrafter's Journey

1
 Introduction
Bienvenue ! Dans ce livre, tu vas apprendre à utiliser les fonctions en Java. Tu connais déjà les
variables et les tableaux. Maintenant, on va apprendre à organiser le code.

■■ Ne jamais regarder la correction avant d'avoir vraiment essayé !

■ Si tu bloques, utilise l'indice. Recommence les exercices ratés.

Comment lire ce livre :

1. Lis le cours (il y a des analogies pour tout expliquer simplement)

2. Regarde les exemples de code

3. Essaie l'exercice tout seul

4. Regarde la correction seulement après avoir essayé

2
 Chapitre 1 — C'est quoi une fonction ?

■ Cours
L'analogie du bouton micro-ondes
Imagine un micro-ondes. Il a un bouton "Réchauffer 1 minute". Tu appuies dessus et il fait tout
seul : allumer la lumière, faire tourner le plateau, chauffer 60 secondes, biper. Tu n'as pas besoin
de savoir comment ça marche à l'intérieur. Tu appuies sur le bouton, ça fait le travail.

Une fonction en Java, c'est pareil. C'est un bouton que tu crées toi-même, qui fait un travail
précis. Tu appelles ce bouton quand tu en as besoin.

Sans fonction — problème

Imagine que tu veux afficher "Bonjour Steve !" à 5 endroits dans ton programme. Sans fonction,
tu réécris la même ligne 5 fois. Si tu veux changer le message, tu dois modifier 5 lignes. C'est
long et risqué.

Avec fonction — solution

Tu crées une fonction une seule fois. Tu l'appelles 5 fois. Si tu veux changer le message, tu
modifies juste la fonction : les 5 appels changent automatiquement.

La structure d'une fonction

public static void direBonjour () {

↑↑↑↑

toujours void = rien le nom paramètres

mettre ça à retourner (tu choisis) (vides ici)

public static void direBonjour() {

[Link]("Bonjour !");
}

// Dans le main, tu APPELLES la fonction comme ça :

direBonjour(); // affiche : Bonjour !
direBonjour(); // affiche encore : Bonjour !
direBonjour(); // et encore : Bonjour !

■ La fonction doit être DEHORS du main, mais DANS la classe. Le main APPELLE la
fonction avec son nom suivi de ().

Passer des informations à une fonction (les paramètres)

3
Tu peux donner des informations à ta fonction, comme donner un nom au micro-ondes pour qu'il
affiche "Bonjour [ton nom] !". Ces informations s'appellent des paramètres.

// La fonction reçoit un String appelé 'nom'

public static void saluer(String nom) {
[Link]("Bonjour " + nom + " !");
}

// Dans le main :
saluer("Steve"); // affiche : Bonjour Steve !
saluer("Alex"); // affiche : Bonjour Alex !

Récupérer un résultat (le retour)

Parfois, tu veux que la fonction te donne quelque chose en retour. Comme une calculatrice : tu
entres 3 + 5, elle te rend 8. Pour ça, on remplace void par le type du résultat, et on utilise return.

// ↓ int = la fonction retourne un nombre entier

public static int additionner(int a, int b) {
return a + b; // return = 'je te rends ce résultat'
}

// Dans le main :
int resultat = additionner(3, 5);
[Link](resultat); // affiche : 8

■ RÉSUMÉ : les 2 types de fonctions

void → la fonction fait quelque chose mais ne retourne RIEN

Exemple : afficher un message

int / double / String / boolean → la fonction RETOURNE un résultat

Exemple : calculer une somme, vérifier une condition

✏■ Exercices — Chapitre 1
✏■ Exercice 1 — Ma première fonction

Énoncé : Crée une fonction 'afficherBienvenue()' qui affiche 'Bienvenue dans Epicrafter Journey
!'. Appelle-la dans le main.
Résultat attendu : Bienvenue dans Epicrafter Journey !
Indice : C'est une fonction void (elle n'a rien à retourner). Écris-la AVANT le main.

Mon code :

4
 ✏■ Exercice 2 — Fonction avec un paramètre

Énoncé : Crée une fonction 'saluer(String nom)' qui affiche 'Bonjour [nom] !'. Appelle-la avec
'Steve' puis 'Alex'.
Résultat attendu : Bonjour Steve ! Bonjour Alex !
Indice : Mets String nom entre les parenthèses. Utilise nom dans le println.

Mon code :

✏■ Exercice 3 — Fonction qui retourne un int

Énoncé : Crée une fonction 'doubler(int n)' qui retourne n * 2. Affiche le résultat pour n=7.
Résultat attendu : Résultat : 14
Indice : Remplace void par int. Utilise return n * 2;

Mon code :

✏■ Exercice 4 — Appels multiples

Énoncé : Crée une fonction 'afficherEtoiles(int nb)' qui affiche une ligne d'étoiles. Appelle-la
avec 3, 5 et 7.
Résultat attendu : *** ***** *******
Indice : Utilise '*'.repeat(nb) pour créer les étoiles.

Mon code :

✏■ Exercice 5 — Fonction boolean

Énoncé : Crée une fonction 'estPair(int n)' qui retourne true si n est pair, false sinon. Teste avec
4 et 7.

5
Résultat attendu : 4 est pair : true 7 est pair : false
Indice : Un nombre est pair si n % 2 == 0. Le type de retour est boolean.

Mon code :

✏■ Exercice 6 — Réutiliser une fonction

Énoncé : Crée une fonction 'afficherJoueur(String nom, int niveau)' et appelle-la 3 fois avec des
données différentes.
Indice : Deux paramètres : un String et un int. Utilise-les tous les deux dans le println.

Mon code :

✏■ Exercice 7 — Retourner un double

Énoncé : Crée une fonction 'calculerPrix(double prix, int quantite)' qui retourne le total. Teste
avec prix=5.99 et quantite=3.
Résultat attendu : Total : 17.97
Indice : Type de retour : double. return prix * quantite;

Mon code :

✏■ Exercice 8 — Appel dans println

Énoncé : Crée une fonction 'getMax(int a, int b)' qui retourne le plus grand. Affiche le résultat
dans un println.
Résultat attendu : Le plus grand est : 12
Indice : Tu peux écrire : [Link](getMax(7, 12));

Mon code :

6
 ✏■ Exercice 9 — Retourner un String

Énoncé : Crée une fonction 'creerMessage(String pseudo, int score)' qui retourne 'Bravo
[pseudo] ! Score : [score]'.
Résultat attendu : Bravo Steve ! Score : 1250
Indice : Type de retour : String. return 'Bravo ' + pseudo + ...

Mon code :

✏■ Exercice 10 — Synthèse chapitre 1

Énoncé : Crée 3 fonctions : afficherTitre() void, calculerNiveau(int xp) qui retourne xp/100, et
afficherFiche(String nom, int xp) qui appelle calculerNiveau. Utilise-les dans le main.
Indice : Les fonctions peuvent s'appeler entre elles. afficherFiche peut appeler calculerNiveau à l'intérieur.

Mon code :

7
 Chapitre 2 — Paramètres et retour de valeurs

■ Cours
Passage par valeur — l'analogie de la photocopie
Quand tu passes une variable à une fonction, Java fait une photocopie de ta variable. La
fonction travaille sur la copie. L'original ne change pas.

public static void doubler(int n) {

n = n * 2; // on modifie la COPIE, pas l'original
}

int score = 10;

doubler(score);
[Link](score); // affiche encore 10 !

■■ Pour changer une variable, il faut RETOURNER la nouvelle valeur et la RÉAFFECTER :

score = doubler(score);

Les fonctions peuvent s'appeler entre elles

Une fonction peut appeler une autre fonction. C'est très courant en Java.

public static int multiplier(int a, int b) {

return a * b;
}

public static int calculerDegats(int att, int def, int multiplicateur) {

int base = att - def;
return multiplier(base, multiplicateur); // appelle multiplier !
}

Retourner un tableau
Une fonction peut aussi retourner un tableau. Le type de retour s'écrit avec des crochets : int[]
ou String[].

public static String[] creerEquipe(String j1, String j2) {

String[] equipe = {j1, j2};
return equipe;
}

// Dans le main :

8
 String[] monEquipe = creerEquipe("Steve", "Alex");
[Link](monEquipe[0]); // Steve

✏■ Exercices — Chapitre 2
✏■ Exercice 11 — Retour et réaffectation

Énoncé : Crée une fonction 'augmenterScore(int score, int bonus)' qui retourne score + bonus.
Dans le main, applique-la sur une variable score = 100 avec bonus = 50.
Résultat attendu : Score avant : 100 Score après : 150
Indice : Pour que score change, écris : score = augmenterScore(score, 50);

Mon code :

✏■ Exercice 12 — Fonctions imbriquées

Énoncé : Crée une fonction 'multiplier(int a, int b)' et une fonction 'carre(int n)' qui utilise
multiplier pour retourner n*n.
Résultat attendu : Carré de 5 : 25
Indice : Dans carre, appelle multiplier(n, n) et retourne le résultat.

Mon code :

✏■ Exercice 13 — Retourner un tableau

Énoncé : Crée une fonction 'creerInventaire(String obj1, String obj2, String obj3)' qui retourne un
tableau String de 3 éléments.
Indice : Type de retour : String[]. Crée le tableau dans la fonction et retourne-le.

Mon code :

✏■ Exercice 14 — Montrer le passage par valeur

9
Énoncé : Déclare vie = 100. Crée une fonction 'reduireVie(int v, int degats)' qui retourne v -
degats. Montre d'abord sans réaffecter (vie reste 100), puis avec réaffectation.
Résultat attendu : Sans réaffectation : 100 Avec réaffectation : 75
Indice : Appelle d'abord sans sauvegarder. Puis : vie = reduireVie(vie, 25);

Mon code :

✏■ Exercice 15 — Calculer une moyenne

Énoncé : Crée une fonction 'moyenne(int a, int b, int c)' qui retourne la moyenne des 3 entiers
en double. Teste avec 80, 90, 70.
Résultat attendu : Moyenne : 80.0
Indice : Type de retour : double. Calcule (a + b + c) / 3.0 (le .0 force le résultat en décimal).

Mon code :

✏■ Exercice 16 — Décrire un monstre

Énoncé : Crée une fonction 'decrireMonstre(String nom, int pv, boolean estBoss)' qui retourne
une description complète.
Résultat attendu : Dragon | PV: 500 | Boss: true
Indice : Type de retour : String. Concatène tous les paramètres dans un message.

Mon code :

✏■ Exercice 17 — Vérifier une valeur

Énoncé : Crée une fonction 'estNiveauValide(int niveau)' qui retourne true si niveau est entre 1
et 100.
Résultat attendu : Niveau 5 valide : true Niveau 150 valide : false
Indice : Utilise && : return niveau >= 1 && niveau <= 100;

Mon code :

10
 ✏■ Exercice 18 — Chaine de fonctions

Énoncé : Crée calculerAttaque(int base, int bonus) et calculerDefense(int base, int bonus). Puis
afficherCombat(int attJ, int defE, int attE, int defJ) qui utilise les deux fonctions.
Indice : afficherCombat appelle calculerAttaque et calculerDefense à l'intérieur.

Mon code :

✏■ Exercice 19 — Reformater un String

Énoncé : Crée une fonction 'nomComplet(String prenom, String nom)' qui retourne 'NOM,
Prenom' (nom en majuscules avec toUpperCase()).
Résultat attendu : CRAFTER, Epic
Indice : return [Link]() + ', ' + prenom;

Mon code :

✏■ Exercice 20 — Synthèse chapitre 2

Énoncé : Crée un mini-combat : calculerDegats(int att, int def) retourne att-def,

appliquerDegats(int pv, int d) retourne pv-d, estVivant(int pv) retourne pv > 0. Simule un échange
de coups.
Indice : Appelle les fonctions dans l'ordre : dégâts → application → vérification → affichage.

Mon code :

11
 Chapitre 3 — La surcharge (même nom, paramètres
différents)

■ Cours
L'analogie du café
Au café, tu peux commander "un café", "un café avec du sucre", ou "un café avec du sucre et du
lait". C'est toujours un café, mais la commande change selon ce que tu précises. En Java, c'est
pareil : même nom de fonction, mais des paramètres différents.

Exemple de surcharge
// Version 1 : avec 2 paramètres
public static int additionner(int a, int b) {
return a + b;
}

// Version 2 : avec 3 paramètres (même nom !)

public static int additionner(int a, int b, int c) {
return a + b + c;
}

// Java choisit automatiquement la bonne version :

additionner(3, 5); // utilise la version 1 → 8
additionner(3, 5, 2); // utilise la version 2 → 10

■ Surcharge valide : nombre de paramètres différent

■ Surcharge valide : types de paramètres différents

■ Invalide : même nom, mêmes paramètres, juste le type de retour qui change

✏■ Exercices — Chapitre 3
✏■ Exercice 21 — Surcharge simple

Énoncé : Crée deux versions : 'afficher(int n)' affiche 'Entier : n', 'afficher(double n)' affiche
'Décimal : n'. Teste les deux.
Résultat attendu : Entier : 42 Décimal : 3.14
Indice : Même nom, types différents. Java choisit selon ce que tu passes.

Mon code :

12
 ✏■ Exercice 22 — Surcharge par nombre

Énoncé : Crée 3 versions de 'additionner' : avec 2, 3 et 4 paramètres int. Teste chacune.

Résultat attendu : 2 params : 7 3 params : 12 4 params : 22
Indice : Java distingue les versions selon le nombre d'arguments.

Mon code :

✏■ Exercice 23 — Attaque surchargée

Énoncé : Crée 'attaquer(int degats)' et 'attaquer(int degats, boolean critique)'. Si critique=true,

les dégâts sont doublés.
Résultat attendu : Dégâts normaux : 25 Dégâts critiques : 50
Indice : Dans la 2e version : if (critique) return degats * 2; return degats;

Mon code :

✏■ Exercice 24 — Salutation surchargée

Énoncé : Crée 'saluer(String nom)' et 'saluer(String nom, int niveau)'. La 2e affiche aussi le
niveau.
Indice : La 1re version affiche juste le nom, la 2e affiche le nom ET le niveau.

Mon code :

✏■ Exercice 25 — Soin souple

Énoncé : Crée 'soigner(int pv, int soin)' qui ne dépasse pas 100, et 'soigner(int pv, int soin, int
pvMax)' qui ne dépasse pas pvMax.
Résultat attendu : PV soignés (max 100) : 95 PV soignés (max 200) : 175
Indice : Utilise [Link](pv + soin, pvMax) pour ne pas dépasser le maximum.

Mon code :

13
 ✏■ Exercice 26 — Afficher un item

Énoncé : Crée 'afficherItem(String nom)' et 'afficherItem(String nom, int quantite)'. La 2e affiche

'nom x quantite'.
Résultat attendu : Épée légendaire Potion x 5
Indice : Version 1 : juste le nom. Version 2 : nom + ' x ' + quantite.

Mon code :

✏■ Exercice 27 — Score souple

Énoncé : Crée 'ajouterScore(int score, int pts)' et 'ajouterScore(int score, int pts, double mult)'.
La 2e multiplie les pts avant de les ajouter.
Résultat attendu : Score normal : 1100 Score x2 : 1200
Indice : Version 2 : return score + (int)(pts * mult);

Mon code :

✏■ Exercice 28 — Message de résultat

Énoncé : Crée 'getMessage(String joueur)' qui retourne un message neutre, et

'getMessage(String joueur, boolean victoire)' qui retourne victoire ou défaite.
Indice : Utilise un if : if (victoire) return joueur + ' a gagné !'; return joueur + ' a perdu.';

Mon code :

✏■ Exercice 29 — Résumé court ou long

Énoncé : Crée 'resume(int score)' qui affiche juste le score, et 'resume(int score, int niveau,
String nom)' qui affiche tout.

14
Indice : Même nom, mais la 2e version a 3 paramètres au lieu d'un.

Mon code :

✏■ Exercice 30 — Synthèse chapitre 3

Énoncé : Crée un système de description de personnage surchargé : 'decrire(String nom)',

'decrire(String nom, int pv)', 'decrire(String nom, int pv, int attaque)'. Chaque version affiche plus
d'informations.
Indice : Commence par la version la plus simple, ajoute les paramètres progressivement.

Mon code :

15
 Chapitre 4 — Fonctions et tableaux

■ Cours
Passer un tableau à une fonction
Tu peux passer un tableau en paramètre. On écrit le type suivi de crochets : int[] ou String[].

public static void afficherScores(int[] scores) {

[Link](scores[0]);
[Link](scores[1]);
[Link](scores[2]);
}

// Dans le main :
int[] mesScores = {100, 200, 300};
afficherScores(mesScores);

Retourner un tableau
public static int[] creerScores(int s1, int s2, int s3) {
int[] scores = {s1, s2, s3};
return scores;
}

// Dans le main :
int[] s = creerScores(450, 820, 310);
[Link](s[0]); // 450

Important : les tableaux sont partagés (pas copiés !)

Avec les types simples (int, double...), Java passe une copie. Avec les tableaux, Java partage le
tableau original. Si la fonction modifie le tableau, l'original change aussi !

public static void mettreAZero(int[] t) {

t[0] = 0; // modifie le tableau ORIGINAL
}

int[] vals = {10, 20, 30};

mettreAZero(vals);
[Link](vals[0]); // affiche 0 !

16
 ■ C'est différent des int et double ! Avec un tableau, la fonction travaille sur l'original, pas
une copie.

✏■ Exercices — Chapitre 4
✏■ Exercice 31 — Passer un tableau

Énoncé : Crée une fonction 'afficherScores(int[] scores)' qui affiche les 3 premiers éléments.
Crée un tableau dans le main et passe-le.
Résultat attendu : Score 1 : 450 Score 2 : 820 Score 3 : 310
Indice : Accède aux éléments avec scores[0], scores[1], scores[2].

Mon code :

✏■ Exercice 32 — Somme d'un tableau

Énoncé : Crée une fonction 'somme(int[] t)' qui retourne la somme des 5 éléments.
Résultat attendu : Somme : 850
Indice : Additionne t[0]+t[1]+t[2]+t[3]+t[4] et retourne le total.

Mon code :

✏■ Exercice 33 — Maximum d'un tableau

Énoncé : Crée une fonction 'maximum(int[] t)' qui retourne le plus grand des 5 éléments.
Résultat attendu : Maximum : 950
Indice : Commence avec max = t[0]. Compare avec chaque élément : if (t[1] > max) max = t[1]; etc.

Mon code :

✏■ Exercice 34 — Retourner un tableau

Énoncé : Crée une fonction 'creerEquipe(String j1, String j2, String j3)' qui retourne un tableau
String de 3 joueurs.

17
Indice : String[] equipe = {j1, j2, j3}; return equipe;

Mon code :

✏■ Exercice 35 — Initialiser un tableau

Énoncé : Crée une fonction 'initTableau(int valeur)' qui retourne un tableau de 5 int, tous égaux
à valeur.
Résultat attendu : Tableau : 0 0 0 0 0
Indice : int[] t = new int[5]; t[0]=valeur; t[1]=valeur; ... return t;

Mon code :

✏■ Exercice 36 — Moyenne d'un tableau

Énoncé : Crée une fonction 'moyenne(int[] t)' qui retourne la moyenne des 5 éléments en
double.
Résultat attendu : Moyenne : 680.0
Indice : double total = t[0]+t[1]+t[2]+t[3]+t[4]; return total / 5.0;

Mon code :

✏■ Exercice 37 — Classement avec deux tableaux

Énoncé : Crée une fonction 'afficherClassement(String[] noms, int[] scores)' qui affiche 3 joueurs
avec leurs scores.
Résultat attendu : 1. Alpha - 9500 pts 2. Beta - 8200 pts 3. Gamma - 7800 pts
Indice : Utilise le même indice pour les deux tableaux : noms[0] correspond à scores[0].

Mon code :

18
 ✏■ Exercice 38 — Modifier un tableau

Énoncé : Crée une fonction 'ajouterBonus(int[] scores, int bonus)' qui ajoute bonus à chaque
élément. Affiche avant et après.
Résultat attendu : Avant : 100 200 300 Après : 150 250 350
Indice : Modifie directement : scores[0] += bonus; etc. Le tableau original sera changé.

Mon code :

✏■ Exercice 39 — Copier un tableau

Énoncé : Crée une fonction 'copier(int[] source)' qui retourne un NOUVEAU tableau avec les
mêmes valeurs. Modifie la copie et montre que l'original n'a pas changé.
Résultat attendu : Original : 10 20 30 Copie modifiée : 99 20 30
Indice : int[] copie = new int[3]; copie[0]=source[0]; ... return copie;

Mon code :

✏■ Exercice 40 — Synthèse chapitre 4

Énoncé : Crée un classement complet : afficherClassement(String[], int[]),

trouverMeilleur(String[], int[]) qui retourne le nom du joueur avec le plus grand score.
Résultat attendu : Meilleur : Alpha avec 9500 points
Indice : Pour trouverMeilleur : trouve d'abord l'indice du score maximum, puis retourne le nom à cet indice.

Mon code :

19
 Chapitre 5 — Exercices de synthèse

■ Rappels rapides
void direBonjour() → fait quelque chose, retourne rien

int additionner(int a, int b) → retourne un int

String getMessage(String nom) → retourne un String

int[] creerTableau(...) → retourne un tableau

Surcharge : même nom, paramètres différents → Java choisit automatiquement

Tableau en paramètre : partagé (modifie l'original)

int en paramètre : copié (l'original ne change pas)

■■ Ces exercices combinent tout ce qu'on a vu. Planifie tes fonctions avant de coder.

✏■ Exercices — Chapitre 5
✏■ Exercice 41 — Fiche de personnage

Énoncé : Crée : creerNom(String prenom, String classe) retourne 'prenom le classe',

calculerPV(int niveau) retourne niveau*50, afficherFiche(String nom, int pv) affiche tout.
Utilise-les toutes.
Indice : afficherFiche appelle les autres fonctions. Teste avec niveau=5 et classe='Guerrier'.

Mon code :

✏■ Exercice 42 — Combat complet

Énoncé : Crée : calculerDegats(int att, int def), appliquerDegats(int pv, int d), estVivant(int pv),
afficherEtat(String nom, int pv). Simule 2 rounds.
Indice : Simule : round 1 → calcule les dégâts des deux côtés → applique → affiche. Même chose round
2.

Mon code :

20
 ✏■ Exercice 43 — Magasin

Énoncé : Crée : afficherArticle(String nom, double prix), calculerTotal(double p1, double p2,
double p3), peutAcheter(double budget, double total). Simule un achat.
Indice : Calcule le total avec calculerTotal, puis vérifie avec peutAcheter.

Mon code :

✏■ Exercice 44 — Statistiques de scores

Énoncé : Avec int[] scores = {850, 1200, 430, 990, 670}, crée : somme(int[]), maximum(int[]),
minimum(int[]), moyenne(int[]). Affiche tout.
Résultat attendu : Total : 4140 Max : 1200 Min : 430 Moyenne : 828.0
Indice : Chaque fonction fait une seule chose. Appelle-les une par une dans le main.

Mon code :

✏■ Exercice 45 — Rapport de mission

Énoncé : Crée : entete(String mission, String joueur), bonusTemps(int duree) retourne 500 si
duree<300 sinon 0, scoreFinal(int base, int enemis, int bonus). Affiche un rapport complet.
Indice : scoreFinal = base + (enemis * 50) + bonus. Appelle toutes les fonctions dans le main.

Mon code :

21
 CORRECTIONS
■■ Ne lisez cette section qu'après avoir vraiment essayé chaque exercice !

Corrections — Chapitre 1
■ Correction 1 — Ma première fonction

La fonction est déclarée AVANT le main, et appelée à l'intérieur du main.

public class Main {
public static void afficherBienvenue() {
[Link]("Bienvenue dans Epicrafter Journey !");
}

public static void main(String[] args) {

afficherBienvenue();
}
}

■ Correction 2 — Fonction avec un paramètre

Le paramètre 'nom' est utilisé dans le println.

public static void saluer(String nom) {
[Link]("Bonjour " + nom + " !");
}

// Dans le main :
saluer("Steve");
saluer("Alex");

■ Correction 3 — Fonction qui retourne un int

On remplace void par int et on utilise return.

public static int doubler(int n) {
return n * 2;
}

int res = doubler(7);

[Link]("Résultat : " + res);

22
 ■ Correction 4 — Appels multiples

repeat() crée une chaîne répétée autant de fois que demandé.

public static void afficherEtoiles(int nb) {
[Link]("*".repeat(nb));
}

afficherEtoiles(3);
afficherEtoiles(5);
afficherEtoiles(7);

■ Correction 5 — Fonction boolean

% 2 == 0 retourne true si le nombre est pair.

public static boolean estPair(int n) {
return n % 2 == 0;
}

[Link]("4 est pair : " + estPair(4));

[Link]("7 est pair : " + estPair(7));

■ Correction 6 — Réutiliser une fonction

On appelle la même fonction avec des données différentes à chaque fois.

public static void afficherJoueur(String nom, int niveau) {
[Link]("Joueur : " + nom + " | Niveau : " + niveau);
}

afficherJoueur("Steve", 5);
afficherJoueur("Alex", 12);
afficherJoueur("Notch", 99);

■ Correction 7 — Retourner un double

Le type de retour est double. Le calcul prix * quantite donne un double.

public static double calculerPrix(double prix, int quantite) {
return prix * quantite;
}

double total = calculerPrix(5.99, 3);

[Link]("Total : " + total);

23
 ■ Correction 8 — Appel dans println

L'appel de fonction peut se faire directement à l'intérieur du println.

public static int getMax(int a, int b) {
if (a > b) return a;
return b;
}

[Link]("Le plus grand est : " + getMax(7, 12));

■ Correction 9 — Retourner un String

On construit le message avec + et on le retourne.

public static String creerMessage(String pseudo, int score) {
return "Bravo " + pseudo + " ! Score : " + score;
}

[Link](creerMessage("Steve", 1250));

■ Correction 10 — Synthèse chapitre 1

afficherFiche appelle calculerNiveau à l'intérieur.

public static void afficherTitre() {
[Link]("=== EPICRAFTER JOURNEY ===");
}
public static int calculerNiveau(int xp) { return xp / 100; }
public static void afficherFiche(String nom, int xp) {
[Link]("Joueur : " + nom);
[Link]("XP : " + xp + " | Niveau : " + calculerNiveau(xp));
}

afficherTitre();
afficherFiche("Epicrafter", 850);

Corrections — Chapitre 2
■ Correction 11 — Retour et réaffectation

Sans réaffectation, score reste à 100. Avec, il passe à 150.

public static int augmenterScore(int score, int bonus) {
return score + bonus;

24
 }

int score = 100;

[Link]("Avant : " + score);
score = augmenterScore(score, 50);
[Link]("Après : " + score);

■ Correction 12 — Fonctions imbriquées

carre appelle multiplier(n, n) pour calculer le carré.

public static int multiplier(int a, int b) { return a * b; }
public static int carre(int n) { return multiplier(n, n); }

[Link]("Carré de 5 : " + carre(5));

■ Correction 13 — Retourner un tableau

Le type de retour est String[]. On crée et retourne le tableau.

public static String[] creerInventaire(String o1, String o2, String o3) {
String[] inv = {o1, o2, o3};
return inv;
}

String[] inv = creerInventaire("Épée", "Bouclier", "Potion");

[Link](inv[0] + " | " + inv[1] + " | " + inv[2]);

■ Correction 14 — Passage par valeur

Sans réaffectation, la variable originale ne change pas.

public static int reduireVie(int v, int degats) { return v - degats; }

int vie = 100;

reduireVie(vie, 25); // pas de réaffectation
[Link]("Sans réaffectation : " + vie); // 100
vie = reduireVie(vie, 25);
[Link]("Avec réaffectation : " + vie); // 75

■ Correction 15 — Calculer une moyenne

Le .0 dans la division force le résultat en décimal.

public static double moyenne(int a, int b, int c) {
return (a + b + c) / 3.0;

25
 }

[Link]("Moyenne : " + moyenne(80, 90, 70));

■ Correction 16 — Décrire un monstre

On construit et retourne un String avec tous les paramètres.

public static String decrireMonstre(String nom, int pv, boolean boss) {
return nom + " | PV: " + pv + " | Boss: " + boss;
}

[Link](decrireMonstre("Dragon", 500, true));

■ Correction 17 — Vérifier une valeur

&& signifie 'et'. Les deux conditions doivent être vraies.

public static boolean estNiveauValide(int niveau) {
return niveau >= 1 && niveau <= 100;
}

[Link](estNiveauValide(5)); // true
[Link](estNiveauValide(150)); // false

■ Correction 18 — Chaîne de fonctions

afficherCombat appelle les autres fonctions à l'intérieur.

public static int calculerAttaque(int base, int bonus) { return base+bonus;
}
public static int calculerDefense(int base, int bonus) { return base+bonus;
}
public static void afficherCombat(int attJ, int defE, int attE, int defJ) {
int degJ = calculerAttaque(attJ, 0) - calculerDefense(defE, 0);
int degE = calculerAttaque(attE, 0) - calculerDefense(defJ, 0);
[Link]("Joueur inflige : " + degJ);
[Link]("Ennemi inflige : " + degE);
}

■ Correction 19 — Reformater un String

toUpperCase() met tout en majuscules.

public static String nomComplet(String prenom, String nom) {
return [Link]() + ", " + prenom;

26
 }

[Link](nomComplet("Epic", "Crafter")); // CRAFTER, Epic

■ Correction 20 — Synthèse chapitre 2

On enchaîne les fonctions dans l'ordre logique d'un combat.

public static int calculerDegats(int att, int def) { return att - def; }
public static int appliquerDegats(int pv, int d) { return pv - d; }
public static boolean estVivant(int pv) { return pv > 0; }

int pvH = 100; int pvE = 60;

pvE = appliquerDegats(pvE, calculerDegats(35, 5));
pvH = appliquerDegats(pvH, calculerDegats(15, 20));
[Link]("Joueur vivant : " + estVivant(pvH));
[Link]("Ennemi vivant : " + estVivant(pvE));

Corrections — Chapitre 3
■ Correction 21 — Surcharge simple

Java choisit la version selon le type passé : int ou double.

public static void afficher(int n) {
[Link]("Entier : " + n);
}
public static void afficher(double n) {
[Link]("Décimal : " + n);
}

afficher(42);
afficher(3.14);

■ Correction 22 — Surcharge par nombre

Java distingue les 3 versions par le nombre d'arguments.

public static int additionner(int a, int b) { return a+b; }
public static int additionner(int a, int b, int c) { return a+b+c; }
public static int additionner(int a, int b, int c, int d) { return a+b+c+d;
}

[Link](additionner(3, 4));

27
 [Link](additionner(3, 4, 5));
[Link](additionner(3, 4, 5, 10));

■ Correction 23 — Attaque surchargée

La 2e version double les dégâts si critique est true.

public static int attaquer(int degats) { return degats; }
public static int attaquer(int degats, boolean critique) {
if (critique) return degats * 2;
return degats;
}

[Link](attaquer(25));
[Link](attaquer(25, true));

■ Correction 24 — Salutation surchargée

La 2e version a un paramètre supplémentaire.

public static void saluer(String nom) {
[Link]("Bonjour " + nom);
}
public static void saluer(String nom, int niveau) {
[Link]("Bonjour " + nom + " ! Niveau " + niveau);
}

saluer("Steve");
saluer("Alex", 7);

■ Correction 25 — Soin souple

[Link] retourne le plus petit des deux valeurs.

public static int soigner(int pv, int soin) {
return [Link](pv + soin, 100);
}
public static int soigner(int pv, int soin, int pvMax) {
return [Link](pv + soin, pvMax);
}

[Link](soigner(80, 30));
[Link](soigner(120, 80, 200));

28
 ■ Correction 26 — Afficher un item

Version 1 : juste le nom. Version 2 : nom + quantité.

public static void afficherItem(String nom) {
[Link](nom);
}
public static void afficherItem(String nom, int qte) {
[Link](nom + " x " + qte);
}

afficherItem("Épée légendaire");
afficherItem("Potion", 5);

■ Correction 27 — Score souple

Le cast (int) convertit le résultat décimal en entier.

public static int ajouterScore(int score, int pts) { return score + pts; }
public static int ajouterScore(int score, int pts, double mult) {
return score + (int)(pts * mult);
}

[Link](ajouterScore(1000, 100));
[Link](ajouterScore(1000, 100, 2.0));

■ Correction 28 — Message de résultat

if/else pour choisir entre deux messages.

public static String getMessage(String joueur) {
return "Partie terminée pour " + joueur;
}
public static String getMessage(String joueur, boolean victoire) {
if (victoire) return joueur + " a gagné !";
return joueur + " a perdu.";
}

■ Correction 29 — Résumé court ou long

Même nom, mais un seul paramètre vs trois paramètres.

public static void resume(int score) {
[Link]("Score : " + score);
}

29
 public static void resume(int score, int niveau, String nom) {
[Link]("=== RÉSUMÉ ===");
[Link]("Joueur : " + nom);
[Link]("Niveau : " + niveau + " | Score : " + score);
}

■ Correction 30 — Synthèse chapitre 3

Chaque version affiche progressivement plus d'informations.

public static void decrire(String nom) {
[Link]("Joueur : " + nom);
}
public static void decrire(String nom, int pv) {
[Link]("Joueur : " + nom + " | PV : " + pv);
}
public static void decrire(String nom, int pv, int att) {
[Link]("Joueur : " + nom + " | PV : " + pv + " | ATT : " +
att);
}

Corrections — Chapitre 4
■ Correction 31 — Passer un tableau

On accède aux éléments par leur indice.

public static void afficherScores(int[] scores) {
[Link]("Score 1 : " + scores[0]);
[Link]("Score 2 : " + scores[1]);
[Link]("Score 3 : " + scores[2]);
}

int[] s = {450, 820, 310};

afficherScores(s);

■ Correction 32 — Somme d'un tableau

On additionne les 5 éléments et on retourne le total.

public static int somme(int[] t) {
return t[0]+t[1]+t[2]+t[3]+t[4];
}

30
 int[] pts = {150,200,175,225,100};
[Link]("Somme : " + somme(pts));

■ Correction 33 — Maximum d'un tableau

On compare chaque élément avec la valeur max courante.

public static int maximum(int[] t) {
int max = t[0];
if (t[1] > max) max = t[1];
if (t[2] > max) max = t[2];
if (t[3] > max) max = t[3];
if (t[4] > max) max = t[4];
return max;
}

■ Correction 34 — Retourner un tableau

On crée le tableau avec les 3 paramètres et on le retourne.

public static String[] creerEquipe(String j1, String j2, String j3) {
String[] equipe = {j1, j2, j3};
return equipe;
}

String[] eq = creerEquipe("Steve", "Alex", "Notch");

[Link](eq[0] + ", " + eq[1] + ", " + eq[2]);

■ Correction 35 — Initialiser un tableau

On crée un tableau vide et on remplit chaque case.

public static int[] initTableau(int valeur) {
int[] t = new int[5];
t[0]=valeur; t[1]=valeur; t[2]=valeur;
t[3]=valeur; t[4]=valeur;
return t;
}

int[] s = initTableau(0);
[Link](s[0]+" "+s[1]+" "+s[2]+" "+s[3]+" "+s[4]);

■ Correction 36 — Moyenne d'un tableau

total / 5.0 force la division décimale.

31
 public static double moyenne(int[] t) {
double total = t[0]+t[1]+t[2]+t[3]+t[4];
return total / 5.0;
}

int[] scores = {500,820,720,630,730};

[Link]("Moyenne : " + moyenne(scores));

■ Correction 37 — Classement

On utilise le même indice pour accéder aux deux tableaux.

public static void afficherClassement(String[] noms, int[] scores) {
[Link]("1. " + noms[0] + " - " + scores[0] + " pts");
[Link]("2. " + noms[1] + " - " + scores[1] + " pts");
[Link]("3. " + noms[2] + " - " + scores[2] + " pts");
}

■ Correction 38 — Modifier un tableau

Le tableau original est modifié car il est partagé, pas copié.

public static void ajouterBonus(int[] scores, int bonus) {
scores[0]+=bonus; scores[1]+=bonus; scores[2]+=bonus;
}

int[] s = {100, 200, 300};

[Link]("Avant : "+s[0]+" "+s[1]+" "+s[2]);
ajouterBonus(s, 50);
[Link]("Après : "+s[0]+" "+s[1]+" "+s[2]);

■ Correction 39 — Copier un tableau

Un nouveau tableau est créé avec les mêmes valeurs. Modifier la copie ne change pas l'original.
public static int[] copier(int[] source) {
int[] copie = new int[3];
copie[0]=source[0]; copie[1]=source[1]; copie[2]=source[2];
return copie;
}

int[] orig = {10, 20, 30};

int[] c = copier(orig);
c[0] = 99;

32
 [Link]("Original : "+orig[0]+" "+orig[1]+" "+orig[2]);
[Link]("Copie : "+c[0]+" "+c[1]+" "+c[2]);

■ Correction 40 — Synthèse chapitre 4

On trouve l'indice du maximum, puis on retourne le nom à cet indice.

public static String trouverMeilleur(String[] noms, int[] scores) {
int maxIdx = 0;
if(scores[1]>scores[maxIdx]) maxIdx=1;
if(scores[2]>scores[maxIdx]) maxIdx=2;
if(scores[3]>scores[maxIdx]) maxIdx=3;
if(scores[4]>scores[maxIdx]) maxIdx=4;
return noms[maxIdx] + " avec " + scores[maxIdx] + " points";
}

String[] p = {"Alpha","Beta","Gamma","Delta","Epsilon"};
int[] s = {9500,8200,7800,6500,5100};
[Link]("Meilleur : " + trouverMeilleur(p, s));

Corrections — Chapitre 5
■ Correction 41 — Fiche de personnage

Chaque fonction a un rôle précis. afficherFiche appelle les autres.

public static String creerNom(String prenom, String classe) {
return prenom + " le " + classe;
}
public static int calculerPV(int niveau) { return niveau * 50; }
public static void afficherFiche(String nom, int pv) {
[Link]("=== FICHE ===");
[Link]("Nom : " + nom);
[Link]("PV : " + pv);
}

String nom = creerNom("Epicrafter", "Guerrier");

int pv = calculerPV(5);
afficherFiche(nom, pv);

■ Correction 42 — Combat complet

On simule 2 rounds en appelant les fonctions dans l'ordre.

33
 public static int calculerDegats(int att, int def) { return att-def; }
public static int appliquerDegats(int pv, int d) { return pv-d; }
public static boolean estVivant(int pv) { return pv > 0; }
public static void afficherEtat(String nom, int pv) {
[Link](nom + " PV : " + pv + " | Vivant : " + estVivant(pv)
);
}

int pvH=100; int pvE=60;

// Round 1
pvE = appliquerDegats(pvE, calculerDegats(35, 5));
pvH = appliquerDegats(pvH, calculerDegats(15, 20));
afficherEtat("Hero", pvH); afficherEtat("Goblin", pvE);

■ Correction 43 — Magasin

Chaque fonction fait une seule chose. Le main coordonne tout.

public static void afficherArticle(String nom, double prix) {
[Link](nom + " : " + prix + " or");
}
public static double calculerTotal(double p1, double p2, double p3) {
return p1 + p2 + p3;
}
public static boolean peutAcheter(double budget, double total) {
return budget >= total;
}

afficherArticle("Épée", 150.0);
double total = calculerTotal(150.0, 80.0, 25.0);
[Link]("Total : " + total);
[Link](peutAcheter(300.0, total) ? "Achat OK" : "Pas assez d'or
");

■ Correction 44 — Statistiques de scores

Chaque fonction calcule une seule statistique.

public static int somme(int[] s) { return s[0]+s[1]+s[2]+s[3]+s[4]; }
public static int maximum(int[] s) {
int m=s[0]; if(s[1]>m)m=s[1]; if(s[2]>m)m=s[2];
if(s[3]>m)m=s[3]; if(s[4]>m)m=s[4]; return m;
}

34
 public static int minimum(int[] s) {
int m=s[0]; if(s[1]<m)m=s[1]; if(s[2]<m)m=s[2];
if(s[3]<m)m=s[3]; if(s[4]<m)m=s[4]; return m;
}
public static double moyenne(int[] s) { return (double)somme(s)/[Link]; }

int[] scores = {850,1200,430,990,670};

[Link]("Total : "+somme(scores));
[Link]("Max : "+maximum(scores)+" | Min : "+minimum(scores));
[Link]("Moyenne : "+moyenne(scores));

■ Correction 45 — Rapport de mission

On combine toutes les notions : String, int, tableau, fonctions.

public static String entete(String mission, String joueur) {
return "Mission : " + mission + " | Joueur : " + joueur;
}
public static int bonusTemps(int duree) {
if (duree < 300) return 500;
return 0;
}
public static int scoreFinal(int base, int enemis, int bonus) {
return base + (enemis * 50) + bonus;
}

String[] objets = {"Clé ancienne", "Potion rare", "Carte trésor"};

String e = entete("Forêt Interdite", "Epicrafter");
int bonus = bonusTemps(245);
int score = scoreFinal(2000, 12, bonus);
[Link](e);
[Link]("Score : " + score);
[Link]("Objets : "+objets[0]+", "+objets[1]+", "+objets[2]);

35
 Félicitations !
Tu as terminé les 45 exercices sur les fonctions !

■ Les fonctions void (font une action, ne retournent rien)

■ Les fonctions avec retour (int, double, String, boolean, tableau)

■ Les paramètres et le passage par valeur

■ La surcharge (même nom, paramètres différents)

■ Passer et retourner des tableaux

■ Organiser son code en fonctions à responsabilité unique

■ Prochaine étape : les conditions (if/else) et les boucles (for/while). Bonne continuation !

Bonne continuation dans Epicrafter's Journey ! ■

36