Methodeparameters in Java

1. Argumenten doorgeven

En nu begint het plezier. Je weet waarschijnlijk al van methoden zoals System.out.println()dat we argumenten kunnen doorgeven aan methoden. Als we eenmaal binnen de methode zijn, noemen we ze parameters. In feite vergroten parameters enorm de voordelen die we halen uit het creëren en gebruiken van methoden.

Hoe declareren we een methode met parameters? Het is eigenlijk heel simpel:

public static void name(parameters)
{
  method body
}

Waar name is de unieke naam van de methode en method body vertegenwoordigt de opdrachten waaruit de methode bestaat. En parameters is een tijdelijke aanduiding voor de parameters van de methode, gescheiden door komma's. Laten we deze sjabloon in meer detail beschrijven:

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

Voorbeelden:

public static void print(String str)
{
}

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

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

Als we niet willen dat de methode parameters heeft, laten we de haakjes gewoon leeg.

Parameters zijn speciale variabelen binnen een methode. Met hun hulp kunt u verschillende waarden doorgeven aan de methode wanneer deze wordt aangeroepen.

Laten we bijvoorbeeld een methode schrijven die een reeks tekst een bepaald aantal keren weergeeft.

Je weet al hoe je code moet schrijven om een ​​string meerdere keren op het scherm weer te geven. Maar welke string moet je printen? En hoe vaak? Daar hebben we de parameters voor nodig.

De code die dit doet, ziet er als volgt uit:

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

Elke keer dat een methode wordt aangeroepen, krijgen de parameters de doorgegeven waarden toegewezen en pas dan beginnen we met het uitvoeren van de opdrachten binnen de methode.

2. Argumenten

Ik zou uw aandacht wat meer willen vestigen op het aanroepen van een methode met parameters.

De waarden die aan de methode worden doorgegeven, worden gewoonlijk argumenten genoemd wanneer ze aan de methode worden doorgegeven.

Laten we nog een voorbeeld bekijken:

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

Toen de printLines methode voor het eerst werd aangeroepen, kregen de parameters de volgende waarden toegewezen:
String text = "Hi", int count = 10.

Toen de printLinesmethode voor de tweede keer werd aangeroepen, kregen de parameters verschillende waarden toegewezen:
String text = "Bye", int count = 20.

Parameters zijn niet meer en niet minder dan variabelen waaraan bepaalde waarden worden toegekend wanneer een methode wordt aangeroepen. De waarden "Hi", "Bye", 10, en 20worden zelf argumenten genoemd."

3. Conflicterende namen van variabelen bij het aanroepen van een methode

Variabelen kunnen worden gebruikt als methodeargumenten. Dit is eenvoudig en begrijpelijk, maar het kan mogelijk problemen opleveren. Laten we teruggaan naar hetzelfde voorbeeld, maar deze keer verplaatsen we de argumenten naar afzonderlijke variabelen:

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

Tot nu toe gaat het goed: we hebben een strvariabele. De waarde wordt toegewezen aan de textparameter wanneer de methode wordt aangeroepen. We hebben een nvariabele. De waarde ervan wordt toegewezen aan de countparameter wanneer de methode wordt aangeroepen." Tot nu toe is alles duidelijk.

Laten we nu onze variabelen hernoemen in de mainmethode:

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

Let op twee dingen

Ten eerste: we hebben variabelen met dezelfde naam in verschillende methoden. Dit zijn verschillende variabelen (we geven ze bewust weer met verschillende kleuren). Alles werkt hetzelfde als in het vorige voorbeeld, waar de variabelen in de methode de naam and mainkregen .strn

Ten tweede: er gebeurt niets magisch als de methode wordt aangeroepen. Aan de parameters worden eenvoudigweg de argumentwaarden toegewezen. Ongeacht of het getallen, strings, variabelen of uitdrukkingen zijn.

Nadat we de variabelen in de hoofdmethode een andere naam hebben gegeven, is er niets veranderd. Het waren voorheen verschillende variabelen in verschillende methoden , en dat blijven ze. Er is geen magisch verband tussen de variabelen text en text .

4. Verwijzingen naar methoden doorgeven

Ik hoop dat je alles van de vorige les hebt begrepen, want nu gaan we het doorgeven van argumenten naar methoden opnieuw bekijken, alleen gaan we dieper.

Zoals u al weet, slaan sommige Java-variabelen niet de waarden zelf op, maar in plaats daarvan een referentie, dwz het adres van het geheugenblok waar de waarden zich bevinden. Dit is hoe stringvariabelen en arrayvariabelen werken.

Wat gebeurt er als u een andere arrayvariabele toewijst aan een arrayvariabele? Dat is juist. De twee variabelen beginnen te verwijzen naar dezelfde ruimte in het geheugen:

En wat gebeurt er als een van deze variabelen een methodeparameter is?

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

Precies hetzelfde gebeurt: de data parameter bevat een verwijzing naar hetzelfde geheugengebied als de monthsvariabele. Wanneer de methode wordt aangeroepen, vindt er een eenvoudige toewijzing plaats: .data = months

En aangezien beide variabelen verwijzen naar hetzelfde geheugengebied waarin een geheel getal is opgeslagen, printArraySum kan de methode niet alleen waarden uit de array lezen, maar deze ook wijzigen!

We kunnen bijvoorbeeld onze eigen methode schrijven die een tweedimensionale array met dezelfde waarde vult. Dit is hoe het eruit zou kunnen zien:

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. Methoden met dezelfde naam

Laten we nu nog een keer teruggaan naar de namen van methoden.

Java-standaarden vereisen dat alle methoden in dezelfde klasse unieke namen hebben. Met andere woorden, het is onmogelijk om twee methoden met dezelfde naam in dezelfde klasse te declareren.

Wanneer methoden worden vergeleken op gelijkheid, wordt niet alleen rekening gehouden met de namen, maar ook met de typen parameters ! Merk op dat er geen rekening wordt gehouden met de namen van de parameters . Voorbeelden:

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

Waarom worden sommige methoden als hetzelfde beschouwd en andere als verschillend ? En waarom wordt er geen rekening gehouden met parameternamen bij het bepalen van de uniciteit van een methode?

Waarom is uniciteit überhaupt nodig? Het punt is dat wanneer de compiler een programma compileert, hij precies moet weten welke methode je op een bepaalde plaats wilt aanroepen.

Als u bijvoorbeeld schrijft , is de compiler slim en zal hij gemakkelijk concluderen dat u van plan bent de methode hier aan te roepen met een parameter.System.out.println("Hi")println()String

Maar als u schrijft , ziet de compiler een aanroep naar de methode met een parameter.System.out.println(1.0)println()double

Wanneer een methode wordt aangeroepen, zorgt de compiler ervoor dat de typen argumenten overeenkomen met de typen parameters. Het besteedt geen aandacht aan de naam van de argumenten. In Java helpen parameternamen de compiler niet om te bepalen welke methode moet worden aangeroepen. En daarom worden ze niet meegenomen bij het bepalen van de uniciteit van een methode.

De naam van een methode en de soorten parameters worden de methodehandtekening genoemd . Bijvoorbeeld,sum(int, int)

Elke klasse moet methoden hebben met unieke handtekeningen in plaats van methoden met unieke namen.