BeginnerJavaTous les articles

Les bases du Java – Les méthodes et le scope (5/5)

Salut c’est Sébastien, on se retrouve aujourd’hui pour une nouvelle vidéo sur le Java. On va parler des méthodes comme je vous l’avais promis au début de notre formation sur le Java, donc c’est parti !

Alors une méthode (ou fonction) ça va nous servir à quoi ? Ça va nous servir à rejouer plusieurs lignes de code qu’on va placer à l’intérieur de cette méthode et à chaque fois quand on rappellera cette méthode par son nom ça va jouer les lignes de code qui se trouve à l’intérieur.

Créer une méthode

Alors comment créer une méthode ?  On va d’abord dans un premier temps créer une méthode qui affiche simplement quelque chose à l’écran pour voir un petit peu comment ça fonctionne. On va voir des choses un petit peu plus compliqué juste après.

Pour créer une méthode, on va utiliser la syntaxe suivante :

public void printHello()
{
    // Corps de la méthode
    System.out.println("Hello");
}
  • « public » fait référence à la programmation orientée objet, on en reparlera dans une prochaine vidéo
  • « void » signifie que la méthode ne retourne rien
  • « printHello » est le nom de la méthode
  • « () » les parenthèses vont servir à mettre des paramètres à la fonction par la suite. Pour le moment on en a pas besoin donc on les laisse vide
  • « {} » le corps de la méthode va se trouver entre les deux accolades

Si par exemple on souhaite appeler cette méthode pour exécuter le code qui se trouve à l’intérieur, c’est très simple. Vous savez que le code qui s’exécute se situe dans la méthode « main« , donc on va appeler la méthode « printHello » dans le « main« .

Cependant, la méthode « main » étant une méthode « static » il faut que l’on rajoute dans notre méthode le mot-clé « static » sinon on aura une erreur lors de l’appel à cette méthode. Une méthode « static » peut uniquement appeler une autre méthode « static ». En Android, on n’aura plus besoin d’utiliser ce mot clé car les méthodes ne sont pas « static ».

Ce qui nous donne le code suivant :

public static void main(String[] args) {
// TODO Auto-generated method stub

printHello();

}

public static void printHello()
{
	System.out.println("Hello");
}

Et à l’exécution on a bien le « Hello » qui s’affiche.

L’avantage d’une méthode c’est que si je l’appelle 2 fois, le code va s’exécuter 2 fois et on aura pas à réécrire tout le corps de la méthode 2 fois.

public static void main(String[] args) {
// TODO Auto-generated method stub

printHello();
printHello();

}

 

Les paramètres d’une méthode

Ce qui serait intéressant ça serait de faire dépendre cette méthode en fonction de la valeur d’un argument. Si par exemple on souhaite écrire « Hello » suivi du prénom d’une personne, on va pour cela rajouter un argument à notre méthode de type « String » pour pouvoir écrire une chaîne de caractère et le nom de la variable on va l’appeler « prénom ».

Pour afficher « Hello » suivi du prénom, il faut concaténer notre chaîne de caractère « Hello » à notre variable « prénom », de cette manière :

public static void printHello(String prenom)
{
	System.out.println("Hello " + prenom);
}

 

Après avoir modifié notre méthode qui prends maintenant un paramètre, on voit bien qu’une erreur est apparue dans le « main », là où notre méthode est appelée.

 

En effet, la méthode « printHello »  requiert un paramètre « prénom » donc il faut que l’on donne ce paramètre quand on appelle la méthode. On va donc passer des chaînes de caractères en paramètre de nos deux méthodes appelées.

public static void main(String[] args) {
// TODO Auto-generated method stub

printHello("Sébastien");
printHello("Diane");

}

public static void printHello(String prenom)
{
	System.out.println("Hello " + prenom);
}

 

Si on exécute on a bien le « Hello Sébastien » et le « Hello Diane » qui s’affiche. On a donc fait dépendre notre méthode d’un paramètre et on peut l’appeler avec des paramètres différents qui feront changer son comportement.

Exemple avec une deuxième méthode

Cette méthode va nous permettre de multiplier deux nombres entier. Elle va s’appeler « mult » et prendre en paramètre deux nombres entier a et b.

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

}

Dans notre fonction main, pour appeler notre méthode on va créer deux entiers x et y qui seront les passés en paramètres. Nous souhaitons multiplier 3 par 5. Nous avons donc le code suivant :

public static void main(String[] args) {
// TODO Auto-generated method stub

    int x = 3;
    int y = 5;
    mult(x, y);

}

Aparté : comportement des variables passées en paramètre d’une fonction

Avant d’implémenter la méthode « mult » je voudrais vous faire part d’un point important. En réalité, dès qu’on passe un paramètre dans une méthode en Java, ce paramètre est copié.

Donc s’il est modifié à l’intérieur de cette méthode, il n’est pas modifié à l’extérieur de cette méthode.

