Metodparametrar i Java

"Hej Amigo! Jag hoppas att du tyckte om att lösa uppgifter med dina egna metoder och att du inser hur bekvämt det är att skapa metoder. Låt oss nu prata om det mest intressanta ämnet av alla."

"Du har väckt mitt intresse, Diego... Ett nytt ämne?"

"Varje ämne är nytt för dig, min unga robot! Och det här är inget undantag. Även om det återigen handlar om metoder. Du har säkert redan märkt från metoder som att vi kan överföra argument till metoder. När vi väl är inne i System.out.println()metoden , vi hänvisar till dem som parametrar."

"Parametrar är vad vi skriver inom parentesen?"

"Ja, precis. Och faktiskt, parametrar förstärker avsevärt fördelarna vi får av att skapa och använda metoder."

"Jag förstår vad du säger om att använda dem, och det visar sig att jag redan har gjort det. Hur deklarerar vi en metod med parametrar?"

"Det är faktiskt ganska enkelt:

public static void name(parameters)
{
  method body
}

"Var namefinns det unika namnet på metoden och method bodyrepresenterar de kommandon som utgör metoden. Och parametersär en platshållare för metodparametrarna, separerade med kommatecken."

"Hmm... jag tror jag förstår... Eller kanske inte..."

"Låt mig ge dig lite mer information om den här mallen så att du är säker på att du förstår att du förstår:

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

Här är några exempel:

public static void print(String str)
{
}

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

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

"Ah... Nu är det klart. Och om vi inte vill att metoden ska ha parametrar så lämnar vi bara parenteserna tomma."

"Precis. I grund och botten är parametrar speciella variabler inom en metod. Med deras hjälp kan du skicka olika värden till metoden när den anropas. Och om du inte behöver skicka värden så lämnar du parenteserna tomma.

"Låt oss till exempel skriva en metod som visar en given textrad ett givet antal gånger. Några tankar om hur man gör detta?"

"Tja... Det verkar som att jag är väl medveten om hur man skriver kod för att visa en sträng på skärmen flera gånger..."

"Hur anger du strängen som ska visas? Och hur anger du antalet visade rader? Kan du gissa?"

"Det börjar bli klart... Förmodligen med hjälp av metodparametrar?"

"Exakt. En strängparameter för textraden och en numerisk parameter för antalet visade rader. Koden som gör detta skulle se ut så här:

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);
   }
}

"Varje gång en metod anropas tilldelas dess parametrar de godkända värdena, och först då börjar vi utföra kommandona i metoden.

Argument

"Jag vill att du ska vara särskilt uppmärksam på att anropa metoder som har parametrar. De värden som skickas till metoden brukar kallas för argument när de skickas till metoden.

Låt oss ta en ny titt på vårt exempel:

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);
   }
}

"När printLinesmetoden anropades för första gången tilldelades dess parametrar följande värden:

String text = "Hi", int count = 10.

"När printLinesmetoden anropades andra gången tilldelades dess parametrar olika värden:

String text = "Bye", int count = 20.

"Parametrar är varken mer eller mindre än variabler som tilldelas vissa värden när en metod anropas. Värdena , , , "Hi"och "Bye"kallas 10i 20sig argument."

"Jag ska försöka komma ihåg skillnaden och inte blanda ihop dessa begrepp."

Variabelnamn som står i konflikt när en metod anropas

"När du anropar en metod kan du använda variabler som argument.

"Ja, det är vettigt!"

"Det är vettigt, men det kan potentiellt skapa vissa svårigheter. Låt oss gå tillbaka till vårt exempel igen, men den här gången flyttar vi argumenten till separata 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... Jag ser inga svårigheter. Vi har en strvariabel. Dess värde tilldelas parametern textnär metoden anropas. Vi har en nvariabel. Dess värde tilldelas parametern countnär metoden anropas." "Än så länge är allt klart."

"Bra, bra. Låt oss nu byta namn på våra variabler i metoden main:

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);
   }
}

"Var uppmärksam på två saker

