Metodeparametre i Java

1. Passerende argumenter

Og nu begynder det sjove. Du kender sikkert allerede fra metoder som System.out.println()den, at vi kan overføre argumenter til metoder. Når vi er inde i metoden, omtaler vi dem som parametre. Faktisk forbedrer parametre i høj grad de fordele, vi får ved at skabe og bruge metoder.

Hvordan erklærer vi en metode med parametre? Det er faktisk ret simpelt:

public static void name(parameters)
{
  method body
}

Hvor name er det unikke navn på metoden og method body repræsenterer de kommandoer, der udgør metoden. Og parameters er en pladsholder for metodeparametrene, adskilt af kommaer. Lad os beskrive denne skabelon mere detaljeret:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

Eksempler:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

Hvis vi ikke ønsker at metoden skal have parametre, så lader vi bare parenteserne stå tomme.

Parametre er specielle variable inden for en metode. Med deres hjælp kan du videregive forskellige værdier til metoden, når den kaldes.

Lad os for eksempel skrive en metode, der viser en tekststreng et givet antal gange.

Du ved allerede, hvordan man skriver kode for at vise en streng på skærmen flere gange. Men hvilken streng skal du printe? Og hvor mange gange? Det er det, vi skal bruge parametrene til.

Koden, der gør dette, vil se sådan ud:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

Hver gang en metode kaldes, tildeles dens parametre de beståede værdier, og først derefter begynder vi at udføre kommandoerne inde i metoden.

2. Argumenter

Jeg vil gerne henlede din opmærksomhed lidt mere på at kalde en metode med parametre.

De værdier, der sendes til metoden, kaldes normalt argumenter, når de overføres til metoden.

Lad os se på et andet eksempel:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

Da printLines metoden blev kaldt for første gang, blev dens parametre tildelt følgende værdier:
String text = "Hi", int count = 10.

Da printLinesmetoden blev kaldt anden gang, blev dens parametre tildelt forskellige værdier:
String text = "Bye", int count = 20.

Parametre er hverken mere eller mindre end variabler, der tildeles bestemte værdier, når en metode kaldes. Værdierne "Hi", "Bye", 10og 20kaldes i sig selv argumenter."

3. Modstridende variabelnavne, når en metode kaldes

Variabler kan bruges som metodeargumenter. Dette er enkelt og forståeligt, men det kan potentielt give nogle vanskeligheder. Lad os gå tilbage til det samme eksempel, men denne gang flytter vi argumenterne til separate variable:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

Så langt, så godt: Vi har en strvariabel. Dens værdi tildeles parameteren, textnår metoden kaldes. Vi har en nvariabel. Dens værdi tildeles parameteren, countnår metoden kaldes." Indtil videre er alt klart.

Lad os nu omdøbe vores variable i mainmetoden:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

Vær opmærksom på to ting

For det første: vi har variabler med samme navn i forskellige metoder. Disse er forskellige variabler (vi afbilder dem bevidst ved hjælp af forskellige farver). Alt fungerer på samme måde som i det foregående eksempel, hvor variablerne i mainmetoden blev navngivet strog n.

For det andet: Der sker ikke noget magisk, når metoden kaldes. Parametrene tildeles simpelthen argumentværdierne. Uanset om det er tal, strenge, variable eller udtryk.

Efter at vi har omdøbt variablerne i hovedmetoden, er intet ændret. De var forskellige variabler i forskellige metoder tidligere, og så forbliver de. Der er ingen magisk forbindelse mellem variablerne text og text .

4. Videregivelse af referencer til metoder

Jeg håber, at du forstod alt fra den forrige lektion, for nu skal vi gense forbigående argumenter til metoder, kun vi dykker dybere.

Som du allerede ved, lagrer nogle Java-variabler ikke selve værdierne, men i stedet en reference, altså adressen på den hukommelsesblok, hvor værdierne er placeret. Sådan fungerer strengvariabler og matrixvariabler.

Når du tildeler en anden matrixvariabel til en matrixvariabel, hvad sker der så? Det er rigtigt. De to variabler begynder at henvise til det samme rum i hukommelsen:

Og hvad sker der, hvis en af ​​disse variable er en metodeparameter?

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }

   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

Præcis det samme sker: data parameteren vil indeholde en reference til det samme hukommelsesområde som variablen months. Når metoden kaldes, opstår en simpel tildeling :.data = months

Og da begge variabler refererer til det samme hukommelsesområde, der lagrer et heltal, så printArraySum kan metoden ikke kun læse værdier fra arrayet, men også ændre dem!

For eksempel kan vi skrive vores egen metode, der udfylder et todimensionelt array med samme værdi. Sådan kan det se ud:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

5. Metoder med samme navn

Lad os nu vende tilbage til metodenavnene igen.

Java-standarder kræver, at alle metoder i samme klasse har unikke navne. Det er med andre ord umuligt at erklære to identisk navngivne metoder i samme klasse.

Når metoder sammenlignes for ensartethed, tages der ikke kun hensyn til navnene, men også parametrenes typer ! Bemærk, at navnene på parametrene ikke tages i betragtning . Eksempler:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

Hvorfor betragtes nogle metoder som ens , mens andre er forskellige ? Og hvorfor tages der ikke højde for parameternavne, når en metodes unikhed skal bestemmes?

Hvorfor er unikhed overhovedet nødvendigt? Sagen er, at når compileren kompilerer et program, skal den vide præcis, hvilken metode du har tænkt dig at kalde et givet sted.

For eksempel, hvis du skriver , er compileren smart og vil nemt konkludere, at du har tænkt dig at kalde metoden her med en parameter.System.out.println("Hi")println()String

Men hvis du skriver , vil compileren se et kald til metoden med en parameter.System.out.println(1.0)println()double

Når en metode kaldes, sikrer compileren, at typerne af argumenterne matcher parametrenes typer. Den lægger ikke vægt på navnet på argumenterne. I Java hjælper parameternavne ikke compileren med at bestemme, hvilken metode der skal kaldes. Og det er derfor, de ikke tages i betragtning, når man skal bestemme en metodes unikke karakter.

Navnet på en metode og typen af ​​dens parametre kaldes metodesignaturen . For eksempel,sum(int, int)

Hver klasse skal have metoder med unikke signaturer i stedet for metoder med unikke navne.