Java et la méthode de fonctionnement

Une méthode est un ensemble d’instructions qui exécutent une tâche spécifique et renvoient le résultat à l’appelant. Une méthode peut effectuer une tâche spécifique sans rien retourner. Les méthodes nous permettent de réutiliser le code sans le retaper. En Java, chaque méthode doit faire partie d’une classe, ce qui est différent des langages comme C, C++ et Python.

Remarque : les méthodes permettent de gagner du temps et nous aident à réutiliser le code sans le retaper.

Les modificateurs sont divisés en deux groupes :

Les modificateurs d’accès contrôlent le niveau d’accès.
Les modificateurs de non-accès ne contrôlent pas le niveau d’accès mais fournissent d’autres fonctionnalités.
Il existe quatre types de modificateurs d’accès Java :

Privé : Le niveau d’accès d’un modificateur privé est uniquement à l’intérieur de la classe. Il n’est pas possible d’y accéder depuis l’extérieur de la classe.
Défaut : Le niveau d’accès d’un modificateur par défaut est uniquement à l’intérieur du paquet. Il n’est pas possible d’y accéder depuis l’extérieur du paquet. Si vous ne spécifiez aucun niveau d’accès, ce sera le niveau par défaut.
Protégé : Le niveau d’accès d’un modificateur protégé est à l’intérieur du paquet et à l’extérieur du paquet par le biais d’une classe enfant. Si vous ne créez pas la classe enfant, il n’est pas possible d’y accéder depuis l’extérieur du paquetage.
Public : Le niveau d’accès d’un modificateur public est partout. Il est accessible à l’intérieur de la classe, à l’extérieur de la classe, à l’intérieur du paquetage et à l’extérieur du paquetage.
Il existe quelques modificateurs Java sans accès :

static : Le membre appartient à la classe, pas aux objets de cette classe.
final : Les valeurs des variables ne peuvent pas être modifiées une fois assignées, les méthodes ne peuvent pas être surchargées, les classes ne peuvent pas être héritées.
abstract : Si appliqué à une méthode – doit être implémenté dans une sous-classe, si appliqué à une classe – contient des méthodes abstraites.
synchronisé : Contrôle l’accès des threads à un bloc/méthode.
volatile : La valeur de la variable est toujours lue depuis la mémoire principale, et non depuis la mémoire d’un thread spécifique.
transient : Le membre est ignoré lors de la sérialisation d’un objet.

Déclaration de méthode

En général, les déclarations de méthodes comportent six éléments :

Modificateur- : Définit le type d’accès de la méthode, c’est-à-dire l’endroit où l’on peut y accéder dans votre application. En Java, il existe 4 types de spécificateurs d’accès.
public : accessible dans toutes les classes de votre application.
protected : accessible dans la classe dans laquelle elle est définie et dans ses sous-classes.
private : accessible uniquement au sein de la classe dans laquelle elle est définie.
default (déclaré/défini sans utiliser de modificateur) : accessible dans la même classe et le même package que ceux dans lesquels sa classe est définie.
Le type de retour : Le type de données de la valeur retournée par la méthode ou void si elle ne retourne pas de valeur.
Le nom de la méthode : les règles relatives aux noms de champs s’appliquent également aux noms de méthodes, mais la convention est un peu différente.
Liste des paramètres : La liste des paramètres d’entrée, séparés par des virgules, est définie, précédée de leur type de données, entre les parenthèses. S’il n’y a pas de paramètres, vous devez utiliser des parenthèses vides ().
Liste des exceptions : Les exceptions attendues par la méthode peuvent être lancées, vous pouvez spécifier cette ou ces exceptions.
Corps de la méthode : il est placé entre accolades. Il s’agit du code qui doit être exécuté pour effectuer les opérations prévues.

Les méthodes en java

Signature de la méthode : Elle se compose du nom de la méthode et d’une liste de paramètres (nombre de paramètres, type des paramètres et ordre des paramètres). Le type de retour et les exceptions ne sont pas considérés comme faisant partie de la signature.

Signature de la méthode de la fonction ci-dessus :

max(int x, int y)
Comment nommer une méthode ? Le nom d’une méthode est généralement un mot unique qui doit être un verbe en minuscule ou plusieurs mots, qui commence par un verbe en minuscule suivi d’un adjectif, noun…… Après le premier mot, la première lettre de chaque mot doit être en majuscule. Par exemple, findSum,
computeMax, setX et getX