Par exemple, ici « x » vaut 3 et « y » vaut « 5. Si dans notre méthode « mult » on ajoute 3 à notre paramètre « a », alors logiquement « a » va valoir 6. Si on affiche notre variable « a » et notre variable « x », on voit bien que ces deux variables n’ont pas la même valeur.

public static void main(String[] args) {
// TODO Auto-generated method stub
   
    int x = 3;
    int y = 5;
    mult(x, y);
		
    System.out.println("x : " + x);
}
	
public static int mult(int a, int b)
{
    a += 3;
    System.out.println("x : " + x);
}

En effet, on constate que « a » vaut 6 car on a ajouté 3 à notre variable « a ». Mais comme on l’a spécifié, « a » est une COPIE de « x » donc « a » vaut 3 mais si on modifie « a » alors « x » ne sera pas modifié. Vous comprenez bien que c’est pour cela que « x » vaut toujours 3 et que « a » vaut 6.

Corps de la méthode « mult »

Créons un entier « res » qui va être le résultat de notre multiplication et qui va valoir « a*b ». Pour récupérer ce résultat dans la fonction main, il faut que notre méthode retourne ce résultat.

« void » signifiait que la méthode ne retournais rien donc maintenant on va renvoyer un entier. Pour renvoyer quelque chose d’une méthode il faut utiliser le mot-clé « return » suivi du nom de la variable à retourner.

Nous avons donc ainsi le code final suivant :

public static void main(String[] args) {
// TODO Auto-generated method stub
   
    int x = 3;
    int y = 5;
    int res = mult(x, y);
		
    System.out.println("res = " + res);
}
	
public static int mult(int a, int b)
{
    int res = a * b;
    return res;
}

Notre résultat vaut bien 15.

Donc là on a vu des types simples, on a vu comment passer une « String » en paramètre, des « int » et comment retourner des variables.

Sachez que vous pouvez passer en paramètre les types que vous voulez et retourner le type que vous voulez. Libre à vous de l’adapter au contexte dans lequel vous êtes.

Le scope d’une variable

Qu’est-ce-que le scope d’une variable ?  C’est l’endroit où une variable est disponible dans le code. Donc quand vous créez une variable, par exemple notre variable « x », où est-ce qu’elle est disponible dans le code ? C’est ce qu’on appelle le scope et on va voir çà tout de suite !

En fait une variable est disponible uniquement à l’endroit où vous la créez. Par exemple notre variable « x » que l’on a créé dans le « main » n’est pas disponible dans la méthode « mult ». Si par exemple on essaie de faire « x++ » dans « mult », il ne va pas le vouloir parce qu’il ne connaît pas « x ». En effet « x » a été créé à l’intérieur d’une autre méthode, « main ».

Notre variable « x » est disponible jusqu’à la fin de la méthode « main » et après la variable est détruite.

public static void main(String[] args) {
// TODO Auto-generated method stub
   
    int x = 3;
    int y = 5;
    int res = mult(x, y);
		
    System.out.println("res = " + res);
    // x est disponible jusqu'ici
}

C’est donc également le cas de « y » dans « main » et de « res » dans « mult ».

Le cas d’une condition

Si par exemple on crée une condition en « if ». Si à l’intérieur de ce « if » on crée une variable « v » alors celle-ci sera disponible QUE dans le « if ». Si on sort du « if » la variable n’est plus disponible.

Pareil si on ajoute un « else » avec une variable « v2 », celle-ci ne sera disponible QUE dans le « else ».

if (x < 5)
{
    int v = 2;
}
else
{
    int v2 = 5;
}

Pour résumé :

  • Quand on crée une variable dans une méthode, cette variable est disponible QUE dans cette méthode.
  • Quand on crée une variable dans une condition, cette variable est disponible QUE dans cette condition.

Une variable n’est disponible que là ou elle est créée.

Rendre une variable disponible dans toute la classe

En revanche, si on crée une variable tout en haut de la classe « Main », à l’extérieur des méthodes mais à l’intérieur de la classe, par conséquent cette variable sera utilisable dans TOUTES les méthodes de la classe.

public class Main {

	static int v3;
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		v3++; // v3 est disponible

		}
	}

	public static void printHello(String prenom)
	{
		// v3 est disponible
	}
	
	public static int mult(int a, int b)
	{
		// v3 est disponible
	}

// v3 est disponible
}

 

Conclusion

Aujourd’hui j’ai pris quelques raccourcis pour vous expliquer comment fonctionnent les attributs et les méthodes d’une classe. Je rentrerai dans les détails quand je parlerai de la programmation orientée objet en Java.

C’est tout pour aujourd’hui, dans la prochaine vidéo on va rentrer enfin dans le vif du sujet. J’espère que vous êtes content, on va parler de la programmation Android. On va mixer le XML et le Java donc tout ce qu’on a appris jusqu’à maintenant ensemble.

On rentrera dans les détails un petit peu plus du Java dans d’autres vidéos, là je vous ai vraiment appris la base de la base pour que vous puissiez vous amuser en Android ! Car vous êtes sur cette chaîne pour ça principalement 😉 donc je vous dis à la prochaine, salut tout le monde !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *