Déclaration de méthode

Salut! Vous savez déjà comment créer vos propres classes avec des champs et des méthodes. Nous allons maintenant nous attarder sur les méthodes. Bien sûr, nous avons déjà fait cela plus d'une fois dans nos cours, mais nous avons surtout couvert des généralités. Aujourd'hui, nous allons décortiquer les méthodes, et étudier de quoi elles sont faites, les différentes manières de les créer, et comment gérer le tout. :) Allons-y!

Déclaration de méthode

Tout le code qui définit une méthode s'appelle une déclaration de méthode . La forme générale d'une déclaration de méthode peut être décrite comme suit :

access modifier, return type, method name (parameter list) {
    // method body
}

A titre d'exemple, regardez les déclarations des différentes méthodes de la Dogclasse.

public class Dog {

   String name;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {
       Dog max = new Dog("Max");
       max.woof();

   }

   public void woof() {
       System.out.println("A dog named " + name + " says \"Woof, woof!\"");
   }

   public void run(int distanceInFeet) {
       System.out.println("A dog named " + name + " ran " + distanceInFeet + " feet!");
   }

   public String getName() {
       return name;
   }
}

1. Modificateur d'accès

Le modificateur d'accès est toujours indiqué en premier. Toutes les Dogméthodes de la classe sont marquées avec le modificateur public . Cela signifie que nous pouvons les appeler depuis n'importe quelle autre classe :

public class Main {

   public static void main(String[] args) {

       Dog butch = new Dog("Butch");
       butch.run(100);
   }

}

Comme vous pouvez le voir, les Dogméthodes de la classe sont facilement accessibles dans la Mainclasse. Ceci est possible grâce au modificateur public . En Java, il existe d'autres modificateurs. Ils ne permettent pas tous d'utiliser des méthodes dans d'autres classes. Nous en parlerons dans d'autres leçons. La principale chose à retenir est de quoi le modificateur est responsable : si une méthode est accessible dans d'autres classes :)

2. mot-clé statique

L'une des Dogméthodes, main(), est marquée du mot-clé static . Cela fait également partie de la déclaration de méthode, et nous connaissons déjà sa signification. Nous ne l'avons pas mentionné dans le modèle de déclaration de méthode donné au début de la leçon, car il est facultatif. S'il est spécifié, il doit venir après le modificateur d'accès. Vous souvenez-vous que dans les dernières leçons, nous avons parlé de variables statiques (de classe) ? Lorsqu'il est appliqué aux méthodes, ce mot-clé a à peu près la même signification. Si une méthode est static , elle peut être utilisée sans référence à un objet spécifique de la classe. Et en effet, vous n'avez pas besoin d'un Dogobjet pour exécuter la main()méthode statique dans leDogclasse. Il fonctionnera très bien sans un. Si cette méthode n'était pas statique, nous aurions d'abord besoin de créer un objet pour l'exécuter.

3. Valeur de retour

Si notre méthode doit retourner quelque chose, alors nous spécifions le type de la valeur de retour. Cela ressort de l'exemple du getName()getter :

public String getName() {
   return name;
}

Il renvoie un Stringobjet. Si une méthode ne renvoie rien, alors le mot-clé void est utilisé à la place, comme dans la woof()méthode :

public void woof() {
   System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}

Méthodes du même nom

Il y a des situations où nous voudrons plusieurs façons différentes d'appeler une méthode. Pourquoi ne pas créer notre propre intelligence artificielle ? Amazon a Alexa, Apple a Siri, alors pourquoi ne devrions-nous pas en avoir un ? :) Dans le film Iron Man, Tony Stark crée sa propre incroyable intelligence artificielle, Jarvis. Rendons hommage à ce personnage génial et nommons notre IA en son honneur. :) La première chose que nous devons faire est d'apprendre à Jarvis à dire bonjour aux personnes qui entrent dans la pièce (ce serait bizarre si un intellect aussi incroyable se révélait impoli).

