Metodparametrar i Java

1. Förbigående argument

Och nu börjar det roliga. Du vet säkert redan från sådana metoder System.out.println()att vi kan överföra argument till metoder. När vi väl är inne i metoden hänvisar vi till dem som parametrar. Faktum är att parametrar avsevärt förbättrar fördelarna vi får av att skapa och använda metoder.

Hur deklarerar vi en metod med parametrar? Det är faktiskt ganska enkelt:

public static void name(parameters)
{
  method body
}

Var name är det unika namnet på metoden och method body representerar de kommandon som utgör metoden. Och parameters är en platshållare för metodparametrarna, separerade med kommatecken. Låt oss beskriva denna mall mer detaljerat:

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

Exempel:

public static void print(String str)
{
}

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

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

Om vi ​​inte vill att metoden ska ha parametrar så lämnar vi bara parenteserna tomma.

Parametrar är speciella variabler inom en metod. Med deras hjälp kan du skicka olika värden till metoden när den anropas.

Låt oss till exempel skriva en metod som visar en textsträng ett givet antal gånger.

Du vet redan hur man skriver kod för att visa en sträng på skärmen flera gånger. Men vilken sträng ska du skriva ut? Och hur många gånger? Det är vad vi behöver parametrarna för.

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.

2. Argument

Jag skulle vilja uppmärksamma er lite mer på att kalla en metod med parametrar.

De värden som skickas till metoden brukar kallas argument när de skickas till metoden.

Låt oss titta på ett annat 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 printLines metoden 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", "Bye", 10och 20kallas själva argument."

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

Variabler kan användas som metodargument. Detta är enkelt och förståeligt, men det kan potentiellt orsaka vissa svårigheter. Låt oss gå tillbaka till samma exempel, 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";
     int n = 10;
     printLines(str, n);
   }
}

Så långt, så bra: 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." Hittills är allt klart.

Låt oss nu döpa om våra 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";
     int 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 bytt namn på variablerna i huvudmetoden har ingenting förändrats. De var olika variabler i olika metoder tidigare, och så förblir de. Det finns ingen magisk koppling mellan  variablerna text och .text

4. Skicka referenser till metoder

Jag hoppas att du förstod allt från förra lektionen, för nu ska vi återkomma till övergående argument till metoder, bara vi kommer att dyka djupare.

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

Vad händer när du tilldelar en annan arrayvariabel till en arrayvariabel? Det är rätt. 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 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);
   }
}

Exakt samma sak händer: data parametern kommer att innehålla en referens till samma minnesområde som variabeln months. När metoden anropas uppstår en enkel uppgift: .data = months

Och eftersom båda variablerna hänvisar till samma område i minnet som lagrar ett heltal, printArraySum kan metoden inte bara läsa värden från arrayen, utan också ändra dem!

Till exempel kan vi skriva en 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);
   }
}

5. Metoder med samma namn

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

Java-standarder kräver att alla metoder i samma klass har unika namn. Med andra ord är det omöjligt att deklarera två identiskt namngivna metoder i samma klass.

När metoder jämförs med avseende på likhet beaktas inte bara namnen utan även parametrarnas typer ! Observera att namnen på parametrarna inte tas med i beräkningen . 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) {
}

Varför anses vissa metoder vara lika , medan andra är olika ? Och varför beaktas inte parameternamn när man bestämmer en metods unika karaktär?

Varför behövs det unika överhuvudtaget? Saken är den att när kompilatorn kompilerar ett program måste den veta exakt vilken metod du tänker anropa på vilken plats som helst.

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.System.out.println("Hi")println()String

Men om du skriver kommer kompilatorn att se ett anrop till metoden med en parameter.System.out.println(1.0)println()double

När en metod anropas ser kompilatorn till att typerna av argument matchar parametrarnas typer. Det ägnar ingen uppmärksamhet åt namnet på argumenten. I Java hjälper inte parameternamn kompilatorn att avgöra vilken metod som ska anropas. Och det är därför de inte tas med i beräkningen när man bestämmer unikheten hos en metod.

Namnet på en metod och typerna av dess parametrar kallas metodsignaturen . Till exempel,sum(int, int)

Varje klass måste ha metoder med unika signaturer snarare än metoder med unika namn.