(Java) Sous-routines : procédures et fonctions - 1

L'utilisation de sous-programmes vous permet d'éviter la duplication de code, au cas où vous auriez besoin d'écrire le même code à différents endroits du programme. 
Les bibliothèques importées dans le programme (par exemple, la bibliothèque mathématique Math) sont constituées de sous-programmes qui ont déjà été compilés par quelqu'un. Les programmeurs n'ont pas besoin de réfléchir aux algorithmes qu'ils implémentent, mais simplement de les appliquer, en pensant uniquement à ce qu'ils font exactement. C'est un gain de temps considérable. Il n'est pas nécessaire d'écrire un algorithme qui a déjà été écrit par quelqu'un d'autre.

Chaque routine ne doit effectuer qu'une seule tâche,  soit simplement calculer quelque chose, soit générer des données, soit faire autre chose. 

Il existe deux types de sous-programmes : les procédures et les fonctions

Les sous-procédures effectuent certaines actions, par exemple, affichent le résultat à l'écran sous une certaine forme (un exemple simple, l'opérateur println()  est une sous-procédure standard qui imprime des informations sur le écran)

Les sous-routines de fonctions retournent un résultat (nombre, chaîne de caractères, etc.) que nous pouvons utiliser dans le programme principal.

Essayons d'écrire une procédure simple :
Supposons que nous ayons besoin d'afficher la chaîne "Erreur" à l'écran chaque fois qu'une erreur peut se produire dans le code en raison de la faute de l'utilisateur (par exemple, lorsqu'il saisit des données incorrectes)
Cela peut être fait en écrivant l'opérateur System.out.println("Erreur"); Et maintenant, imaginez qu'une telle ligne doive être insérée à de nombreux endroits dans le programme. Bien sûr, vous pouvez simplement l'écrire partout. Mais cette solution a deux inconvénients.
1) cette chaîne sera stockée en mémoire plusieurs fois
2) si nous voulons changer la sortie en cas d'erreur, nous devrons changer cette ligne tout au long du programme, ce qui est plutôt gênant

Dans de tels cas, des procédures sont nécessaires.
Un programme avec une procédure pourrait ressembler à ceci : ... static void printError() // description de la procédure { System.out.println("Erreur"); // corps de la procédure - commandes que la procédure exécutera } public static void main(String[] args) { ... printError() // lance la procédure d'exécution. Nous spécifions simplement le nom de la procédure que nous voulons exécuter. ... impressionErreur() ... } La procédure commence par le mot void. Il y a des crochets vides après le nom de la procédure.
Toutes les instructions exécutées dans une procédure sont mises en retrait. 

Les procédures sont écrites avant la fonction principale main()

Pour exécuter une procédure, dans le programme principal, vous devez l'appeler par son nom et n'oubliez pas d'écrire des parenthèses !
Vous pouvez appeler une procédure dans un programme autant de fois que vous le souhaitez.

Imaginons maintenant que nous ayons besoin d'afficher différents messages en réponse à l'erreur d'un utilisateur, selon le type d'erreur qu'il a commise.
Dans ce cas, vous pouvez écrire votre propre procédure pour chaque erreur :   vide statique printErrorZero() { System.out.println("Erreur. Division par zéro!"); } statique vide printErrorInput() { System.out.println("Erreur dans l'entrée!"); } Et s'il y a beaucoup plus d'erreurs possibles ? Cette solution ne nous conviendra pas !
Nous devons apprendre à contrôler la procédure en lui indiquant quel message d'erreur afficher.
Pour cela, nous avons besoin de paramètres que nous écrirons entre parenthèses après le nom de la procédure static void printError(String s) { System.out.println(s); } Dans cette procédure, s est un paramètre - une variable spéciale qui vous permet de contrôler la procédure.

Le paramètre est une variable qui détermine le fonctionnement de la sous-routine. Les noms des paramètres sont répertoriés séparés par des virgules dans l'en-tête du sous-programme. Le type de paramètre est écrit avant le paramètre.

Maintenant, lors de l'appel de la procédure, vous devez indiquer entre parenthèses la valeur réelle qui sera affectée au paramètre (variable s) à l'intérieur de notre procédure printError("Erreur ! Division par zéro !"); Cette valeur s'appelle un argument.

L'argument est la valeur du paramètre qui est transmise à la sous-routine lorsqu'elle est appelée.

Un argument peut être non seulement une valeur constante, mais également une variable ou une expression arithmétique.

Il est souvent nécessaire d'utiliser des variables supplémentaires qui ne seront utilisées que dans le sous-programme. Ces variables sont appelées locales (ou locales) et ne peuvent être manipulées qu'au sein de la sous-routine dans laquelle elles sont créées.
 
Le programme principal en Java est également un sous-programme, donc toutes les variables déclarées dans main() sont des variables locales 
Les autres sous-programmes ne "savent" rien des variables locales des autres sous-programmes.

Ainsi, il est possible de limiter la portée (portée) d'une variable uniquement au sous-programme où elle est vraiment nécessaire. En programmation, cette technique est appelée encapsulation  - empêcher une variable d'être modifiée de l'extérieur.

S'il est nécessaire de déclarer une variable qui serait visible n'importe où dans le programme (dans n'importe quel sous-programme), alors ces variables sont déclarées en dehors de tous les sous-programmes (voir le programme 3 du tableau ci-dessous)
Ces variables sont appelées globales.

En Java, au démarrage du programme, toutes les variables globales sont automatiquement mises à zéro (les variables booléennes deviennent fausses)


Analysez trois programmes : s'affiche à l'écran

test de vide statique() {   int je = 5 ; System.out.println(i); }

test de vide statique() {   int je = 5 ;   System.out.println(i); } public static void main(String[] args) { { int je = 7 ;   System.out.println(i);   test(); }

classe publique principale { int je ; test de vide statique() {   je = 2 ; } public static void main(String[] args) { { test(); System.out.println(i); }

1) Dans ce programme, la variable i est locale. Une variable locale est déclarée dans une sous-routine	2) Ici, même s'il y a une variable i dans le programme principal (avec la valeur 7), une nouvelle variable locale i avec la valeur 5 sera créée.  Lorsque vous exécutez ce programme, l'écran affichera la valeur 75	3) Ce programme a une variable globale i. Sa valeur peut être changée à l'intérieur d'un sous-programme, et à l'intérieur du programme principal La procédure fonctionnera avec la variable globale i et lui attribuera une nouvelle valeur égale à 2. La valeur 2