Metodeparametere i Java

1. Passerende argumenter

Og nå begynner moroa. Du vet sikkert allerede fra metoder som det System.out.println()at vi kan overføre argumenter til metoder. Når vi er inne i metoden, refererer vi til dem som parametere. Faktisk forbedrer parametere i stor grad fordelene vi får ved å lage og bruke metoder.

Hvordan erklærer vi en metode med parametere? Det er faktisk ganske enkelt:

public static void name(parameters)
{
  method body
}

Hvor name er det unike navnet på metoden og method body representerer kommandoene som utgjør metoden. Og parameters er en plassholder for metodeparametrene, atskilt med komma. La oss beskrive denne malen mer detaljert:

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 vil at metoden skal ha parametere, lar vi bare parentesene stå tomme.

Parametre er spesielle variabler innenfor en metode. Med deres hjelp kan du sende ulike verdier til metoden når den kalles.

La oss for eksempel skrive en metode som viser en tekststreng et gitt antall ganger.

Du vet allerede hvordan du skriver kode for å vise en streng på skjermen flere ganger. Men hvilken streng skal du skrive ut? Og hvor mange ganger? Det er det vi trenger parametrene til.

Koden som gjør dette vil se slik ut:

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 kalles, blir parameterne tildelt de beståtte verdiene, og først da begynner vi å utføre kommandoene inne i metoden.

2. Argumenter

Jeg vil gjerne trekke din oppmerksomhet litt mer til å kalle en metode med parametere.

Verdiene som sendes til metoden kalles vanligvis argumenter når de sendes til metoden.

La oss se på et annet 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 ble kalt for første gang, ble dens parametere tildelt følgende verdier:
String text = "Hi", int count = 10.

Da printLinesmetoden ble kalt andre gang, ble dens parametere tildelt forskjellige verdier:
String text = "Bye", int count = 20.

Parametre er hverken mer eller mindre enn variabler som tildeles bestemte verdier når en metode kalles. Verdiene "Hi", "Bye", 10og 20kalles i seg selv argumenter."

3. Motstridende variabelnavn når du kaller en metode

Variabler kan brukes som metodeargumenter. Dette er enkelt og forståelig, men det kan potensielt skape noen vanskeligheter. La oss gå tilbake til det samme eksemplet, men denne gangen flytter vi argumentene til separate variabler:

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å bra: vi har en strvariabel. Verdien tilordnes parameteren textnår metoden kalles. Vi har en nvariabel. Verdien tildeles parameteren countnår metoden kalles." Så langt er alt klart.

La oss nå gi nytt navn til variablene våre 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 oppmerksom på to ting

For det første: vi har variabler med samme navn i forskjellige metoder. Dette er forskjellige variabler (vi viser dem bevisst med forskjellige farger). Alt fungerer på samme måte som i forrige eksempel, hvor variablene i mainmetoden ble navngitt strog n.

For det andre: Ingenting magisk skjer når metoden kalles. Parametrene blir ganske enkelt tildelt argumentverdiene. Uansett om de er tall, strenger, variabler eller uttrykk.

Etter at vi har gitt nytt navn til variablene i hovedmetoden, har ingenting endret seg. De var forskjellige variabler i forskjellige metoder tidligere, og slik forblir de. Det er ingen magisk sammenheng mellom variablene text og text .

4. Sende referanser til metoder

Jeg håper du forsto alt fra forrige leksjon, for nå skal vi se tilbake på beståtte argumenter til metoder, bare vi vil dykke dypere.

Som du allerede vet, lagrer noen Java-variabler ikke selve verdiene, men i stedet en referanse, dvs. adressen til minneblokken der verdiene er plassert. Dette er hvordan strengvariabler og matrisevariabler fungerer.

Hva skjer når du tilordner en annen matrisevariabel til en matrisevariabel? Det er riktig. De to variablene begynner å referere til samme plass i minnet:

Og hva skjer hvis en av disse variablene 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);
   }
}

Nøyaktig det samme skjer: data parameteren vil inneholde en referanse til det samme minneområdet som variabelen months. Når metoden kalles, oppstår en enkel oppgave: .data = months

Og siden begge variablene refererer til det samme området av minnet som lagrer et heltall, printArraySum kan metoden ikke bare lese verdier fra matrisen, men også endre dem!

For eksempel kan vi skrive vår egen metode som fyller en todimensjonal matrise med samme verdi. Slik kan det se ut:

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

La oss nå gå tilbake til metodenavn igjen.

Java-standarder krever at alle metoder i samme klasse har unike navn. Med andre ord, det er umulig å deklarere to identisk navngitte metoder i samme klasse.

Når metoder sammenlignes for likhet, tas ikke bare navnene i betraktning, men også typene av parametere ! Merk at navnene på parameterne ikke tas med i betraktningen . 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 anses noen metoder som like , mens andre er forskjellige ? Og hvorfor blir ikke parameternavn tatt i betraktning når man bestemmer det unike til en metode?

Hvorfor er unikhet nødvendig i det hele tatt? Saken er at når kompilatoren kompilerer et program, må den vite nøyaktig hvilken metode du har tenkt å kalle på et gitt sted.

Hvis du for eksempel skriver , er kompilatoren smart og vil lett konkludere med at du har tenkt å kalle metoden her med en parameter.System.out.println("Hi")println()String

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

Når en metode kalles, sikrer kompilatoren at typene av argumentene samsvarer med typene av parameterne. Den legger ikke vekt på navnet på argumentene. I Java hjelper ikke parameternavn kompilatoren med å bestemme hvilken metode som skal kalles. Og det er grunnen til at de ikke blir tatt i betraktning når man bestemmer det unike ved en metode.

Navnet på en metode og typene av dens parametere kalles metodesignaturen . For eksempel,sum(int, int)

Hver klasse må ha metoder med unike signaturer i stedet for metoder med unike navn.