Méthodes en Java avec exemples
À l'aide d'exemples, nous allons découvrir les méthodes Java, les définir et les utiliser dans les programmes Java de cet article. Une méthode est un morceau de code qui accomplit un objectif spécifique. Généralement, une méthode est un ensemble d'énoncés ou d'énoncés organisés ensemble pour effectuer une tâche ou une action particulière. C'est une technique pour rendre le code plus réutilisable. Nous créons une méthode une fois, puis l'utilisons à plusieurs reprises.
Nous n'avons pas à écrire du code encore et encore. Il permet également une modification et une lisibilité faciles du code en ajoutant ou en supprimant simplement des morceaux de code. Ce n'est que lorsque nous appelons ou invoquons la méthode qu'elle est exécutée. La méthode main() est la méthode la plus importante en Java.
Supposons que vous ayez besoin de créer un programme pour dessiner un cercle et le colorier. Pour surmonter cette difficulté, vous pouvez concevoir deux approches :
- une méthode pour dessiner un cercle
- une méthode pour colorier le cercle
Des valeurs ou des arguments peuvent être insérés à l'intérieur des méthodes, et ils ne seront exécutés que lorsque la méthode sera appelée. Les fonctions sont un autre nom pour eux. Voici les utilisations les plus courantes des méthodes en Java :
- Il permet la réutilisation du code (définir une fois et utiliser plusieurs fois)
- Un programme étendu peut être décomposé en parties de code plus petites.
- Cela améliore la lisibilité du code.
Méthodes en Java
En décomposant un problème complexe en petits morceaux, vous pouvez créer un programme plus facile à comprendre et à réutiliser. Il existe deux sortes de méthodes en Java :statiques et dynamiques.
Méthodes définies par l'utilisateur : Nous pouvons développer notre méthode en fonction de nos besoins.
Méthodes de bibliothèque standard : Ce sont les méthodes intégrées de Java qui peuvent être utilisées.
Déclaration de la méthode
Les propriétés de la méthode telles que la visibilité, le type de retour, le nom et les paramètres sont toutes indiquées dans la déclaration de la méthode. Comme le montre le diagramme suivant, il se compose de six composants appelés en-têtes de méthode.
(Access Specifier) (Return Type) (Method Name) (Parameter List) --> Method Header
{
// Method Body
}
Par exemple :
public int sumValues(int x, int y){
// method body
} Où sumValues(int x, int y) est la signature de la méthode
Signature de méthode : Une signature de méthode est une chaîne qui identifie une méthode. Il est inclus dans la déclaration de méthode. Il contient le nom de la méthode ainsi qu'une liste de paramètres.
Spécificateur d'accès : Le spécificateur d'accès de la méthode, également appelé modificateur, détermine le type d'accès de la méthode. Il spécifie la visibilité de la méthode. Il existe quatre types différents de spécificateurs d'accès en Java :
- Public : Lorsque nous utilisons le spécificateur public dans notre application, toutes les classes peuvent accéder à la méthode.
- Privé : La méthode n'est accessible que dans les classes déclarées lors de l'utilisation d'un spécificateur d'accès privé.
- Protégé : La méthode est accessible dans le même package ou dans les sous-classes d'un package différent lors de l'utilisation du spécificateur d'accès protégé.
- Par défaut : Lorsqu'aucun spécificateur d'accès n'est spécifié dans la déclaration de méthode, Java utilise le spécificateur d'accès par défaut. Il ne peut être vu qu'à partir du même package.
Type de retour : Le type de retour d'une méthode est le type de données qu'elle retourne. Par exemple, il peut s'agir d'un type de données primitif, d'un objet, d'une collection ou d'un évitement. Le mot-clé void est utilisé lorsqu'une méthode ne renvoie rien.
Nom de la méthode : Le nom d'une méthode est défini par son nom de méthode, qui est un nom unique.
Il doit être adapté à la fonctionnalité de la méthode. Si nous créons une méthode pour soustraire deux nombres, le nom de la méthode doit être subtraction(). Le nom d'une méthode est utilisé pour l'appeler.
Liste des paramètres : La liste de paramètres est une collection de paramètres séparés par une virgule et entourés de parenthèses. Il spécifie le type de données ainsi que le nom de la variable. Laissez la parenthèse vide si la méthode n'a pas de paramètres.
Corps de la méthode : La déclaration de méthode inclut une section appelée le corps de la méthode. Il contient toutes les actions qui doivent être effectuées. De plus, il est protégé par une paire d'accolades.
Choix d'un nom de méthode
Lorsque vous nommez une méthode, gardez à l'esprit qu'elle doit être un verbe et commencer par une lettre minuscule. S'il y a plus de deux mots dans le nom de la méthode, le premier doit être un verbe, suivi d'un adjectif ou d'un nom. À l'exception du premier mot, la première lettre de chaque mot du nom de la méthode multi-mots doit être en majuscule. Considérez le scénario suivant :
- sum(), area() sont deux méthodes à mot unique
- areaOfCircle(), stringComparision() sont deux méthodes multi-mots
Il est également concevable qu'une méthode porte le même nom qu'une autre méthode de la même classe; c'est ce qu'on appelle la surcharge de méthode.
Méthodes définies par l'utilisateur
Commençons par examiner les méthodes définies par l'utilisateur. Pour déclarer une méthode, utilisez la syntaxe suivante :
returnType methodName() {
// method body
}
Par exemple,
int sumValues() {
// code
} La méthode ci-dessus est nommée sumValues(), dont le type de retour est un int. La syntaxe pour déclarer une méthode est la suivante. La syntaxe complète pour déclarer une méthode, en revanche, est
modifier static returnType nameOfMethod (parameter1, parameter2, ...) {
// method body
} Ici,
modificateur - Il spécifie les types d'accès de la méthode, tels que public, privé, etc. Visitez le spécificateur d'accès Java pour plus d'informations.
statique -Il est accessible sans créer d'objets si nous utilisons le mot clé statique.
La méthode sqrt() de la classe Math standard, par exemple, est statique. Par conséquent, nous pouvons appeler Math.sqrt() sans d'abord établir une instance de classe Math. Les valeurs paramètre1/paramètre2 sont fournies à une méthode. Une méthode peut prendre n'importe quel nombre d'arguments.
Appel de méthode en Java
Nous avons déclaré une méthode appelée sumValues() dans l'exemple précédent. Pour utiliser la méthode, nous devons d'abord l'appeler. La méthode sumValues() peut être appelée de la manière suivante.
// calls the method
sumValues();
Example: Using Methods in Java
class Codeunderscored {
// create a method
public int sumValues(int num_1, int num_2) {
int sumVal = num_1 + num_2;
// return the results
return sumVal;
}
public static void main(String[] args) {
int num1 = 67;
int num2 = 33;
// create an object of Codeunderscored
Codeunderscored code = new Codeunderscored();
// calling method
int resultVal = code.sumValues (num1, num2);
System.out.println("The resultant sum value is: " + resultVal);
}
} Nous avons défini une méthode appelée sumValues() dans l'exemple précédent. Les paramètres num_1 et num_2 sont utilisés dans la méthode. Prenez note de la ligne,
int resultVal = code.sumValues (num1, num2);
La procédure a été invoquée en donnant deux arguments, num_1 et num_2. Nous avons placé la valeur dans la variable de résultat car la méthode renvoie une valeur. Il convient de noter que la méthode n'est pas statique. Par conséquent, nous utilisons l'objet de la classe pour invoquer la méthode.
Le mot clé void
Nous pouvons utiliser le mot-clé void pour créer des méthodes qui ne renvoient pas de valeur. Dans l'exemple suivant, nous allons examiner une méthode void appelée demoVoid. C'est une méthode vide, ce qui signifie qu'elle ne renvoie rien. Une instruction doit être utilisée pour appeler une méthode void, telle que demoVoid(98);. Comme illustré dans l'exemple suivant, il s'agit d'une instruction Java qui se termine par un point-virgule.
public class Codeunderscored {
public static void main(String[] args) {
demoVoid(98);
}
public static void demoVoid(double points) {
if (points >= 100) {
System.out.println("Grade:A");
}else if (points >= 80) {
System.out.println("Grade:B");
}else {
System.out.println("Grade:C");
}
}
} Utilisation de valeurs pour transmettre des paramètres
Les arguments doivent être passés lors du travail sur la procédure d'appel. Ceux-ci doivent être répertoriés dans la spécification de la méthode dans le même ordre que leurs paramètres correspondants. Généralement, les paramètres peuvent être donnés de deux manières :une valeur ou une référence.
Appeler une méthode avec un paramètre s'appelle passer des paramètres par valeur. La valeur de l'argument est fournie au paramètre de cette manière. Le programme ci-dessous montre comment passer un paramètre par valeur. Même après avoir utilisé la procédure, les valeurs des arguments restent inchangées.
public class Codeunderscored {
public static void main(String[] args) {
int x = 20;
int y = 62;
System.out.println("Items initial order, x = " + x + " and y = " + y);
// Invoking the swap method
swapValues(x, y);
System.out.println("\n**Order if items, before and after swapping values **:");
System.out.println("Items after swapping, x = " + x + " and y is " + y);
}
public static void swapValues(int a, int b) {
System.out.println("Items prior to swapping(Inside), x = " + x + " y = " + y);
// Swap n1 with n2
int temp = x;
x = y;
y = temp;
System.out.println("Items post swapping(Inside), x = " + x + " y = " + y);
}
} Surcharge de méthodes
La surcharge de méthode se produit lorsqu'une classe contient deux ou plusieurs méthodes portant le même nom mais des paramètres distincts. Ce n'est pas la même chose que de passer outre. Lorsqu'une méthode est surchargée, elle a le même nom, type, nombre de paramètres, etc.
Prenons l'exemple de la recherche des plus petits nombres entiers. Disons que nous recherchons le plus petit nombre de types doubles. Ensuite, pour construire deux méthodes ou plus avec le même nom mais des paramètres différents, la notion de surcharge sera introduite.
L'exemple suivant clarifie la situation :
public class Codeunderscored {
public static void main(String[] args) {
int x = 23;
int y = 38;
double numOne = 17.3;
double numTwo = 29.4;
int resultOne = smallestValue(x, y);
// invoking function name with different parameters
double resultTwo = smallestValue(numOne, numTwo);
System.out.println("The Minimum number is: = " + resultOne);
System.out.println("The Minimum number is: = " + resultTwo);
}
// for integer
public static int smallestValue(int numOne, int numTwo) {
int smallestVal;
if ( numOne > numTwo)
smallestVal = numTwo;
else
smallestVal = numOne;
return smallestVal;
}
// for double
public static double smallestValue(double numOne, double numTwo) {
double smallestVal;
if ( numOne > numTwo)
smallestVal = numTwo;
else
smallestVal = numOne;
return smallestVal;
}
}
Les méthodes de surcharge améliorent la lisibilité d'un programme. Deux méthodes portant le même nom mais des paramètres différents sont présentées ici. Le résultat est le plus petit nombre parmi les types entier et double.
Utiliser des arguments sur la ligne de commande
Lorsque vous exécutez un programme, vous souhaiterez peut-être lui fournir des informations. Elle est effectuée en appelant main() avec des arguments de ligne de commande.
Lorsqu'un programme est exécuté, un argument de ligne de commande est une information qui apparaît après le nom du programme sur la ligne de commande. Il est simple de récupérer des paramètres de ligne de commande à partir d'un programme Java. Ils sont enregistrés dans le tableau String fourni à main() sous forme de chaînes. Le programme suivant affiche tous les arguments de ligne de commande qu'il est appelé.
public class Codeunderscored {
public static void main(String args[]) {
for(int i = 0; i<args.length; i++) {
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
"Ce" mot-clé
Un mot-clé Java est utilisé pour référencer l'objet de la classe actuelle dans une méthode d'instance ou un constructeur. Vous pouvez l'utiliser pour faire référence à des membres de classe tels que des constructeurs, des variables et des méthodes. Il convient de noter que le mot-clé this n'est utilisé que dans les méthodes d'instance et les constructeurs.
En général, le terme auquel il se réfère :
- Dans un constructeur ou une méthode, distinguez les variables d'instance des variables locales si leurs noms sont identiques.
class Employee {
int age;
Employee(int age) {
this.age = age;
}
} - Dans une classe, appelez une sorte de constructeur (constructeur paramétré ou constructeur par défaut) à partir d'une autre. C'est ce qu'on appelle l'invocation explicite du constructeur.
class Employee {
int age
Employee() {
this(20);
}
Employee(int age) {
this.age = age;
}
} Ce mot clé est utilisé pour accéder aux membres de la classe dans l'exemple suivant. Copiez et collez le programme ci-dessous dans un fichier appelé thisKeyword.java.
public class Codeunderscored {
// Instance variable num
int num = 10;
Codeunderscored() {
System.out.println("This is a program that uses the keyword this as an example. ");
}
Codeunderscored(int num) {
// Using the default constructor as a starting point
this();
// num is assigned to the instance variable num by assigning the local variable num to the instance variable num.
this.num = num;
}
public void greet() {
System.out.println("Hello and welcome to Codeunderscored.com. ");
}
public void print() {
// declaration of the num Local variable
int num = 20;
// The local variable is printed.
System.out.println("num is the value of a local variable. : "+num);
// The instance variable is printed.
System.out.println("num is the value of the instance variable. : "+this.num);
// Invoking a class's greet method
this.greet();
}
public static void main(String[] args) {
// Creating an instance of the class
Codeunderscored code = new Codeunderscored();
// The print technique is used to print a document.
code.print();
// Through a parameterized constructor, a new value is passed to the num variable.
Codeunderscored codeU = new Codeunderscored(30);
// Using the print technique once more
codeU.print();
}
} Arguments avec variables (var-args)
Vous pouvez donner un nombre variable de paramètres du même type à une méthode dans JDK 1.5. Le paramètre de la méthode est déclaré comme suit :
typeName... parameterName
Vous spécifiez le type suivi de points de suspension dans la définition de la méthode (…). Dans une méthode, un seul paramètre de longueur variable peut être fourni, et ce doit être le dernier paramètre. Tous les paramètres réguliers doivent le précéder.
public class VarargsCode {
public static void main(String args[]) {
// Calling of a method with variable args
showMax(54, 23, 23, 22, 76.5);
showMax(new double[]{21, 22, 23});
}
public static void showMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
} Type de retour d'une méthode Java
L'appel de fonction peut ou non obtenir une valeur d'une méthode Java. L'instruction return est utilisée pour renvoyer n'importe quelle valeur. Par exemple,
int sumValues() {
...
return sumVal;
} La variable sumVal est retournée dans ce cas. Étant donné que le type de retour de la fonction est int, le type de la variable sumVal doit être int. Sinon, une erreur sera générée.
// Example : Return Type of a Method
class Codeunderscored {
// creation of a static method
public static int squareValues(int numVal) {
// return statement
return numVal * numVal;
}
public static void main(String[] args) {
int result;
// call the method
// store returned value to result
resultVal = squareValues(13);
System.out.println("The Squared value of 13 is: " + resultVal);
}
}
Dans le programme précédent, nous avons construit une méthode squareValues(). La méthode accepte un entier comme entrée et renvoie le carré du nombre. Le type de retour de la méthode a été spécifié comme int ici.
Par conséquent, la méthode doit toujours renvoyer un nombre positif. Notez que nous utilisons le mot-clé void comme type de retour de la méthode si la méthode ne renvoie aucune valeur.
Par exemple,
public void squareValues(int i) {
int resultVal = i * i;
System.out.println("The Square of the given number is: " + resultVal);
} Paramètres de la méthode Java
Un paramètre de méthode est une valeur que la méthode accepte. Une méthode, comme indiqué précédemment, peut avoir n'importe quel nombre de paramètres. Par exemple,
// method with two parameters
int sumValues(int x, int y) {
// code
}
// method with no parameter
int sumValues(){
// code
}
Lors de l'appel d'une méthode de paramètre, nous devons fournir les valeurs de ces paramètres. Par exemple,
// call to a method with two parameters sumValues(29, 21); // call to a method with no parameters sumValues()
Exemple :Paramètres de méthode
class Codeunderscored {
// method with no parameter
public void methodWithNoParameters() {
System.out.println("Method without parameter");
}
// method with single parameter
public void methodWithParameters(int a) {
System.out.println("Method with a single parameter: " + a);
}
public static void main(String[] args) {
// create an object of Codeunderscored
Codeunderscored code = new Codeunderscored();
// call to a method with no parameter
code.methodWithNoParameters ();
// call to a method with the single parameter
code.methodWithParameters (21);
}
} Le paramètre de la méthode est int dans ce cas. En conséquence, le compilateur lancera une erreur si nous passons un autre type de données que int. Parce que Java est un langage étroitement typé, c'est le cas. Le paramètre réel est le 32ème argument fourni à la méthode methodWithParameters() lors de l'appel de la méthode.
Un argument formel est le paramètre num accepté par la spécification de la méthode. Le type d'arguments formels doit être spécifié. De plus, les types d'arguments réels et formels doivent toujours être les mêmes.
Méthode statique
Une méthode statique a le mot-clé static. En d'autres termes, une méthode statique est une méthode qui appartient à une classe plutôt qu'une instance de cette classe. Nous pouvons également construire une méthode statique en préfixant le nom de la méthode avec le terme static.
L'avantage fondamental d'une méthode statique est qu'elle peut être appelée sans nécessiter la création d'un objet. Il peut modifier la valeur des membres de données statiques et y accéder. Il est employé dans la création d'une méthode d'instance. Le nom de la classe est utilisé pour l'appeler. La fonction main() est le meilleur exemple de méthode statique.
public class Codeunderscored
{
public static void main(String[] args)
{
displayStatically();
}
static void displayStatically()
{
System.out.println("Codeunderscored example of static method.");
}
} Méthode d'instance en Java
Une méthode de classe est appelée méthode d'instance. C'est une méthode non statique définie par la classe. Il est indispensable de construire un objet de la classe avant d'appeler ou d'invoquer la méthode d'instance. Regardons une méthode d'instance en action.
public class CodeunderscoredInstanceMethod
{
public static void main(String [] args)
{
//Creating an object of the class
CodeunderscoredInstanceMethod code = new CodeunderscoredInstanceMethod();
//invoking instance method
System.out.println("The numbers' sum is: "+code .sumValues(39, 51));
}
int s;
//user-defined method because we have not used static keyword
public int sumValues(int x, int y)
{
resultVal = x+y;
//returning the sum
return resultVal;
}
} Les méthodes d'instance sont divisées en deux catégories :
- Méthode mutateur
- Méthode d'accès
Méthode d'accès
La méthode d'accès est la ou les méthodes qui lisent la ou les variables d'instance. Parce que la méthode est précédée du terme obtenir, nous pouvons la reconnaître. Getters est un autre nom pour cela. Il renvoie la valeur du champ privé. Il est utilisé pour obtenir la valeur du champ privé.
public int getAge()
{
return age;
} Méthode du mutateur
La ou les méthodes lisent et modifient les valeurs des variables d'instance. Parce que la méthode a précédé l'ensemble de termes, nous pouvons le reconnaître. Les setters ou les modificateurs sont d'autres noms pour cela. Même s'il ne vous donne rien, il accepte un paramètre dépendant du champ du même type de données. Il est utilisé pour définir la valeur du champ privé.
public void setAge(int age)
{
this.age = age;
} Exemple :méthodes d'instance – Accesseur et mutateur
public class Employee
{
private int empID;
private String name;
public int getEmpID() //accessor method
{
return empID;
}
public void setEmpID(int empID) //mutator method
{
this.empID = empID;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public void display()
{
System.out.println(" Your Employee NO is.: "+empID);
System.out.println("Employee name: "+name);
}
}
Méthodes pour une bibliothèque standard
Les méthodes de bibliothèque standard sont des méthodes intégrées Java qui peuvent être utilisées immédiatement. Ces bibliothèques standard sont incluses dans un fichier d'archive Java (*.jar) avec JVM et JRE et la bibliothèque de classes Java (JCL).
Les exemples incluent,
- print() est une méthode java.io.
- Dans PrintSteam, la méthode print("...") affiche une chaîne entre guillemets.
- sqrt() est une méthode de classe Math. Elle renvoie la racine carrée d'un nombre.
Voici un exemple qui fonctionne :
// Example: Method from the Java Standard Library
public class Codeunderscored {
public static void main(String[] args) {
// the sqrt() method in action
System.out.print("The Square root of 9 is: " + Math.sqrt(9));
}
} Méthode abstraite
Une méthode abstraite n'a pas de corps de méthode. En d'autres termes, une méthode abstraite n'a pas d'implémentation. Il se déclare dans la classe abstraite à tout moment. Si une classe a une méthode abstraite, elle doit être elle-même abstraite. Le mot clé abstract permet de définir une procédure abstraite.
La syntaxe est la suivante :
abstract void method_name();
abstract class CodeTest //abstract class
{
//abstract method declaration
abstract void display();
}
public class MyCode extends CodeTest
{
//method impelmentation
void display()
{
System.out.println("Abstract method?");
}
public static void main(String args[])
{
//creating object of abstract class
CodeTest code = new MyCode();
//invoking abstract method
code.display();
}
} Méthode d'usine
C'est une méthode qui renvoie un objet à la classe où il a été créé. Les méthodes d'usine sont toutes des méthodes statiques. Un exemple de cas est le suivant :
NumberFormat obj = NumberFormat.getNumberInstance().
La méthode finalize( )
Il est possible de définir une méthode qui sera appelée juste avant que le ramasse-miettes ne détruise un objet. Cette fonction est appelée finalize(), garantissant qu'un objet se termine correctement. Finalize(), par exemple, peut être utilisé pour s'assurer qu'un fichier ouvert détenu par cet objet est fermé.
Définissez simplement la méthode finalize() pour ajouter un finaliseur à une classe. Lorsque le runtime Java recycle un objet de cette classe, il appelle cette méthode. Dans la méthode finalize(), vous spécifierez les actions qui doivent être effectuées avant qu'un objet ne soit détruit dans la méthode finalize().
Voici la forme générale de la méthode finalize() :
protected void finalize( ) {
// finalization code here
} Le mot clé protected est un spécificateur qui empêche le code déclaré en dehors de la classe d'accéder à finalize(). Cela implique que vous n'avez aucun moyen de savoir quand ou si finalize() sera appelé. Par exemple, si votre application s'arrête avant la récupération de place, finalize() ne sera pas appelée.
Quels sont les avantages d'employer des méthodes ?
L'avantage le plus important est que le code peut être réutilisé. Une méthode peut être écrite une fois puis utilisée plusieurs fois. Nous n'avons pas à recréer le code à partir de zéro à chaque fois. Pensez-y de cette façon :"écrire une fois, réutiliser plusieurs fois".
Exemple 5 :Méthode Java pour la réutilisation du code
public class Codeunderscored {
// definition of the method
private static int calculateSquare(int x){
return x * x;
}
public static void main(String[] args) {
for (int i = 5; i <= 10; i++) {
//calling the method
int resultVal = calculateSquare(i);
System.out.println("The Square of " + i + " is: " + resultVal);
}
}
} Nous avons développé la méthode calculateSquare() dans le programme précédent pour calculer le carré d'un nombre. L'approche est utilisée pour trouver le carré des nombres entre cinq et 10 dans ce cas. En conséquence, la même procédure est utilisée à plusieurs reprises.
- Les méthodes rendent le code plus lisible et débogable.
Le code pour calculer le carré dans un bloc est conservé dans la méthode calculateSquare(). En conséquence, il est plus facile à lire.
Exemple :appeler plusieurs fois une méthode
public class Codeunderscored {
static void showCode() {
System.out.println("I am excited about CodeUnderscored!");
}
public static void main(String[] args) {
showCode();
showCode();
showCode();
showCode();
}
}
// I am excited about CodeUnderscored!
// I am excited about CodeUnderscored!
// I am excited about CodeUnderscored!
// I am excited about CodeUnderscored! Exemple :méthode définie par l'utilisateur
import java.util.Scanner;
public class Codeunderscored
{
public static void main (String args[])
{
//creating Scanner class object
Scanner scan=new Scanner(System.in);
System.out.print("Enter the number: ");
//reading value from user
int num=scan.nextInt();
//method calling
findEvenOdd(num);
}
//user defined method
public static void findEvenOdd(int num)
{
//method body
if(num%2==0)
System.out.println(num+" is even");
else
System.out.println(num+" is odd");
}
} Conclusion
En général, une méthode est une manière d'atteindre un objectif. En Java, une méthode est une collection d'instructions qui accomplit un objectif spécifié. Il garantit que le code peut être réutilisé. De plus, les méthodes peuvent également être utilisées pour modifier rapidement le code.
Une méthode est une section de code qui ne s'exécute que lorsqu'elle est invoquée. Il a des paramètres qui sont des données qui peuvent être transmises à une méthode. Les méthodes, souvent appelées fonctions, exécutent des tâches spécifiques. De plus, certains des avantages de l'utilisation de méthodes incluent la réutilisation du code, sa création une fois et son utilisation plusieurs fois.
Au sein d'une classe, une méthode doit être déclarée. Il est défini par le nom de la méthode, précédé de parenthèses(). Bien que Java dispose de plusieurs méthodes prédéfinies, telles que System.out.println(), vous pouvez également écrire la vôtre pour gérer des tâches spécifiques.
