Vous êtes sur la page 1sur 16

developpement-informatique.

com

Méthodes et surcharge des méthodes en Java


Developpement-informatique.com

15-19 minutes

Une méthode est un module de programme contenant une série d'instructions permettant d'exécuter

une tâche. Vous avez déjà vu des classes Java contenant une méthode main(), qui s'exécute

automatiquement lorsque vous exécutez un programme.

La méthode main() d’un programme peut exécuter des méthodes supplémentaires, et ces méthodes

peuvent en exécuter d’autres.

Toute classe peut contenir un nombre illimité de méthodes et chaque méthode peut être appelée un

nombre illimité de fois.

Une méthode main() s'exécute automatiquement lorsque vous exécutez un programme, mais d'autres

méthodes ne s'exécutent pas simplement parce que vous les placez dans une classe - elles doivent

être appelées. Une classe peut contenir des méthodes qui ne sont jamais appelées à partir d'une

application particulière, tout comme certains périphériques électroniques peuvent contenir des

fonctionnalités que vous n'utilisez jamais. Par exemple, vous pouvez utiliser un enregistreur numérique

pour lire des films mais jamais pour enregistrer des programmes télévisés.

Remarque !  L'utilisation d'un nom de méthode pour contenir ou encapsuler une série d'instructions est

un exemple de la fonctionnalité que les programmeurs appellent abstraction.

Lorsque les programmeurs utilisent l'abstraction, ils utilisent un nom de méthode général dans un

module plutôt que de répertorier toutes les activités détaillées qui seront exécutées par la méthode.

Création d'une méthode

Syntaxe :

1
modificateur returnType nomDeMethode(Liste des paramètres) {
2
}
3

Chaque méthode doit inclure les deux parties décrites dans la syntaxe
En-tête - L’en-tête de la méthode fournit des informations sur la manière dont les autres

méthodes peut interagir avec elle. Un en-tête de méthode est également appelé une déclaration.

Un corps de la méthode entre deux accolades: le corps de la méthode contient les instructions

permettant d'effectuer le travail de la méthode.

Un corps de la méthode est appelé sa mise en œuvre (implémentation). Techniquement, une

méthode n'est pas obligée de contenir des instructions dans son corps, mais vous n'avez

généralement aucune raison de créer une méthode vide dans une classe. (Parfois, lors du

développement d'un programme, le programmeur crée une méthode vide en tant qu'espace

réservé et complète l'implémentation ultérieurement. Une méthode vide s'appelle un stub.)

Exemple 1 :

2
public class Personne{
3
    private Integer age;
4
    private String nom;
5
    public void affiche(){
6
    }
7
    public String getNom(){
8
        return this.nom;
9
    }
10
    public static void main(String args[]){
11
        Personne p=new Personne();
12
        p.affiche();
13
    }
14
}
15

16
L'en-tête de la méthode est la première ligne d'une méthode. Il contient les éléments suivants:

Modificateurs d'accès optionnels

Un type de retour

Un identificateur

Parenthèses

Modificateurs d'accès

Le modificateur d'accès pour une méthode Java peut être l'un des modificateurs suivants: public,

private, protected ou, si non spécifié, package par défaut. Le plus souvent, les méthodes sont

accessibles au public.

Une méthode doter d'un accès public signifie que toute autre classe peut l'utiliser, pas seulement la

classe dans laquelle réside la méthode.

De plus, toute méthode pouvant être utilisée sans instancier un objet nécessite le modificateur de mot-

clé static (Méthode de classe). La méthode main() dans une application doit utiliser le mot clé static,

mais d'autres méthodes, telles que affiche(), peuvent également l'utiliser.

Type de retour

Un type de retour décrit le type de données que la méthode renvoie à sa méthode appelante. toutes les

méthodes ne doivent pas nécessairement renvoyer une valeur à leurs méthodes d'appelantes; une

méthode qui retourne aucune donnée a un type de retour void. La méthode main() dans une

application doit avoir un type de retour void; Dans cet exemple, getNom() a String comme type de

retour.

Un identificateur

Le nom d’une méthode peut être n’importe quel identifiant légal. Autrement dit, à l'instar des identifiants

