Metódusparaméterek Java-ban

"Szia Amigo! Remélem, élvezte a feladatok megoldását a saját módszereivel, és rájött, milyen kényelmes módszereket alkotni. Most pedig beszéljünk a legérdekesebb témáról."

– Felkeltette az érdeklődésemet, Diego... Új téma?

"Minden téma új számodra, fiatal robotom! És ez alól ez sem kivétel. Bár ismét a módszerekről van szó. Valószínűleg már észrevetted, hogy az ilyen módszereknél érveket tudunk átadni metódusoknak. Ha már benne vagyunk a System.out.println()módszerben , paraméterként hivatkozunk rájuk."

"A paramétereket a zárójelbe írjuk?"

"Igen, pontosan. És 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."

"Értem, hogy mit mondasz a használatukról, és kiderül, hogy már megtettem. Hogyan deklarálunk egy metódust paraméterekkel?"

"Valójában nagyon egyszerű:

public static void name(parameters)
{
  method body
}

"Hol nametalálható a metódus egyedi neve, és method bodya módszert alkotó parancsokat jelöli. És parametersa metódusparaméterek helyőrzője, vesszővel elválasztva."

– Hmm... azt hiszem, értem... Vagy talán nem...

"Hadd adjak néhány további részletet erről a sablonról, hogy biztos legyen benne, hogy megértette:

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

Íme néhány példa:

public static void print(String str)
{
}

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

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

"Ah... Most már világos. És ha nem akarjuk, hogy a metódusnak legyenek paraméterei, akkor hagyjuk üresen a zárójeleket."

"Pontosan. A paraméterek alapvetően speciális változók egy metóduson belül. Segítségükkel különböző értékeket adhatunk át a metódusnak, amikor meghívják. Ha pedig nem kell értékeket átadni, akkor a zárójeleket üresen hagyjuk.

"Például írjunk egy metódust, ami egy adott szövegsort adott számú alkalommal jelenít meg. Van valami ötleted, hogyan kell ezt csinálni?"

"Nos... Úgy tűnik, jól tudom, hogyan kell kódot írni ahhoz, hogy egy karakterlánc többször is megjelenjen a képernyőn..."

"Hogyan adja meg a megjelenítendő karakterláncot? És hogyan adja meg a megjelenített sorok számát? Kitalálja?"

– Kezdenek világosodni a dolgok... Valószínűleg a metódusparaméterek segítségével?

"Pontosan. Egy karakterlánc-paraméter a szövegsorhoz, és egy numerikus paraméter a megjelenített sorok számára. A kód, amely ezt teszi, í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);
   }
}

„Minden alkalommal, amikor 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.

Érvek

"Azt szeretném, ha különös figyelmet fordítana a paraméterekkel rendelkező metódusok meghívására. A metódusnak átadott értékeket általában argumentumnak nevezik , amikor átadják a metódusnak.

Vessünk még egy pillantást a példánkra:

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 printLinesmetódus első meghívásakor a paraméterei a következő értékeket kapták:

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

"A printLinesmódszer 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 bizonyos értékeket kapnak egy metódus meghívásakor. A , "Hi", "Bye", 10és értékeket 20magukat argumentumnak nevezik."

"Megpróbálok emlékezni a különbségre, és nem keverem össze ezeket a fogalmakat."

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

"A metódus meghívásakor változókat használhat argumentumként.

– Hát ennek van értelme!

"Ez logikus, de potenciálisan nehézségeket okozhat. Térjünk vissza még egyszer a példánkhoz, de ezúttal külön változókba helyezzük át az argumentumokat:

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... nem látok semmi nehézséget. Van egy változónk. Ennek értéke a metódus meghívásakor strvan hozzárendelve a paraméterhez . Van egy változónk. Az értéke a metódus meghívásakor van hozzárendelve a paraméterhez." – Eddig minden világos.textncount

"Jó, jó. 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";
     String 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ő metódusokbantext , és így maradnak. A két változó között nincs varázslatos kapcsolat ."

"Most már tudom."

Hivatkozások átadása a módszerekre

"Remélem, már mindent magába olvasztott, amit az érvek módszerekre való átadásáról mondtam. Azért mondom, mert most egy kicsit mélyebbre fogunk merülni ebben a témában. Figyeljen."

"Már tudja, hogy a Java egyes változói 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- és tömbváltozók.

"Mi történik, ha egy fejlesztő egy másik tömbváltozót rendel egy tömbváltozóhoz?"

– Akkor ugyanarra a címre mutatnak?

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

"Pontosan ugyanez történik: a dataparamé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 summetódus nem csak kiolvasni tud értékeket a tömbből, hanem megváltoztatni is tudja azokat!"

– Azt hiszem, értem, de kellenek még példák!

"Nos, például írhatunk saját metódusunkat, amely egy kétdimenziós tömböt tölt ki ugyanazzal az é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);
   }
}

Azonos nevű módszerek

"Most térjünk vissza még egyszer a metódusnevekhez."

– El sem tudom képzelni, mi mást lehetne még elmondani a nevekről!

"Nos, a Java nyelvi szabvány megköveteli, hogy ugyanabban az osztályban minden metódusnak egyedi neve legyen.

"Szóval lehetetlen deklarálni két azonos nevű metódust ugyanabban az osztályban?"

"Most – nagyon figyelj! Az osztályban lévő metódusoknak valóban lehet azonos neve! De ebben az esetben eltérő paraméterekkel kell rendelkezniük. Más szóval, a metódusokat az azonosság szempontjából hasonlítják össze, nem csak a neveket veszik figyelembe, hanem a paraméterek típusai ! Megjegyzés, hogy konkrétan típusokat mondtam. A paraméterek neveit nem vesszük 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) {
}

"Teljesen össze vagyok zavarodva! Miért van szükségünk erre? Miért tekintenek egyes módszereket azonosnak , míg mások másokat ? És miért nem veszik figyelembe a paraméterneveket egy metódus egyediségének meghatározásakor? Miért van szükség az egyediségre minden?"

"A helyzet az, hogy amikor a fordító lefordí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 a metódus itt egy paraméterrel akarod meghívni . De ha írod , akkor a fordító a metódus hívását fogja látni paraméterrel . Fogalma sincs milyen nevet adott a programozó a paraméternek a metódus deklarálásakor."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, úgy tűnik, kezd átmenni!

"A metódus meghívásakor a fordító gondoskodik arról, hogy az argumentumok típusai megegyezzenek a paraméterek típusával. Nem fordít figyelmet az argumentumok nevére. Java-ban a paraméternevek nem segítik a fordítót annak meghatározásában, hogy melyik metódust használja. A programozóknak van szükségük rájuk, nem a fordítónak.

"És gondolom, ezért nem veszik figyelembe őket egy módszer egyediségének meghatározásakor?"

"Igen, ez teljesen helyes. A metódus nevét és paramétereinek típusait metódus aláírásnak nevezik . Például: sum (int, int)"

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

"Jól van, Amigo! Tökéletesen összefoglaltad ezt a leckét. Ha valami homályos marad, ne ess pánikba. Ez a téma néhány feladat után kiderül."