Création et utilisation de méthodes en Java

Java

Encore une fois, bienvenue ! Le sujet d'aujourd'hui est les méthodes Java. Si vous n'avez pas suivi, nous avons couvert la logique et le binaire, les types primitifs et les types de référence. Maintenant, nous allons nous plonger dans l'une des fonctionnalités des objets appelée méthode. En particulier, nous allons nous concentrer sur la création et l'utilisation de méthodes en Java.

Que sont les méthodes ?

Si vous avez eu l'occasion de jouer avec des cordes, vous connaissez probablement quelques méthodes comme length() et equals() . En fait, dans la dernière leçon, nous avons abordé très brièvement les méthodes lorsque nous avons mentionné l'opérateur point .

Il s'avère que les méthodes sont des actions que nous effectuons sur des objets. Dans le cas des chaînes, nous avons utilisé des méthodes pour en savoir plus sur les différents String objets. Par exemple, nous pouvons utiliser length() pour déterminer le nombre de caractères dans un String objet.

Bien sûr, les méthodes peuvent faire d'autres choses comme manipuler des objets. Étant donné que les chaînes sont immuables, il n'y a généralement pas beaucoup de ces types de méthodes. Cependant, ils existent.

Par exemple, il y a un String méthode appelée toLowerCase() qui convertira tous les caractères dans un String s'opposer aux minuscules. Comme déjà mentionné, les chaînes sont immuables, donc la méthode renverra en fait un tout nouveau String objet—un avec une nouvelle adresse. Jetons un coup d'œil :

String myString = "Hello, World!";
myNewString = myString.toLowerCase();
System.out.printLn(myString); // Prints "Hello, World!"
System.out.printLn(myNewString); // Prints "hello, world!"

Remarquez comment les deux chaînes sont différentes. C'est parce que le String d'origine l'objet n'a jamais été modifié. Au lieu de cela, le toLowerCase() la méthode a renvoyé un tout nouveau String objet. Nous approfondirons cela plus tard.

D'ici là, nous devrions probablement aborder un sujet important en informatique :la pile.

La pile

Au fur et à mesure que nous poursuivrons ces leçons, nous voudrons nous familiariser avec deux domaines clés du matériel informatique :la pile et le tas . Ces deux concepts définissent les régions de mémoire où vit un programme.

Lorsque nous parlons de méthodes, nous ne nous soucions vraiment que de la pile. La pile est une structure de données dernier entré, premier sorti (LIFO) qui ressemble étroitement à quelque chose comme une pile de crêpes (sauf qu'elle est souvent dessinée à l'envers). Comme vous pouvez l'imaginer, la dernière crêpe ajoutée à la pile est mangée en premier.

Chaque fois que nous utilisons une méthode, elle est ajoutée à la pile en tant qu'appel de méthode. Par exemple, si nous appelons equals() sur un objet String, un nouvel appel de méthode sera ajouté à la pile. Une fois equals() le calcul est terminé, l'appel sort de la pile et nous revenons à une pile vide.

Pour les besoins de la discussion, disons que equals() appelle quelques méthodes qui lui sont propres. Par exemple, il compare peut-être les deux chaînes par longueur. S'ils ont la même longueur, nous dirons que les chaînes sont égales. Pour ce faire, equals() devrait attendre length() pour terminer le calcul sur les deux chaînes avant de pouvoir renvoyer true ou false .

Heureusement, la pile simplifie un peu la complexité. Le programme commencera en appuyant sur le equals() appeler sur la pile. Ensuite, le programme poussera le length() appeler la première chaîne au-dessus du equals() appeler.

Une fois length() est terminé, il passera le résultat à equals() , et le programme poussera un length() supplémentaire appeler en plus du equals() appeler la deuxième chaîne. Enfin, equals() utilisera le résultat des deux length() calculs à rapporter true ou false .

Ne vous inquiétez pas si cela vous semble au-dessus de votre tête ! Nous reviendrons sur les piles à l'avenir.

Un conte de deux méthodes

En général, il existe deux types de méthodes de base :statique et instance . Jusqu'à présent, nous avons travaillé avec des méthodes d'instance qui opèrent sur une instance d'une classe. Par exemple :

String favoriteColor = "blue";
String favoriteFood = "sushi";
favoriteColor.equals(favoriteFood);

Ici, nous avons deux instances de la classe String :favoriteColor et favoriteFood . La première chose à noter est que le equals() méthode utilise ces deux variables. Cependant, une seule de ces variables est fournie en entrée tandis que l'autre initie l'appel de méthode.

Alors, comment ça marche ?

Les méthodes d'instance fonctionnent parce que l'objet dont elles font partie fournit un contexte à l'opération. En d'autres termes, nous n'avons besoin que d'une seule entrée pour la méthode equals car elle a accès à l'objet appelant.