de classes et de variables, l'identifiant d'une méthode doit être un mot sans espaces, et ne peut pas être

un mot-clé Java.

La méthode qui s'exécute en premier lorsque vous exécutez une application doit être nommée main(),

mais vous avez beaucoup de choix pour nommer les autres méthodes que vous créez. Techniquement,

vous pouvez même nommer une autre méthode main() à condition de ne pas inclure String [] dans les

parenthèses, mais cela risquerait d'être source de confusion et n'est pas recommandé. Parce que les

méthodes "font" quelque chose - c'est-à-dire effectuent une action - leurs noms contiennent souvent un

verbe, tel que afficher ou calculer, etc.

Voir Identifiants et mots clés en java


Parenthèses

chaque en-tête de méthode contient un ensemble de parenthèses qui suivent l'identificateur. Les

parenthèses peuvent contenir des données à envoyer à la méthode. Par exemple, lorsque vous écrivez

une méthode main() dans une classe, les parenthèses dans son en-tête entourent String [] args. La

méthode afficher() de la classe Personne ne nécessite aucune donnée extérieure; ses parenthèses

sont donc vides.

Appeler une méthode

Les méthodes d'instance sont accessibles via des objets créés.

Vous pouvez accéder aux membres à l'aide de l'opérateur point ".".

Syntaxe:

2
ReferenceObjet = new Constructor()
3
ReferenceObjet.nomMethode()
4

Exemple 2 :

1 class Lampe {

2     private boolean isOn;

3     public Lampe(){

4         this.isOn=false;

5     }

6     public void allumer() {

7         isOn = true;

8         System.out.println("Allumer ");
9     }

10     public static void ClassMethod() {

11         System.out.println("je suis une méthode de classe ");

12     }

13     public static void main(String args[]){

14         Lampe l1= new Lampe();

15         l1.allumer();

16         Lampe.ClassMethod();

17     }

18 }

19

20

21

22

23

24

25

26

27

28

29

Allumer

je suis une méthode de classe

Passer des paramètres aux méthodes


Certaines méthodes exigent que des éléments de données leur soient envoyés lors de leur appelle. Les

éléments de données que vous utilisez dans un appel à une méthode sont appelés des arguments.

Lorsque la méthode reçoit les éléments de données, ils sont appelés paramètres. Les méthodes qui

reçoivent des données sont flexibles car elles peuvent produire des résultats différents en fonction des

données reçues.

les programmes orientés objet utilisent le masquage d'implémentation, qui décrit l'encapsulage des

détails de la méthode. Cela signifie qu'un client n'a pas besoin de savoir comment une méthode

fonctionne en interne, mais doit seulement connaître le nom de la méthode appelée et le type

d'informations à envoyer. (En règle générale, vous souhaitez également connaître les données

renvoyées par la méthode;) En d'autres termes, la méthode appelante doit uniquement comprendre

l'interface avec la méthode appelée. L’interface est la seule partie d’une méthode que le client de la

méthode voit ou avec laquelle il interagit.

Si une méthode peut recevoir un paramètre ou pas, sa déclaration contient les mêmes éléments que

ceux qui n'acceptent pas de paramètre: modificateurs d'accès facultatifs, type de retour de la méthode,

nom de la méthode et ensemble de parenthèses. Cependant, si une méthode reçoit un paramètre, deux

éléments supplémentaires sont requis entre parenthèses:

Le type de paramètre

Un nom local pour le paramètre

Vous pouvez transmettre plusieurs arguments à une méthode en les répertoriant dans l'appel de la

méthode et en les séparant par des virgules.

La signature d’une méthode est la combinaison du nom de la méthode et du nombre, des types et de

l’ordre des arguments. Par conséquent, vous pouvez dire qu’un appel de méthode doit correspondre à

la signature de la méthode appelée.

Remarque !  Les arguments d'un appel de méthode sont souvent appelés paramètres effectifs. Les

variables de la déclaration de méthode qui acceptent les valeurs des paramètres réels sont des

paramètres formels.

dans l'exemple ci-dessous, la variable "monnom" est un parmètre réel et "nom" dans la méthode

afficher() est un paramètre formel

Exemple 3 :

