Metódusparaméterek Java-ban

1. Érvek átadása

És most kezdődik a móka. Valószínűleg már tudja, hogy az ilyen módszerekből System.out.println()átadhatunk argumentumokat metódusoknak. Ha már a metóduson belül vagyunk, akkor paraméterként hivatkozunk rájuk. Valójában a paraméterek nagyban növelik a módszerek létrehozásából és használatából származó előnyöket.

Hogyan deklarálunk egy metódust paraméterekkel? Valójában nagyon egyszerű:

public static void name(parameters)
{
  method body
}

Hol name található a metódus egyedi neve, és method body a módszert alkotó parancsokat jelöli. És parameters a metódusparaméterek helyőrzője, vesszővel elválasztva. Ismertesse ezt a sablont részletesebben:

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

Példák:

public static void print(String str)
{
}

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

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

Ha nem akarjuk, hogy a metódusnak legyenek paraméterei, akkor a zárójeleket hagyjuk üresen.

A paraméterek speciális változók egy metóduson belül. Segítségükkel különböző értékeket adhat át a metódusnak a meghívásakor.

Például írjunk egy metódust, amely adott számú szöveges karakterláncot jelenít meg.

Már tudja, hogyan kell kódot írni, hogy egy karakterlánc többször megjelenjen a képernyőn. De melyik karakterláncot érdemes nyomtatni? És hányszor? Ehhez kellenek a paraméterek.

Az ezt végrehajtó kód így nézne ki:

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

Valahányszor egy metódust meghívunk, a paramétereihez hozzárendeljük az átadott értékeket, és csak ezután kezdjük el végrehajtani a metóduson belüli parancsokat.

2. Érvek

Kicsit jobban felhívnám a figyelmet egy metódus paraméteres meghívására.

A metódusnak átadott értékeket általában argumentumnak nevezik, amikor átadják a metódusnak.

Nézzünk egy másik példát:

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

A printLines metódus első meghívásakor a paraméterei a következő értékeket kapták:
String text = "Hi", int count = 10.

A printLinesmetódus másodszori meghívásakor a paraméterei különböző értékeket kaptak:
String text = "Bye", int count = 20.

A paraméterek nem többek és nem kevesebbek, mint változók, amelyek a metódus meghívásakor bizonyos értékeket kapnak. "Hi"Magukat a , "Bye", 10és értékeket 20érveknek nevezzük."

3. Ütköző változónevek metódus hívásakor

A változók metódus argumentumaként használhatók. Ez egyszerű és érthető, de bizonyos nehézségeket okozhat. Térjünk vissza ugyanahhoz a példához, de ezúttal az argumentumokat külön változókba helyezzük át:

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

Eddig minden rendben: van egy strváltozónk. Értékét a textparaméter a metódus meghívásakor rendeli hozzá. Van egy nváltozónk. Értéke counta metódus meghívásakor van hozzárendelve a paraméterhez." Egyelőre minden világos.

Most nevezzük át a változóinkat a metódusban 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";
     int count = 10;
     printLines(text, count);
   }
}

Két dologra figyelj

Először is: különböző metódusokban azonos nevű változóink vannak. Ezek különböző változók (szándékosan különböző színekkel ábrázoljuk őket). Minden ugyanúgy működik, mint az előző példában, ahol a metódusban mainszereplő változókat strés n.

Másodszor: Semmi varázslatos nem történik a metódus meghívásakor. A paraméterekhez egyszerűen hozzárendeljük az argumentumértékeket. Függetlenül attól, hogy számok, karakterláncok, változók vagy kifejezések.

Miután a fő metódusban átneveztük a változókat, semmi sem változott. Korábban különböző változók voltak a különböző módszerekben , és így maradnak. text A és a változók között nincs mágikus kapcsolat text .

4. Hivatkozások átadása a módszerekre

Remélem, mindent megértett az előző leckéből, mert most újra átnézzük az érvek átadását a módszereknek, csak mélyebbre merülünk.

Amint azt már tudjuk, egyes Java változók nem magukat az értékeket tárolják, hanem egy hivatkozást, azaz annak a memóriablokknak a címét, ahol az értékek találhatók. Így működnek a karakterlánc-változók és a tömbváltozók.

Ha egy tömbváltozóhoz egy másik tömbváltozót rendel, mi történik? Úgy van. A két változó ugyanarra a memóriaterületre kezd hivatkozni:

És mi történik, ha e változók egyike metódusparaméter?

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

Pontosan ugyanez történik: a data paraméter ugyanarra a memóriaterületre fog hivatkozni, mint a monthsváltozó. A metódus meghívásakor egy egyszerű hozzárendelés történik: .data = months

És mivel mindkét változó egy egész számot tároló memóriaterületre vonatkozik, így a printArraySum metódus nem csak kiolvashatja a tömbből az értékeket, hanem megváltoztathatja is azokat!

Például írhatunk saját metódusunkat, amely egy kétdimenziós tömböt tölt ki azonos értékkel. Így nézhet ki:

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. Azonos nevű módszerek

Most pedig térjünk vissza a metódusnevekhez.

A Java szabványok megkövetelik, hogy ugyanabban az osztályban minden metódusnak egyedi neve legyen. Más szavakkal, lehetetlen két azonos nevű metódust deklarálni ugyanabban az osztályban.

Amikor a módszereket azonosságra hasonlítjuk össze, nem csak a neveket veszik figyelembe, hanem a paraméterek típusát is ! Vegye figyelembe, hogy a paraméterek neveit a rendszer nem veszi figyelembe . Példák:

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

Miért tekintenek egyes módszereket azonosnak , míg mások eltérőek ? És miért nem veszik figyelembe a paraméterneveket egy metódus egyediségének meghatározásakor?

Miért kell egyáltalán az egyediség? A helyzet az, hogy amikor a fordító fordít egy programot, pontosan tudnia kell, hogy egy adott helyen melyik metódust kívánja meghívni.

Például, ha azt írod , a fordító okos, és könnyen arra a következtetésre jut, hogy itt egy paraméterrel kívánod meghívni a metódust .System.out.println("Hi")println()String

De ha azt írod , akkor a fordító a metódus hívását fogja látni egy paraméterrel.System.out.println(1.0)println()double

A metódus meghívásakor a fordító biztosítja, hogy az argumentumok típusai megegyezzenek a paraméterek típusával. Nem fordít figyelmet az érvek nevére. Java-ban a paraméternevek nem segítik a fordítót annak meghatározásában, hogy melyik metódust hívja meg. És ezért ezeket nem veszik figyelembe egy módszer egyediségének meghatározásakor.

A metódus nevét és paramétereinek típusait metódus aláírásnak nevezzük . Például,sum(int, int)

Minden osztálynak egyedi aláírású metódusokkal kell rendelkeznie, nem pedig egyedi névvel.