"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 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."
– 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:
Kód | Magyarázat |
---|---|
|
A print metódus egy paraméterrel van deklarálva:String str |
|
A print metódus két paraméterrel van deklarálva:String str int count |
|
A write metódus két paraméterrel van deklarálva: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:
Kód | Magyarázat |
---|---|
|
printLines A metódust a következő paraméterekkel deklaráltuk : String text , int count A metódus karakterlánc- text count időket jelenít meg. A metódust különböző paraméterekkel hívjuk printLines |
„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:
Kód | Magyarázat |
---|---|
|
printLines A metódust a következő paraméterekkel deklaráltuk : String text , int count A metódus karakterlánc- text count időket jelenít meg A metódust a következő argumentumokkal hívjuk meg : printLines text = "Hi"; count = 10; text = "Bye"; count = 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 printLines
mó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 20
magukat 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:
Kód | Magyarázat |
---|---|
|
printLines A metódust a következő paraméterekkel deklaráltuk : String text , int count A metódus karakterlánc- text count időket jelenít meg A metódust a következő argumentumokkal hívjuk meg : printLines text = str; count = n; |
"Hmm... nem látok semmi nehézséget. Van egy változónk. Ennek értéke a metódus meghívásakor str
van 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.text
n
count
"Jó, jó. Most nevezzük át a változóinkat a metódusban main
:
Kód | Magyarázat |
---|---|
|
printLines A metódust a következő paraméterekkel deklaráltuk : String text , int count A metódus karakterlánc- text count időket jelenít meg A metódust a következő argumentumokkal hívjuk meg : printLines text = text; count = 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 main
szereplő 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?
Kód | Magyarázat |
---|---|
|
A sum módszer kiszámítja az átadott tömbben lévő számok összegét, és megjeleníti a képernyőn |
"Pontosan ugyanez történik: a data
paraméter ugyanarra a memóriaterületre fog hivatkozni, mint a months
vá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 sum
metó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:
Kód | Magyarázat |
---|---|
|
A fill metódus az átadott kétdimenziós tömb minden celláján iterál, és hozzárendeli value őket. Létrehozunk egy kétdimenziós tömböt. A teljes tömböt kitöltjük a számmal 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:
Kód | Magyarázat |
---|---|
|
Ez a három módszer különböző módszer. Ugyanabban az osztályban deklarálhatók. |
|
Ezen öt módszer mindegyike eltérő . Ugyanabban az osztályban deklarálhatók. |
|
"Ez a két metódus azonosnak tekinthető , vagyis nem deklarálhatók ugyanabban az osztályban." |
"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()
String
System.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."
GO TO FULL VERSION