För det första: vi har variabler med samma namn i olika metoder. Det här är olika variabler (vi avbildar dem medvetet med olika färger). Allt fungerar på samma sätt som i föregående exempel, där variablerna i mainmetoden hette stroch n.

För det andra: Inget magiskt händer när metoden anropas. Parametrarna tilldelas helt enkelt argumentvärdena. Oavsett om de är tal, strängar, variabler eller uttryck.

"Efter att vi döpt om variablerna i huvudmetoden har ingenting förändrats. De var olika variabler i olika metoder tidigare, och så finns de kvar. Det finns inget magiskt samband mellan de två textvariablerna."

"Nu vet jag."

Skicka referenser till metoder

"Jag hoppas att du redan har assimilerat allt jag har berättat om att föra över argument till metoder. Jag säger det, för nu ska vi dyka lite djupare in i det här ämnet. Lyssna noga."

"Du vet redan att vissa variabler i Java inte lagrar själva värdena, utan istället en referens , dvs adressen till minnesblocket där värdena finns. Så fungerar strängvariabler och arrayvariabler.

"När en utvecklare tilldelar en annan arrayvariabel till en arrayvariabel, vad händer?"

"Pekar de då på samma adress?"

"Korrekt. De två variablerna börjar hänvisa till samma utrymme i minnet:

"Och vad händer om en av dessa variabler är en metodparameter?

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);
   }
}

"Exakt samma sak händer: dataparametern kommer att innehålla en referens till samma minnesområde som monthsvariabeln. När metoden anropas sker en enkel tilldelning: .data = months

"Och eftersom båda variablerna refererar till samma område i minnet som lagrar ett heltal, så sumkan metoden inte bara läsa värden från matrisen, utan också ändra dem!"

"Jag antar att jag förstår, men jag behöver fler exempel!"

"Tja, till exempel kan vi skriva vår egen metod som fyller en tvådimensionell array med samma värde. Så här 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 samma namn

"Låt oss nu återgå till metodnamnen igen."

"Jag kan inte föreställa mig vad mer man kan säga om namn!"

"Ja, Java-språkstandarden kräver att alla metoder i samma klass har unika namn.

"Så, det är omöjligt att deklarera två identiskt namngivna metoder i samma klass?"

"Nu — var uppmärksam! Metoder i en klass kan verkligen ha identiska namn! Men i det här fallet måste de ha olika parametrar. Med andra ord, metoder jämförs för likhet, inte bara tas hänsyn till namnen, utan också typerna av parametrar ! Observera att jag specifikt sa typer. Namnen på parametrarna beaktas inte . Exempel:

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) {
}

"Jag är helt förvirrad! Varför behöver vi allt detta? Varför anses vissa metoder vara lika , medan andra är olika ? Och varför beaktas inte parameternamn när man bestämmer hur unik en metod är? Varför är unikhet nödvändig vid Allt?"

"Saken är att när kompilatorn kompilerar ett program måste den veta exakt vilken metod du tänker anropa på en given plats.

"Om du till exempel skriver , är kompilatorn smart och kommer lätt att dra slutsatsen att du tänker anropa metoden här med en parameter. Men om du skriver , kommer kompilatorn att se ett anrop till metoden med en parameter. Den har ingen aning om vilket namn programmeraren gav parametern när metoden deklarerades."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, det verkar börja gå igenom!

"När en metod anropas säkerställer kompilatorn att typerna av argument matchar parametrarnas typer. Den uppmärksammar inte namnet på argumenten. I Java hjälper inte parameternamn kompilatorn att avgöra vilken metod som ska Programmerare behöver dem, inte kompilatorn.

"Och jag antar att det är därför de inte tas med i beräkningen när man avgör en metods unika karaktär?"

"Ja, det är helt korrekt. Namnet på en metod och typerna av dess parametrar kallas metodsignaturen . Till exempel sum (int, int)"

"Så varje klass måste ha metoder med unika signaturer snarare än metoder med unika namn."

"Bra gjort, Amigo! Du sammanfattade den här lektionen perfekt. Om något är oklart, få inte panik. Detta ämne kommer att bli klart efter ett par uppgifter."