Methodeparameters in Java

"Hallo Amigo! Ik hoop dat je het leuk vond om taken op te lossen met je eigen methoden, en dat je je realiseert hoe handig het is om methoden te creëren. Laten we het nu hebben over het meest interessante onderwerp van allemaal."

'Je hebt mijn interesse gewekt, Diego... Een nieuw onderwerp?'

"Elk onderwerp is nieuw voor jou, mijn jonge robot! En dit is geen uitzondering. Hoewel het weer over methoden gaat. Je hebt waarschijnlijk al gemerkt dat we bij dergelijke methoden argumenten kunnen doorgeven aan methoden. Als we eenmaal binnen de methode System.out.println()zijn , noemen we ze parameters."

"Parameters zijn wat we tussen haakjes schrijven?"

"Ja, precies. En in feite vergroten parameters enorm de voordelen die we halen uit het creëren en gebruiken van methoden."

"Ik begrijp wat je zegt over het gebruik ervan, en het blijkt dat ik het al heb gedaan. Hoe declareren we een methode met parameters?"

"Het is eigenlijk heel simpel:

public static void name(parameters)
{
  method body
}

"Waar nameis de unieke naam van de methode en method bodyvertegenwoordigt de commando's waaruit de methode bestaat. En parametersis een tijdelijke aanduiding voor de methodeparameters, gescheiden door komma's."

"Hmm... ik denk dat ik het begrijp... Of misschien ook niet..."

"Laat me je wat meer details geven over deze sjabloon, zodat je zeker weet dat je begrijpt dat je begrijpt:

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

Hier zijn enkele voorbeelden:

public static void print(String str)
{
}

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

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

"Ah... Nu is het duidelijk. En als we niet willen dat de methode parameters heeft, dan laten we de haakjes gewoon leeg."

"Precies. In wezen zijn parameters speciale variabelen binnen een methode. Met hun hulp kun je verschillende waarden doorgeven aan de methode wanneer deze wordt aangeroepen. En als je geen waarden hoeft door te geven, laat je de haakjes leeg.

"Laten we bijvoorbeeld een methode schrijven die een bepaalde regel tekst een bepaald aantal keren weergeeft. Heb je enig idee hoe je dit kunt doen?"

"Nou... het lijkt erop dat ik goed weet hoe ik code moet schrijven om een ​​string meerdere keren op het scherm weer te geven..."

"Hoe specificeer je de weer te geven string? En hoe specificeer je het aantal weergegeven regels? Kun je raden?"

"Het begint duidelijk te worden... Waarschijnlijk met behulp van methodeparameters?"

"Precies. Een tekenreeksparameter voor de regel tekst en een numerieke parameter voor het aantal weergegeven regels. 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 de opdrachten binnen de methode uit te voeren.

Argumenten

"Ik wil dat je speciale aandacht besteedt aan het aanroepen van methoden die parameters hebben. De waarden die aan de methode worden doorgegeven, worden gewoonlijk argumenten genoemd wanneer ze aan de methode worden doorgegeven.

Laten we nog eens naar ons voorbeeld kijken:

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 printLinesmethode 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 toegewezen wanneer een methode wordt aangeroepen. De waarden "Hi", "Bye", 10, en 20worden zelf argumenten genoemd."

"Ik zal proberen het verschil te onthouden en deze concepten niet door elkaar te halen."

Conflicterende namen van variabelen bij het aanroepen van een methode

"Als je een methode aanroept, kun je variabelen als argumenten gebruiken.

"Nou, dat is logisch!"

"Het is logisch, maar het kan mogelijk problemen opleveren. Laten we nogmaals teruggaan naar ons 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";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... ik zie geen problemen. We hebben een strvariabele. De waarde ervan wordt toegewezen aan de textparameter wanneer de methode wordt aangeroepen. We hebben een nvariabele. De waarde wordt toegewezen aan de countparameter wanneer de methode wordt aangeroepen." "Tot nu toe is alles duidelijk."

"Goed, goed. 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";
     String 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 methodentext , en dat blijven ze. Er is geen magisch verband tussen de twee variabelen."

"Nu weet ik het."

Verwijzingen naar methoden doorgeven

'Ik hoop dat je alles al hebt begrepen wat ik je heb verteld over het doorgeven van argumenten aan methoden. Dat zeg ik, omdat we nu wat dieper op dit onderwerp gaan ingaan. Luister goed.'

"Je weet al dat sommige variabelen in Java niet de waarden zelf opslaan, maar in plaats daarvan een referentie , dat wil zeggen het adres van het geheugenblok waar de waarden zich bevinden. Dit is hoe stringvariabelen en arrayvariabelen werken.

"Wat gebeurt er als een ontwikkelaar een andere arrayvariabele toewijst aan een arrayvariabele?"

"Wijzen ze dan naar hetzelfde adres?"

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

"Precies hetzelfde gebeurt: de dataparameter 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, sumkan de methode niet alleen waarden uit de array lezen, maar ze ook wijzigen!"

"Ik denk dat ik het begrijp, maar ik heb meer voorbeelden nodig!"

"Nou, we kunnen bijvoorbeeld onze eigen methode schrijven die een tweedimensionale array met dezelfde waarde vult. Zo zou het eruit 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);
   }
}

Methoden met dezelfde naam

"Laten we nu nog eens teruggaan naar de namen van methoden."

'Ik kan me niet voorstellen wat er nog meer over namen zou kunnen worden gezegd!'

"Nou, de Java-taalstandaard vereist dat alle methoden in dezelfde klasse unieke namen hebben.

"Dus het is onmogelijk om twee methoden met dezelfde naam in dezelfde klasse te declareren?"

"Nu - let goed op! Methoden in een klasse kunnen inderdaad identieke namen hebben! Maar in dit geval moeten ze verschillende parameters hebben. Met andere woorden, methoden worden vergeleken op gelijkheid, er wordt niet alleen rekening gehouden met de namen, maar ook de types van de parameters !Merk op dat ik specifiek de types zei.Er wordt geen rekening 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) {
}

"Ik ben helemaal in de war! Waarom hebben we dit allemaal nodig? Waarom worden sommige methoden als hetzelfde beschouwd , terwijl andere anders zijn ? En waarom wordt er geen rekening gehouden met parameternamen bij het bepalen van de uniciteit van een methode? Waarom is uniciteit noodzakelijk bij alle?"

"Het punt is dat wanneer de compiler een programma compileert, hij precies moet weten welke methode je op een bepaalde plaats wilt aanroepen.

"Als je bijvoorbeeld schrijft , is de compiler slim en zal hij gemakkelijk concluderen dat je van plan bent de methode hier aan te roepen met een parameter. Maar als je schrijft , ziet de compiler een aanroep naar de methode met een parameter. Hij heeft geen idee welke naam de programmeur aan de parameter heeft gegeven bij het declareren van de methode."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, het lijkt door te dringen!

"Wanneer een methode wordt aangeroepen, zorgt de compiler ervoor dat de typen argumenten overeenkomen met de typen parameters. Er wordt geen aandacht besteed aan de naam van de argumenten. In Java helpen parameternamen de compiler niet om te bepalen welke methode moet worden gebruikt. Programmeurs hebben ze nodig, niet de compiler.

"En ik denk dat ze daarom niet in aanmerking worden genomen bij het bepalen van het unieke karakter van een methode?"

"Ja, dat klopt helemaal. De naam van een methode en de typen van zijn parameters worden de methodehandtekening genoemd . Bijvoorbeeld, sum (int, int)"

"Dus elke klasse moet methoden hebben met unieke handtekeningen in plaats van methoden met unieke namen."

"Goed gedaan, Amigo! Je hebt deze les perfect samengevat. Als er iets onduidelijk blijft, geen paniek. Dit onderwerp zal na een paar taken duidelijk worden."