Mga parameter ng pamamaraan sa Java

"Kumusta Amigo! Sana ay nasiyahan ka sa paglutas ng mga gawain gamit ang sarili mong mga pamamaraan, at napagtanto mo kung gaano kaginhawang gumawa ng mga pamamaraan. Ngayon ay pag-usapan natin ang pinakakawili-wiling paksa sa lahat."

"Napukaw mo ang interes ko, Diego... Isang bagong paksa?"

"Ang bawat paksa ay bago para sa iyo, aking batang robot! At ang isang ito ay walang pagbubukod. Bagama't muli ito ay tungkol sa mga pamamaraan. Malamang na napansin mo na mula sa mga pamamaraan tulad na maaari nating ipasa ang mga argumento sa mga pamamaraan. Kapag tayo ay nasa loob ng pamamaraan System.out.println(). , tinutukoy namin ang mga ito bilang mga parameter."

"Mga parameter ang isinusulat natin sa loob ng panaklong?"

"Oo, eksakto. At, sa katunayan, ang mga parameter ay lubos na nagpapahusay sa mga benepisyong nakukuha natin sa paggawa at paggamit ng mga pamamaraan."

"Nakukuha ko ang sinasabi mo tungkol sa paggamit sa mga ito, at lumalabas na nagawa ko na ito. Paano tayo magdedeklara ng paraan na may mga parameter?"

"Ito ay talagang medyo simple:

public static void name(parameters)
{
  method body
}

"Nasaan nameang natatanging pangalan ng pamamaraan at method bodykumakatawan sa mga utos na bumubuo sa pamamaraan. At parametersisang placeholder para sa mga parameter ng pamamaraan, na pinaghihiwalay ng mga kuwit."

"Hmm... I think naiintindihan ko na... Or maybe not..."

"Hayaan akong magbigay sa iyo ng ilang higit pang mga detalye tungkol sa template na ito para sigurado ka na naiintindihan mo na naiintindihan mo:

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

Narito ang ilang halimbawa:

public static void print(String str)
{
}

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

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

"Ah... Ngayon malinaw na. At kung ayaw nating magkaroon ng mga parameter ang pamamaraan, iiwan na lang nating walang laman ang mga panaklong."

"Eksakto. Talaga, ang mga parameter ay mga espesyal na variable sa loob ng isang pamamaraan. Sa tulong nila, maaari mong ipasa ang iba't ibang mga halaga sa pamamaraan kapag ito ay tinawag. At kung hindi mo kailangang ipasa ang mga halaga, pagkatapos ay iiwan mong walang laman ang mga panaklong.

"Halimbawa, magsulat tayo ng isang paraan na nagpapakita ng isang linya ng teksto sa isang naibigay na bilang ng beses. Anumang mga iniisip kung paano ito gagawin?"

"Well... Mukhang alam ko na kung paano magsulat ng code para magpakita ng string sa screen ng ilang beses..."

"Paano mo tinukoy ang string na ipapakita? At paano mo tinukoy ang bilang ng mga ipinapakitang linya? Maaari mo bang hulaan?"

"Nagsisimula nang maging malinaw ang mga bagay... Marahil sa tulong ng mga parameter ng pamamaraan?"

"Eksakto. Isang string na parameter para sa linya ng text, at isang numeric na parameter para sa bilang ng mga ipinapakitang linya. Ang code na gagawa nito ay magiging ganito:

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

"Sa tuwing tatawagin ang isang pamamaraan, ang mga parameter nito ay itinalaga ang mga naipasa na halaga, at pagkatapos lamang natin sisimulan na isagawa ang mga utos sa loob ng pamamaraan.

Mga argumento

"Nais kong bigyan mo ng espesyal na pansin ang mga pamamaraan ng pagtawag na may mga parameter. Ang mga halaga na ipinasa sa pamamaraan ay karaniwang tinatawag na mga argumento kapag ipinasa ang mga ito sa pamamaraan.

