Metodeparametere i Java

"Hei Amigo! Jeg håper du likte å løse oppgaver ved hjelp av dine egne metoder, og at du innser hvor praktisk det er å lage metoder. La oss nå snakke om det mest interessante emnet av alle."

"Du har vakt min interesse, Diego... Et nytt emne?"

"Hvert emne er nytt for deg, min unge robot! Og denne er intet unntak. Selv om det nok en gang handler om metoder. Du har sikkert allerede lagt merke til fra metoder som at vi kan overføre argumenter til metoder. Når vi først er inne i System.out.println()metoden , refererer vi til dem som parametere."

"Parametere er det vi skriver innenfor parentesen?"

"Ja, akkurat. Og faktisk øker parametere i stor grad fordelene vi får ved å lage og bruke metoder."

"Jeg forstår hva du sier om å bruke dem, og det viser seg at jeg allerede har gjort det. Hvordan deklarerer vi en metode med parametere?"

"Det er faktisk ganske enkelt:

public static void name(parameters)
{
  method body
}

"Hvor nameer det unike navnet på metoden og method bodyrepresenterer kommandoene som utgjør metoden. Og parameterser en plassholder for metodeparametrene, atskilt med komma."

"Hmm... jeg tror jeg forstår... Eller kanskje ikke..."

"La meg gi deg noen flere detaljer om denne malen slik at du er sikker på at du forstår at du forstår:

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

Her er noen eksempler:

public static void print(String str)
{
}

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

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

"Ah... Nå er det klart. Og hvis vi ikke vil at metoden skal ha parametere, så lar vi bare parentesen stå tom."

"Nettopp. I utgangspunktet er parametere spesielle variabler innenfor en metode. Med deres hjelp kan du sende ulike verdier til metoden når den kalles. Og hvis du ikke trenger å sende verdier, lar du parentesene stå tomme.

"La oss for eksempel skrive en metode som viser en gitt tekstlinje et gitt antall ganger. Noen tanker om hvordan dette gjøres?"

"Vel... Det virker som om jeg er godt klar over hvordan man skriver kode for å vise en streng på skjermen flere ganger..."

"Hvordan angir du strengen som skal vises? Og hvordan angir du antall viste linjer? Kan du gjette?"

"Ting begynner å bli klart... Trolig ved hjelp av metodeparametere?"

"Nøyaktig. En strengparameter for tekstlinjen, og en numerisk parameter for antall viste linjer. 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 dens parametere tildelt de beståtte verdiene, og først da begynner vi å utføre kommandoene inne i metoden.

Argumenter

"Jeg vil at du skal være spesielt oppmerksom på å kalle metoder som har parametere. Verdiene som sendes til metoden kalles vanligvis argumenter når de sendes til metoden.

La oss ta en ny titt på eksemplet vårt:

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 printLinesmetoden 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.

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

"Jeg skal prøve å huske forskjellen og ikke forveksle disse konseptene."

Motstridende variabelnavn når du kaller en metode

"Når du kaller en metode, kan du bruke variabler som argumenter.

"Vel, det gir mening!"

"Det er fornuftig, men det kan potensielt skape noen vanskeligheter. La oss gå tilbake til eksemplet vårt igjen, men denne gangen flytter vi argumentene inn i 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";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... Jeg ser ingen vanskeligheter. Vi har en strvariabel. Dens verdi tildeles parameteren textnår metoden kalles. Vi har en nvariabel. Dens verdi tilordnes parameteren countnår metoden kalles." — Så langt er alt klart.

"Bra, bra. 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";
     String 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 de to textvariablene."

"Nå vet jeg det."

Sende referanser til metoder

"Jeg håper du allerede har assimilert alt jeg har fortalt deg om å overføre argumenter til metoder. Jeg sier det, fordi vi nå skal dykke litt dypere inn i dette emnet. Hør nøye."

"Du vet allerede at noen variabler i Java ikke lagrer verdiene i seg selv, men i stedet en referanse , dvs. adressen til minneblokken der verdiene er plassert. Slik fungerer strengvariabler og arrayvariabler.

"Når en utvikler tildeler en annen matrisevariabel til en matrisevariabel, hva skjer?"

— Peker de da på samme adresse?

"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 sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

"Nøyaktig det samme skjer: dataparameteren vil inneholde en referanse til samme minneområde som monthsvariabelen. Når metoden kalles oppstår en enkel tilordning: .data = months

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

"Jeg skjønner vel, men jeg trenger flere eksempler!"

"Vel, for eksempel, vi kan 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);
   }
}

Metoder med samme navn

"La oss nå gå tilbake til metodenavn igjen."

"Jeg kan ikke forestille meg hva annet som kan sies om navn!"

"Vel, Java-språkstandarden krever at alle metoder i samme klasse har unike navn.

"Så, det er umulig å erklære to identisk navngitte metoder i samme klasse?"

"Nå - følg godt med! Metoder i en klasse kan faktisk ha identiske navn! Men i dette tilfellet må de ha forskjellige parametere. Med andre ord, metoder sammenlignes for likhet, ikke bare blir navnene tatt i betraktning, men også typene av parametere ! Merk at jeg spesifikt sa typer. Navnene på parameterne er ikke tatt i betraktning . 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) {
}

"Jeg er helt forvirret! Hvorfor trenger vi alt dette? Hvorfor regnes noen metoder som like , mens andre er forskjellige ? Og hvorfor tas det ikke hensyn til parameternavn når man bestemmer en metodes unikhet? Hvorfor er unikhet nødvendig ved alle?"

"Tingen er at når kompilatoren kompilerer et program, må den vite nøyaktig hvilken metode du har tenkt å kalle på et gitt sted.

"For eksempel, hvis du skriver , er kompilatoren smart og vil lett konkludere med at du har tenkt å kalle metoden her med en parameter. Men hvis du skriver , vil kompilatoren se et kall til metoden med en parameter. Den har ingen anelse om hvilket navn programmereren ga til parameteren da han erklærte metoden."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, det ser ut til å begynne å komme igjennom!

"Når en metode kalles, sørger kompilatoren for at typene av argumentene samsvarer med typene av parameterne. Den tar ikke hensyn til navnet på argumentene. I Java hjelper ikke parameternavn kompilatoren med å bestemme hvilken metode som skal Programmerere trenger dem, ikke kompilatoren.

"Og jeg antar at det er derfor de ikke blir tatt i betraktning når man skal bestemme det unike ved en metode?"

"Ja, det er helt riktig. Navnet på en metode og typene av dens parametere kalles metodesignaturen . For eksempel sum (int, int)"

"Så hver klasse må ha metoder med unike signaturer i stedet for metoder med unike navn."

"Godt gjort, Amigo! Du oppsummerte denne leksjonen perfekt. Hvis noe forblir uklart, ikke få panikk. Dette emnet vil bli klart etter et par oppgaver."