Chapitre : Exécutez des fonctions
Introduction aux fonctions
Les fonctions sont des blocs de code conçus pour exécuter des traitements spécifiques. Elles
permettent de réutiliser le code, de simplifier la maintenance et de structurer les programmes
de manière logique.
Une fonction est définie par deux parties principales :
1. La signature (ou prototype) : décrit la fonction, ses paramètres et son type de retour.
2. L’implémentation : contient les instructions exécutées lorsque la fonction est appelée.
Structure d’une fonction en Java
Chaque fonction en Java suit un modèle composé de cinq éléments :
1. Visibilité : définit quelles parties du programme peuvent utiliser la fonction.
o Exemple : public, private, etc.
2. Caractéristique : modifie le comportement de la fonction.
o Exemple : static pour simplifier l'accès sans créer d'objet.
3. Type retour : indique si la fonction retourne une valeur et de quel type (ex. : int,
String, void).
4. Nom : doit être clair et explicite. On utilise généralement la notation camelCase.
5. Paramètres : variables que la fonction reçoit en entrée pour effectuer son traitement.
Exemple concret : main
public static void main(String[] args)
• Visibilité : public (accessible partout).
• Caractéristique : static (appelable sans créer d'instance de classe).
• Type retour : void (ne retourne aucune valeur).
• Nom : main.
• Paramètres : String[] args (tableau contenant les arguments passés au programme).
Appel d’une fonction
Une fonction est appelée à l’aide de la syntaxe suivante :
[Nom de classe].[Nom de la méthode](arguments);
Exemple : si une méthode affiche est définie dans la classe Main, l’appel se fait ainsi :
Main.affiche();
Pratique : Écrire des fonctions en Java
1. Écrire une fonction simple
Une fonction sans paramètres et sans retour :
Code :
public static void affiche() {
System.out.println("Une fonction en Java a été exécutée");
}
Explications :
• public static : rend la fonction accessible partout et simple à appeler.
• void : aucun retour attendu.
• affiche : nom clair indiquant son rôle.
Pour appeler cette fonction dans main :
public static void main(String[] args) {
affiche();
}
Résultat dans la console :
Une fonction en Java a été exécutée
2. Ajouter des paramètres
Une fonction qui reçoit un paramètre et l’utilise :
Code :
public static void affiche(String texte) {
System.out.println(texte);
}
Appel :
public static void main(String[] args) {
affiche("Bienvenue dans Java !");
}
Résultat dans la console :
Bienvenue dans Java !
3. Fonction avec plusieurs paramètres et retour
Une fonction effectuant un calcul et retournant le résultat :
Code :
public static int addition(final int entier1, final int entier2) {
return entier1 + entier2;
}
Appel :
public static void main(String[] args) {
int resultat = addition(5, 10);
System.out.println("Le résultat est : " + resultat);
}
Résultat dans la console :
Le résultat est : 15
4. Fonctions récursives
Les fonctions récursives s'appellent elles-mêmes pour simplifier des traitements répétitifs.
Elles nécessitent un critère d'arrêt pour éviter une boucle infinie.
Exemple : fonction de décompte
Code :
public static void decompte(final int valeur) {
if (valeur >= 0) {
System.out.println(valeur);
decompte(valeur - 1); // Appel récursif
}
}
Appel :
public static void main(String[] args) {
decompte(5);
}
Résultat dans la console :
5
4
3
2
1
0
5. Exercices pratiques
Consigne : Créer une fonction nommée affichage qui :
1. Prend un paramètre de type String.
2. Concatène ce paramètre avec le mot "Bonjour ".
3. Affiche le résultat.
Appeler cette fonction dans main avec "Marty" comme argument.
Solution :
public static void affichage(String texte) {
System.out.println("Bonjour " + texte);
}
public static void main(String[] args) {
affichage("Marty");
}
Résultat dans la console :
Bonjour Marty
Points-clés à retenir
• Une fonction simplifie et organise le code en permettant la réutilisation.
• Les fonctions peuvent recevoir des paramètres, retourner des résultats ou ne rien
retourner (void).
• Les fonctions récursives sont utiles, mais elles nécessitent un critère d’arrêt.
• Bien nommer les fonctions est une bonne pratique pour rendre le code lisible