1 public class Test{


2     public static void afficher(String nom){

3         System.out.println("Bonjour "+nom);

4     }

5     public static void main(String args[]){

6         String monnom="ESSADDOUKI";

7         afficher(monnom);

8     }

9 }

En Java, tous les primitifs tels que int, char, etc. sont passés par valeur, mais tous les non-primitifs (ou

objets de toute classe) sont toujours des références. Cela devient donc délicat lorsque nous passons

des références d'objet à des méthodes. Java crée une copie des références et la transmet à la

méthode, mais celles-ci pointent toujours sur la même référence mémoire. Ainsi, l'objet de la méthode

appelante ainsi que sa référence resteront inchangés.

Les modifications ne sont pas reflétées si nous modifions l'objet lui-même pour désigner un autre

emplacement ou un autre objet.

Exemple 4 :

1 class Personne {

2     private int age;

3     private String nom;

4     public Personne(int age, String nom) {

5         this.age = age;

6         this.nom = nom;

7     }

8     public void setNom(String nom) {

9         this.nom = nom;
10     }

11     public String getNom() {

12         return nom;

13     }

14 }

15 public class Test {

16     public static void main(String args[]) {

17         Personne p = new Personne(32, "ESSADDOUKI");

18         changerNom(p, "Kayouh");

19         System.out.println("le nom de p est " + p.getNom());

20         changerNom2(p, "Moutawakil");

21         System.out.println("le nom de p est " + p.getNom());

22     }

23     public static void changerNom(Personne p, String name) {

24         p.setNom(name);

25     }

26     public static void changerNom2(Personne p, String name) {

27         p = new Personne(42, name);

28     }

29 }

30

31

32

33

34
35

36

37

38

39

40

41

42

43

le nom de p est Kayouh

le nom de p est Kayouh

Différence entre un argument et un paramètre

Argument Paramètre

Lorsqu'une méthode est appelée, les valeurs Les valeurs qui sont écrites lors de la définition

transmises lors de l'appel sont appelées arguments. de la méthode sont appelées paramètres.

Ceux-ci sont utilisés dans l'instruction d'appel de Ceux-ci sont utilisés dans l'en-tête de la

méthode pour envoyer une valeur de la méthode méthode appelée pour recevoir la valeur des

appelante à la méthode appelée. arguments.

Pendant l'appel, chaque argument est toujours Les paramètres sont des variables locales

attribué au paramètre dans la définition de la auxquelles sont attribués les arguments lorsque

méthode. la méthode est appelée.

Ils sont aussi appelés paramètres réels Ils sont aussi appelés paramètres formels

Arguments variables (Varargs)

Dans JDK 5, Java a inclus une fonctionnalité qui simplifie la création de méthodes devant prendre un

nombre variable d’arguments. Cette fonctionnalité s'appelle varargs et est une forme abrégée pour les

arguments de longueur variable. Une méthode qui prend un nombre variable d'arguments est une

méthode varargs.
Avant JDK 5, les arguments de longueur variable pouvaient être traités de deux manières. Une méthode

surchargée (une pour chaque) et une autre placent les arguments dans un tableau, puis transmettent ce

tableau à la méthode. Les deux sont potentiellement sujets aux erreurs et nécessitent plus de code. La

fonction varargs offre une option plus simple et meilleure.

Syntaxe :

Un argument de longueur variable est spécifié par trois points (...). Par exemple :

1
public void afficher(String ... noms){
2
}
3

Cette syntaxe indique au compilateur que afficher() peut être appelée avec zéro argument ou plus. En

conséquence, ici, noms est implicitement déclaré comme un tableau de type String[]. Vous trouverez

ci-dessous un extrait de code illustrant le concept ci-dessus:

Exemple 5 :

1 public class Test{

2     public static void afficher(String ... noms){

3         for (String nom : noms) {

4             System.out.println(nom);

5         }

6     }

7     public static void main(String args[]){

8         afficher("Mostafa", "Ismail", "Dounia", "Omar", "Sara");

9     }

10 }
Mostafa

Ismail

Dounia

Omar

Sara

La syntaxe ... indique au compilateur que varargs a été utilisé et que ces arguments doivent être