public class Jarvis {

   public void sayHi(String name) {
       System.out.println("Good evening, " + name + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
   }
}

Sortie console : Bonsoir, Tony Stark. Comment allez-vous? Très bien! Jarvis est maintenant en mesure d'accueillir des invités. Bien sûr, plus souvent que ce ne sera son maître, Tony Stark. Et s'il ne vient pas seul ! Mais notre sayHi()méthode n'accepte qu'un seul argument. Ainsi, il ne peut saluer qu'une seule personne entrant dans la pièce et ignorera l'autre. Pas très poli, d'accord ? :/ Dans ce cas, on peut résoudre le problème en écrivant simplement 2 méthodes avec le même nom, mais des paramètres différents :

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

}

C'est ce qu'on appelle la surcharge de méthode . La surcharge de méthodes permet à notre programme d'être plus flexible et de s'adapter à différentes façons de travailler. Passons en revue son fonctionnement :

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

Sortie console : Bonsoir, Tony Stark. Comment allez-vous? Bonsoir, Tony Stark et Captain America. Comment allez-vous? Excellent, les deux versions ont fonctionné. :) Mais nous n'avons pas résolu le problème ! Et s'il y a trois invités ? Nous pourrions, bien sûr, surcharger sayHi()à nouveau la méthode, afin qu'elle accepte trois noms d'invités. Mais il pourrait y en avoir 4 ou 5. Jusqu'à l'infini. N'y a-t-il pas une meilleure façon d'apprendre à Jarvis à gérer n'importe quel nombre de noms, sans surcharger la sayHi()méthode un million de fois() ? :/ Bien sûr que oui ! Si ce n'était pas le cas, pensez-vous que Java serait le langage de programmation le plus populaire au monde ? ;)

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       System.out.println();
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

Lorsque ( String... names ) est utilisé comme paramètre, cela indique qu'une collection de Strings sera transmise à la méthode. Nous n'avons pas besoin de spécifier à l'avance combien il y en aura, donc maintenant notre méthode est beaucoup plus flexible :

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
   }
}

Sortie console : Bonsoir, Tony Stark. Comment allez-vous? Bonsoir, Capitaine America. Comment allez-vous? Bonsoir, Veuve Noire. Comment allez-vous? Bonsoir Hulk. Comment allez-vous? À l'intérieur de la méthode, nous parcourons tous les arguments et affichons des phrases formatées avec des noms. Ici, nous utilisons une for-eachboucle simplifiée (que vous avez déjà vue). C'est parfait ici, car la notation ( String... names ) signifie en fait que le compilateur place tous les arguments passés dans un tableau. Par conséquent, nous pouvons travailler avec des noms de variablescomme nous travaillerions avec un tableau, y compris en le parcourant dans une boucle. De plus, cela fonctionnera avec n'importe quel nombre de chaînes passées! Deux, dix, voire mille, la méthode fonctionnera correctement avec n'importe quel nombre d'invités. Bien plus pratique que de surcharger la méthode pour toutes les possibilités, vous ne pensez pas ? :) Voici un autre exemple de surcharge de méthode. Donnons une printInfoFromDatabase()méthode à Jarvis. Il affichera des informations sur une personne à partir d'une base de données. Si la base de données indique qu'une personne est un super-héros ou un super-vilain, nous afficherons cette information :

public class Jarvis {

   public void printInfoFromDatabase (String bio) {

       System.out.println(bio);
   }

   public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {

       System.out.println(bio);
       if (!isEvil) {
           System.out.println("Also known as the superhero " + nickname);
       } else {
           System.out.println("Also known as the supervillain " + nickname);
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.printInfoFromDatabase("Laura Palmer. Date of birth: July 22, 1972. Twin Peaks, Washington");
       System.out.println();
       jarvis.printInfoFromDatabase("Max Eisenhardt. Height: 15.6 ft. Weight: 189 lbs. ", true, "Magneto");
   }
}

Sortie : Laura Palmer. Date de naissance : 22 juillet 1972. Twin Peaks, Washington Max Eisenhardt. Hauteur : 15,6 pi. Poids : 189 lb. Aussi connu sous le nom de supervillain Magneto So, le comportement de notre méthode dépend des données que nous lui transmettons. Autre point important : l'ordre des arguments compte ! Disons que notre méthode prend une chaîne et un nombre :

public class Person {