Tingnan natin ang isa pang halimbawa:

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

"Kapag printLinestinawag ang pamamaraan sa unang pagkakataon, ang mga parameter nito ay itinalaga ng mga sumusunod na halaga:

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

"Kapag printLinestinawag ang pamamaraan sa pangalawang pagkakataon, ang mga parameter nito ay itinalaga ng iba't ibang mga halaga:

String text = "Bye", int count = 20.

"Ang mga parameter ay hindi hihigit at hindi bababa sa mga variable na itinalaga ng ilang partikular na halaga kapag tinawag ang isang paraan. Ang mga halaga "Hi", "Bye", 10, at 20ang kanilang mga sarili ay tinatawag na mga argumento."

"Susubukan kong tandaan ang pagkakaiba at hindi malito ang mga konseptong ito."

Mga salungat na pangalan ng variable kapag tumatawag sa isang paraan

"Kapag tumawag ka ng isang pamamaraan, maaari mong gamitin ang mga variable bilang mga argumento.

"Well, iyon ang akma!"

"Ito ay makatuwiran, ngunit maaari itong magdulot ng ilang mga paghihirap. Bumalik tayo sa ating halimbawa muli, ngunit sa pagkakataong ito ay ililipat natin ang mga argumento sa magkakahiwalay na mga variable:

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... I don't see any difficulties. We have a strvariable. Its value is assigned to the textparameter when the method is called. We have an nvariable. Its value is assigned to the countparameter when the method is called." "So far, malinaw na ang lahat."

"Mabuti, mabuti. Ngayon, palitan natin ang pangalan ng ating mga variable sa mainpamamaraan:

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

"Pagtuunan mo ng pansin ang dalawang bagay