stockés dans le tableau désigné par noms.

La variable "noms" est exploitée comme un tableau. Dans ce cas, nous avons défini le type de

données de "noms" comme String. Donc, cela ne peut prendre que des valeurs de String. Le

nombre d'arguments peut être trouvé en utilisant noms.length, la façon dont nous trouvons la

longueur d'un tableau en Java.

Remarque ! Une méthode peut avoir des paramètres de longueur variable avec d'autres paramètres

aussi, mais on doit s'assurer qu'il n'existe qu'un seul paramètre varargs qui doit être écrit en dernier

dans la liste des paramètres de la déclaration de méthode.

1 int nums(int a, float b, double … c)

Dans ce cas, les deux premiers arguments sont mis en correspondance avec les deux premiers

paramètres et les arguments restants appartiennent à c.

Exemple 6 :

1 public class Test {

2     public static void afficher(int annee, String ecole, String... noms) {

3         System.out.println("Annee : " + annee);

4         System.out.println("Ecole : " + ecole);

5         for (String nom : noms) {

6             System.out.println(nom);

7         }

8     }

9     public static void main(String args[]) {


10         afficher(2019, "ESTM", "Mostafa", "Ismail", "Dounia", "Omar",
"Sara");
11

    }
12

}
13

Annee : 2019

Ecole : ESTM

Mostafa

Ismail

Dounia

Omar

Sara

Surcharge des méthodes

La surcharge permet à différentes méthodes d’avoir le même nom, mais des signatures différentes où la

signature peut différer en fonction du nombre de paramètres d’entrée, du type de paramètres d’entrée

ou des deux.

Exemple 7 :

1 public class Test {

2     public int somme(int x, int y) {

3         return (x + y);

4     }

5     public int somme(int x, int y, int z) {

6         return (x + y + z);

7     }

8     public double somme(double x, double y) {

9         return (x + y);

10     }
11     public static void main(String args[]) {

12         Test t = new Test();

13         System.out.println(t.somme(10, 20));

14         System.out.println(t.somme(10, 20, 30));

15         System.out.println(t.somme(10.5, 20.5));

16     }

17 }

18

19

20

21

22

23

24

Et si le prototype exact ne correspond pas aux arguments.

En termes de priorité, le compilateur prend les mesures suivantes:

1. Conversion de type mais vers un type plus élevé (en termes de plage) dans la même catégorie.

2. Conversion de type dans la catégorie immédiatement supérieure (supposez qu'il n'y ait pas de

type de données long disponible pour un type de données int, alors il recherchera le type de

données float).

Exemple 8 :

1 public class Test {

2     public void afficher(String s) {

3         System.out.println("je suis un String : " + s);


4     }

5     public void afficher(int a) {

6         System.out.println("je suis un int : " + a);

7     }

8     public static void main(String args[]) {

9         Test t = new Test();

10         t.afficher("Mostafa");

11         t.afficher('A');

12         t.afficher(435);

13         t.afficher(4.5);

14     }

15 }

16

17

18

19

20

21

22

23

24

25

26

27
Quel est l'avantage?

Nous n’avons pas besoin de créer et de mémoriser des noms différents pour des méthodes faisant la

même chose. Par exemple, dans notre code, si la surcharge n'était pas prise en charge par Java, il

faudrait créer des noms de méthodes tels que somme1, somme2,… ou somme2Int, ... etc.

Peut-on surcharger les méthodes sur le type de retour?

Nous ne pouvons pas surcharger par type de retour.

Exemple 9 :

3 public class Test {

4     public int getValue(){

5     }

6     public String getValue(){

7     }

8 }

10

Peut-on surcharger les méthodes statiques?

La réponse est oui. Nous pouvons avoir deux méthodes statiques ou plus portant le même nom, mais

avec des différences dans les paramètres d'entrée.

Peut-on surcharger main()

Comme d'autres méthodes statiques, nous pouvons surcharger main() en Java.

Java prend-il en charge la surcharge des opérateurs?

Contrairement à C ++, Java n'autorise pas les opérateurs surchargés définis par l'utilisateur.
Partager ce cours avec tes amis :

Vous aimerez peut-être aussi