   public static void sayYourAge(String greeting, int age) {
       System.out.println(greeting + " " + age);
   }

   public static void main(String[] args) {

       sayYourAge("My age is ", 33);
       sayYourAge(33, "My age is "); // Error!
   }
}

Si la méthode Personde la classe sayYourAge()prend une chaîne et un nombre en entrée, alors c'est l'ordre dans lequel ces arguments doivent être passés à la méthode ! Si nous les passons dans un ordre différent, alors le compilateur générera une erreur et la personne ne pourra pas dire son âge. Au fait, les constructeurs, dont nous avons parlé dans la dernière leçon, sont aussi des méthodes ! Vous pouvez également les surcharger (c'est-à-dire créer plusieurs constructeurs avec différents ensembles de paramètres) et l'ordre des arguments passés est également fondamental pour eux. Ce sont de vraies méthodes ! :)

Comment invoquer des méthodes avec des paramètres similaires

Comme vous le savez, nullest un mot clé en Java. Il est très important de comprendre qu'il nullne s'agit ni d'un objet ni d'un type de données . Imaginez que nous ayons une Personclasse et une introduce()méthode qui annoncent le nom et l'âge de la personne. De plus, l'âge peut être transmis sous forme de texte ou de nombre.

public class Person {

   public void introduce(String name, String age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person alex = new Person();
       alex.introduce ("Alex", "twenty-one");

       Person mary = new Person();
       mary.introduce("Mary", 32);
   }
}

Nous connaissons déjà la surcharge, nous savons donc que les deux méthodes se comporteront comme elles le devraient : Je m'appelle Alex. J'ai vingt et un ans. Je m'appelle Mary. Mon âge est de 32 ans Mais que se passera-t-il si nous passons nullcomme second paramètre à la place d'une chaîne ou d'un nombre ?

public static void main(String[] args) {

   Person victor = new Person();
   victor.introduce("Victor", null);// Ambiguous method call!
}

Nous aurons une erreur de compilation ! Qu'est-ce qui en est la cause et quelle est exactement "l'ambiguïté" ? En fait, tout est très simple. Le problème est que nous avons deux versions de la méthode : une avec a Stringcomme second argument, et une avec an Integercomme second argument. Mais a Stringet an Integerpeuvent être tous les deux null! Étant donné qu'il s'agit de types de référence, nullest la valeur par défaut pour les deux. C'est pourquoi, dans cette situation, le compilateur ne peut pas déterminer quelle version de la méthode il doit appeler. La solution à ce problème est assez simple. Nullpeut être explicitement converti en un type de référence spécifique. Ainsi, lorsque vous appelez une méthode, vous pouvez indiquer entre parenthèses le type de données souhaité pour le second argument ! Le compilateur comprendra votre "indice" et appellera la bonne méthode :

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("Method with a string and a number!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", (String) null);
   }
}

Sortie : méthode avec deux chaînes ! Je m'appelle Victor. Mon âge est null Notez que si le paramètre number était un primitif intplutôt qu'une instance du type de référence Integer, il n'y aurait pas eu une telle erreur.

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, int age) {
       System.out.println("Method with a string and a number!!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", null);
   }
}

Pouvez-vous deviner pourquoi? Si vous avez deviné pourquoi, bravo ! :) Parce que les primitives ne peuvent pas être null. Maintenant, le compilateur n'a qu'un seul choix, c'est-à-dire appeler la introduce()méthode avec deux chaînes. Il s'agit de la version de la méthode qui s'exécutera à chaque appel de la méthode.