Metodeparametre i Java

"Hej Amigo! Jeg håber, du nød at løse opgaver ved hjælp af dine egne metoder, og at du indser, hvor praktisk det er at skabe metoder. Lad os nu tale om det mest interessante emne af alle."

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

"Hvert emne er nyt for dig, min unge robot! Og det her er ingen undtagelse. Selvom det endnu en gang handler om metoder. Du har sikkert allerede bemærket fra metoder som, at vi kan overføre argumenter til metoder. System.out.println()Når vi er inde i metoden , henviser vi til dem som parametre."

"Parametre er det, vi skriver inde i parentesen?"

"Ja, præcis. Og faktisk øger parametre i høj grad de fordele, vi får ved at skabe og bruge metoder."

"Jeg forstår, hvad du siger om at bruge dem, og det viser sig, at jeg allerede har gjort det. Hvordan erklærer vi en metode med parametre?"

"Det er faktisk ret simpelt:

public static void name(parameters)
{
  method body
}

"Hvor nameer det unikke navn på metoden og method bodyrepræsenterer de kommandoer, der udgør metoden. Og parameterser en pladsholder for metodeparametrene, adskilt af kommaer."

"Hmm... jeg tror jeg forstår... Eller måske ikke..."

"Lad mig give dig nogle flere detaljer om denne skabelon, så 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 nogle eksempler:

public static void print(String str)
{
}

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

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

"Ah... Nu er det klart. Og hvis vi ikke vil have metoden til at have parametre, så lader vi bare parenteserne stå tomme."

"Nøjagtigt. Grundlæggende er parametre specielle variabler inden for en metode. Med deres hjælp kan du sende forskellige værdier til metoden, når den kaldes. Og hvis du ikke skal videregive værdier, så lader du parenteserne stå tomme.

"Lad os f.eks. skrive en metode, der viser en given tekstlinje et givet antal gange. Nogen tanker om, hvordan man gør dette?"

"Nå... Det ser ud til, at jeg er godt klar over, hvordan man skriver kode for at vise en streng på skærmen flere gange..."

"Hvordan angiver du strengen, der skal vises? Og hvordan angiver du antallet af viste linjer? Kan du gætte?"

"Tingene begynder at stå klart... Formentlig ved hjælp af metodeparametre?"

"Nøjagtigt. En strengparameter for tekstlinjen og en numerisk parameter for antallet af viste linjer. Koden, der gør dette, ville 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.

Argumenter

"Jeg vil gerne have, at du er særlig opmærksom på at kalde metoder, der har parametre. De værdier, der sendes til metoden, kaldes normalt argumenter, når de videregives til metoden.

Lad os tage et andet kig på vores 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 printLinesmetoden 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", 10, og 20kaldes i sig selv argumenter."

"Jeg vil prøve at huske forskellen og ikke forveksle disse begreber."

Modstridende variabelnavne, når en metode kaldes

"Når du kalder en metode, kan du bruge variabler som argumenter.

"Jamen, det giver mening!"

"Det giver mening, men det kan potentielt give nogle vanskeligheder. Lad os gå tilbage til vores eksempel igen, men denne gang flytter vi argumenterne ind 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 kan ikke se nogen vanskeligheder. 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."

"Godt, godt. Lad os nu omdøbe vores variabler 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 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, variabler eller udtryk.

"Efter at vi har omdøbt variablerne i hovedmetoden, har intet ændret sig. De var forskellige variabler i forskellige metoder tidligere, og så forbliver de. Der er ingen magisk sammenhæng mellem de to textvariable."

"Nu ved jeg."

Videregivelse af referencer til metoder

"Jeg håber, du allerede har assimileret alt, hvad jeg har fortalt dig om at overføre argumenter til metoder. Det siger jeg, for nu skal vi dykke lidt dybere ned i dette emne. Lyt godt efter."

"Du ved allerede, at nogle variabler i Java ikke gemmer selve værdierne, men i stedet en reference , altså adressen på den hukommelsesblok, hvor værdierne er placeret. Sådan fungerer strengvariabler og arrayvariabler.

"Når en udvikler tildeler en anden array-variabel til en array-variabel, hvad sker der så?"

"Piger de så på samme adresse?"

"Korrekt. 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 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øjagtig det samme sker: dataparameteren vil indeholde en reference til det samme hukommelsesområde som monthsvariablen. Når metoden kaldes, opstår der en simpel tildeling: .data = months

"Og da begge variabler refererer til det samme område af hukommelsen, der lagrer et heltal, så sumkan metoden ikke kun læse værdier fra arrayet, men også ændre dem!"

"Jeg forstår det, men jeg har brug for flere eksempler!"

"Nå, 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);
   }
}

Metoder med samme navn

"Lad os nu vende tilbage til metodenavnene igen."

"Jeg kan ikke forestille mig, hvad der ellers kunne siges om navne!"

"Java sprogstandarden kræver, at alle metoder i samme klasse har unikke navne.

"Så det er umuligt at erklære to identisk navngivne metoder i samme klasse?"

"Nu – vær meget opmærksom! Metoder i en klasse kan ganske rigtigt have identiske navne! Men i dette tilfælde skal de have forskellige parametre. Med andre ord sammenlignes metoder for ensartethed, der tages ikke kun hensyn til navnene, men også parametrenes typer ! Bemærk, at jeg specifikt nævnte typer. Navnene på parametrene er ikke taget 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) {
}

"Jeg er fuldstændig forvirret! Hvorfor har vi brug for alt dette? Hvorfor betragtes nogle metoder som ens , mens andre er forskellige ? Og hvorfor tages der ikke højde for parameternavne, når man bestemmer en metodes unikke karakter? Hvorfor er unikhed nødvendig ved alle?"

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

"Hvis du for eksempel skriver , er compileren smart og vil nemt konkludere, at du har tænkt dig at kalde metoden her med en parameter. Men hvis du skriver , vil compileren se et kald til metoden med en parameter. Den aner ikke hvilket navn programmøren gav til parameteren, da han erklærede metoden."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, det ser ud til at begynde at komme igennem!

"Når en metode kaldes, sikrer compileren, at typerne af argumenterne matcher parametrenes typer. Den er ikke opmærksom på navnet på argumenterne. I Java hjælper parameternavne ikke compileren med at bestemme, hvilken metode der skal Programmører har brug for dem, ikke compileren.

"Og jeg gætter på, at det er derfor, de ikke tages i betragtning, når man skal afgøre, om en metode er unik?"

"Ja, det er helt korrekt. Navnet på en metode og typerne af dens parametre kaldes metodesignaturen . For eksempel, sum (int, int)"

"Så hver klasse skal have metoder med unikke signaturer i stedet for metoder med unikke navne."

"Godt gået, Amigo! Du opsummerede denne lektion perfekt. Hvis noget forbliver uklart, skal du ikke gå i panik. Dette emne vil blive klart efter et par opgaver."