En général, une méthode a un nom unique dans la classe dans laquelle elle est définie, mais il arrive qu’une méthode ait le même nom que d’autres méthodes de la même classe, car la surcharge de méthodes est autorisée en Java.

Appel de la méthode

La méthode doit être appelée pour utiliser sa fonctionnalité. Il peut y avoir trois situations lorsqu’une méthode est appelée :
Une méthode retourne au code qui l’a invoquée lorsque :

elle a terminé toutes les instructions de la méthode
Elle atteint une instruction de retour
Elle lance une exception
Exemple

// Programme Java pour illustrer les méthodes

// Importation des classes nécessaires
import java.io.* ;

// Classe 1
// Classe d’aide
class Addition {

// Initialement, on prend la somme à 0
// car nous n'avons pas commencé la com[utation
int sum = 0 ;

// Méthode
// Pour ajouter deux nombres
public int addTwoInt(int a, int b)
{

    // Addition de deux valeurs entières
    sum = a + b ;

    // Retourne la somme de deux valeurs
    retourne la somme ;
}

}

// Classe 2
// Classe d’aide
class GFG {

// Méthode principale du pilote
public static void main(String[] args)
{

    // Création d'un objet de classe 1 dans la méthode main()
    Addition add = new Addition() ;

    // Appel de la méthode de la classe ci-dessus
    // pour ajouter deux entiers
    // en utilisant l'instance créée
    int s = add.addTwoInt(1, 2) ;

    // Impression de la somme de deux nombres
    System.out.println("Somme de deux valeurs entières :"
                       + s) ;
}

}
Sortie
Somme de deux valeurs entières :3

Exemple 2

// Programme Java pour illustrer l’appel de méthode
// Via différentes façons d’appeler une méthode

// Importation des classes nécessaires
import java.io.* ;

// Classe 1
// Classe d’aide
class Test {

public static int i = 0 ;

// Constructeur de la classe
Test()
{

    // Compte le nombre d'objets de la classe
    i++ ;
}

// Méthode 1
// Pour accéder aux membres statiques de la classe et
// et pour obtenir le nombre total d'objets
// de la même classe créés jusqu'à présent
public static int get()
{

    // instructions à exécuter....
    retourne i ;
}

// Méthode 2
// Méthode d'instance appelant directement un objet
// qui est créé dans une autre classe 'GFG'.

// Peut également être appelée par un objet directement créé dans la
// même classe et à partir d'une autre méthode définie dans la
// même classe et renvoyer une valeur entière car le type de retour est
// int.
public int m1()
{

    // Affiche uniquement le message
    System.out.println(
        "A l'intérieur de la méthode m1 par un objet de la classe GFG") ;

    // Appel de la méthode m2() au sein de la même classe.
    this.m2() ;

    // Déclarations à exécuter, le cas échéant
    retourne 1 ;
}

// Méthode 3
// Ne renvoie rien
public void m2()
{

    // Impression de la déclaration
    System.out.println(
        "La méthode m2 provient de la méthode m1") ;
}

}

// Classe 2
// Classe principale
class GFG {

// Méthode du pilote principal
public static void main(String[] args)
{

    // Création d'un objet de la classe ci-dessus dans la classe thi
    Test obj = new Test() ;

    // Appel de la méthode 2 à l'intérieur de la méthode main()
    int i = obj.m1() ;

    // Affichage du message uniquement
    System.out.println(
        "Contrôle retourné après la méthode m1 :" + i) ;

    // Appel de la méthode m2()
    // obj.m2() ;
    int no_of_objects = Test.get() ;

    // Impression de l'instruction
    System.out.print(
        "No of instances created till now : ") ;

    System.out.println(no_of_objects) ;
}

}
Sortie
Dans la méthode m1 par un objet de la classe GFG
Dans la méthode m2 provenant de la méthode m1
Contrôle retourné après la méthode m1 :1
Nombre d’instances créées jusqu’à présent : 1
Le flux de contrôle du programme ci-dessus est le suivant :

méthodes en java

Allocation de mémoire pour les appels de méthodes

Les appels de méthodes sont implémentés par le biais d’une pile. Chaque fois qu’une méthode est appelée, un cadre de pile est créé dans la zone de pile et ensuite, les arguments passés, les variables locales et la valeur à renvoyer par cette méthode appelée sont stockés dans ce cadre de pile et lorsque l’exécution de la méthode appelée est terminée, le cadre de pile alloué est supprimé. Il existe un registre de pointeurs de pile qui suit le sommet de la pile et qui est ajusté en conséquence.

%d blogueurs aiment cette page :