Pendant ce temps, une méthode statique appartient à la seule classe. En d'autres termes, les méthodes statiques n'ont pas accès aux propriétés d'instance comme la séquence de caractères qui définit favoriteColor . Au lieu de cela, les méthodes statiques fournissent une utilité à une classe dans son ensemble. Par exemple :

String.valueOf(5);

Cette ligne appelle la méthode statique valueOf() du String classe sur un entier. Le résultat est l'entier sous la forme d'un String ou "5". Les méthodes statiques fonctionnent sans jamais avoir besoin d'une instance d'une classe car elles n'ont besoin d'aucun contexte pour exécuter leur fonction.

Syntaxe de la méthode

Maintenant que nous avons une idée de la façon dont les méthodes sont utilisées, regardons comment elles sont écrites.

Syntaxe de la méthode statique

Examinons d'abord une méthode statique :

public static int add(int firstNum, int secondNum) {
    return firstNum + secondNum;
}

Dans la première ligne, nous avons pas mal d'informations :

public :indique que la méthode est publique (nous pourrons en discuter plus tard)
static :déclare la méthode comme statique
int :indique un type de retour entier

Le bit suivant est le nom de la méthode suivi de parenthèses qui contiennent les entrées. Dans ce cas, nous avons créé une méthode add avec deux int entrées.

Dans le corps de la méthode, nous avons l'instruction return. Le return Le mot-clé marque un point de sortie pour la méthode. En d'autres termes, return prend tout ce qui se trouve sur sa ligne et le renvoie comme sortie de la méthode. Si nous devions appeler le add(5, 6) , la ligne de retour nous donnerait un résultat de 11.

Vous remarquerez peut-être également qu'il existe quelques éléments de syntaxe intéressants. Par exemple, la ligne dans le corps se termine par un point-virgule, ; . En Java, toutes les lignes doivent se terminer par un point-virgule à moins qu'elles n'ouvrent un bloc de code. Les blocs de code sont ouverts à l'aide d'une accolade ouvrante, { , et fermé à l'aide d'une accolade fermante, } .

Syntaxe de la méthode d'instance

Malheureusement, jusqu'à ce que nous parlions de la disposition des classes, nous n'aurons pas d'exemples de méthodes statiques à essayer par vous-même. Cependant, vous pouvez essayer d'écrire vos propres méthodes d'instance qui serviront un objectif similaire pour le moment.

La syntaxe de la méthode d'instance est exactement la même sauf que vous excluez le static modificateur. Par exemple :

public int add(int firstNum, int secondNum) {
    return firstNum + secondNum;
}

Essayez de le saisir directement dans le volet des interactions DrJava. En cas de succès, vous devriez pouvoir appeler la méthode en utilisant son nom et deux entrées de votre choix. Essayez d'utiliser votre connaissance des types primitifs pour observer la méthode sous diverses entrées. Voici quelques exemples :

add(2, 3)
add(-4, 6)
add(4.0, 7)
add(5, true)

Remarquez comment certains de ces exemples échouent là où ils n'auraient peut-être pas utilisé l'opérateur d'addition. C'est parce que notre méthode applique uniquement la saisie d'entiers.

Alors, qu'est-ce qui différencie cette méthode d'une méthode statique ?

Pour le moment, rien. Cependant, essayez ce qui suit :

int firstNum;
int secondNum;
public int add() {
    return firstNum + secondNum;
}

Vous pouvez maintenant appeler add sans aucune entrée. Sans définir explicitement firstNum et secondNum , add() doit renvoyer 0. Cependant, vous pouvez modifier le comportement de la méthode add en modifiant l'une ou l'autre de ces variables. Essayez de modifier firstNum et surveiller le comportement de add.

Surcharge de méthode

Sans vous en rendre compte, vous venez de surcharger la méthode add. Je ne suis pas sûr de ce que cela veut dire? Essayez d'appeler add dans les deux sens :une fois sans entrée et une fois avec deux entrées.

Vous venez de créer deux méthodes d'ajout différentes qui partagent le même nom. Ceci est parfaitement légal en Java et nous permet d'étendre le comportement d'une seule méthode pour gérer plusieurs listes de paramètres d'entrée. Il existe de nombreuses utilisations de la surcharge de méthode, mais en général, elle est utilisée pour améliorer la lisibilité du code.

À l'avenir, nous aborderons certainement la lisibilité du code car je pense que c'est l'aspect le plus important du codage. Pour l'instant, nous allons nous arrêter ici. Merci encore d'être resté dans les parages ! Ensuite, nous élargirons notre champ d'application à la structure de classe, afin que nous puissions commencer à écrire notre propre code.