Una: mayroon kaming mga variable na may parehong pangalan sa iba't ibang mga pamamaraan. Ito ay iba't ibang mga variable (sinasadya naming ilarawan ang mga ito gamit ang iba't ibang kulay). Ang lahat ay gumagana katulad ng sa nakaraang halimbawa, kung saan ang mga variable sa mainpamamaraan ay pinangalanan strat n.

Pangalawa: Walang mahiwagang nangyayari kapag tinawag ang pamamaraan. Ang mga parameter ay itinalaga lamang ang mga halaga ng argumento. Hindi alintana kung ang mga ito ay mga numero, string, variable, o expression.

"Pagkatapos naming palitan ang pangalan ng mga variable sa pangunahing pamamaraan, walang nagbago. Sila ay iba't ibang mga variable sa iba't ibang mga pamamaraan dati, at kaya nananatili sila. Walang magic na koneksyon sa pagitan ng dalawang textvariable."

"Ngayon alam ko na."

Pagpasa ng mga sanggunian sa mga pamamaraan

"Sana na-assimilate mo na ang lahat ng sinabi ko sa iyo tungkol sa pagpasa ng mga argumento sa mga pamamaraan. Sinasabi ko iyan, dahil mas malalim na ang ating gagawin ngayon sa paksang ito. Makinig kang mabuti."

"Alam mo na na ang ilang mga variable sa Java ay hindi nag-iimbak ng mga halaga mismo, ngunit sa halip ay isang reference , ibig sabihin, ang address ng bloke ng memorya kung saan matatagpuan ang mga halaga. Ito ay kung paano gumagana ang mga string variable at array variable.

"Kapag ang isang developer ay nagtalaga ng isa pang array variable sa isang array variable, ano ang mangyayari?"

"Do they then point at the same address?"

"Tama. Nagsisimulang tumukoy ang dalawang variable sa parehong espasyo sa memorya:

"At ano ang mangyayari kung ang isa sa mga variable na ito ay isang parameter ng pamamaraan?

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

"Eksaktong parehong bagay ang mangyayari: ang dataparameter ay maglalaman ng isang reference sa parehong lugar ng memorya bilang monthsvariable. Kapag ang pamamaraan ay tinawag, isang simpleng pagtatalaga ay magaganap: .data = months

"At dahil ang parehong mga variable ay tumutukoy sa parehong lugar ng memorya na nag-iimbak ng isang integer, kung gayon ang sumpamamaraan ay hindi lamang maaaring magbasa ng mga halaga mula sa array, ngunit baguhin din ang mga ito!"

"Naiintindihan ko yata, pero kailangan ko ng higit pang mga halimbawa!"

"Buweno, halimbawa, maaari tayong sumulat ng sarili nating pamamaraan na pumupuno sa isang two-dimensional na array na may parehong halaga. Ganito ang hitsura nito:

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

Mga pamamaraan na may parehong pangalan

"Ngayon, bumalik tayo sa mga pangalan ng pamamaraan muli."

"Hindi ko maisip kung ano pa ang masasabi tungkol sa mga pangalan!"

"Buweno, ang pamantayan ng wikang Java ay nangangailangan ng lahat ng mga pamamaraan sa parehong klase na magkaroon ng mga natatanging pangalan.

"Kaya, imposibleng magdeklara ng dalawang magkatulad na pangalang pamamaraan sa parehong klase?"

"Ngayon — bigyang pansin! Ang mga pamamaraan sa isang klase ay maaaring magkaroon ng magkatulad na mga pangalan! Ngunit sa kasong ito, dapat silang magkaroon ng iba't ibang mga parameter. Sa madaling salita, ang mga pamamaraan ay inihambing para sa pagkakapareho, hindi lamang ang mga pangalan ay isinasaalang-alang, kundi pati na rin ang mga uri ng mga parameter ! Tandaan na partikular kong sinabi ang mga uri. Ang mga pangalan ng mga parameter ay hindi isinasaalang-alang . Mga halimbawa:

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

"Ako ay lubos na nalilito! Bakit kailangan natin ang lahat ng ito? Bakit ang ilang mga pamamaraan ay itinuturing na pareho , habang ang iba ay iba ? At bakit ang mga pangalan ng parameter ay hindi isinasaalang-alang kapag tinutukoy ang pagiging natatangi ng isang pamamaraan? Bakit kailangan ang pagiging natatangi sa lahat?"

"Ang bagay ay kapag ang compiler ay nag-compile ng isang programa, dapat itong malaman nang eksakto kung aling paraan ang balak mong tawagan sa anumang lugar.

"Halimbawa, kung isusulat mo , matalino ang compiler at madaling mag-conclude na balak mong tawagan ang method dito na may parameter. Pero kung isusulat mo , makakakita ang compiler ng tawag sa method na may parameter. Wala itong ideya anong pangalan ang ibinigay ng programmer sa parameter kapag idineklara ang pamamaraan."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, parang nagsisimula nang makalusot!

"Kapag tinawag ang isang pamamaraan, tinitiyak ng compiler na ang mga uri ng argumento ay tumutugma sa mga uri ng mga parameter. Hindi nito binibigyang pansin ang pangalan ng mga argumento. Sa Java, ang mga pangalan ng parameter ay hindi nakakatulong sa compiler na matukoy kung aling paraan ang Kailangan sila ng mga programmer, hindi ang compiler.

"At sa palagay ko iyon ang dahilan kung bakit hindi sila isinasaalang-alang kapag tinutukoy ang pagiging natatangi ng isang pamamaraan?"

"Oo, iyon ay ganap na tama. Ang pangalan ng isang pamamaraan at ang mga uri ng mga parameter nito ay tinatawag na lagda ng pamamaraan . Halimbawa, sum (int, int)"

"Kaya ang bawat klase ay dapat magkaroon ng mga pamamaraan na may natatanging mga lagda sa halip na mga pamamaraan na may natatanging mga pangalan."

"Magaling, Amigo! Naisa-isa mo ang aralin na ito nang perpekto. Kung may nananatiling hindi malinaw, huwag mag-panic. Magiging malinaw ang paksang ito pagkatapos ng ilang gawain."