Mga parameter ng pamamaraan sa Java

1. Pagpasa ng mga argumento

At ngayon magsisimula ang saya. Malamang na alam mo na mula sa mga pamamaraang tulad nito System.out.println()na maaari naming ipasa ang mga argumento sa mga pamamaraan. Kapag nasa loob na tayo ng pamamaraan, tinutukoy natin ang mga ito bilang mga parameter. Sa katunayan, lubos na pinapahusay ng mga parameter ang mga benepisyong nakukuha natin sa paggawa at paggamit ng mga pamamaraan.

Paano namin idedeklara ang isang pamamaraan na may mga parameter? Ito ay talagang medyo simple:

public static void name(parameters)
{
  method body
}

Nasaan name ang natatanging pangalan ng pamamaraan at method body kumakatawan sa mga utos na bumubuo sa pamamaraan. At parameters ay isang placeholder para sa mga parameter ng pamamaraan, na pinaghihiwalay ng mga kuwit. Ilarawan natin ang template na ito nang mas detalyado:

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

Mga halimbawa:

public static void print(String str)
{
}

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

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

Kung hindi namin nais na magkaroon ng mga parameter ang pamamaraan, pagkatapos ay iiwan na lamang namin ang mga panaklong na walang laman.

Ang mga parameter ay mga espesyal na variable sa loob ng isang pamamaraan. Sa kanilang tulong, maaari mong ipasa ang iba't ibang mga halaga sa pamamaraan kapag tinawag ito.

Halimbawa, magsulat tayo ng isang paraan na nagpapakita ng isang string ng teksto sa isang naibigay na bilang ng beses.

Alam mo na kung paano magsulat ng code upang ipakita ang isang string sa screen nang maraming beses. Ngunit aling string ang dapat mong i-print? At ilang beses? Iyan ang kailangan natin ng mga parameter.

Ang code na gumagawa 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 bawat oras na tinawag ang isang pamamaraan, ang mga parameter nito ay itinalaga ang mga naipasa na mga halaga, at pagkatapos lamang magsisimula kaming magsagawa ng mga utos sa loob ng pamamaraan.

2. Mga argumento

Nais kong iguhit ang iyong pansin nang kaunti pa sa pagtawag sa isang pamamaraan na may mga parameter.

Ang mga halaga na ipinasa sa pamamaraan ay karaniwang tinatawag na mga argumento kapag sila ay ipinasa 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 printLines tinawag 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 sarili ay tinatawag na mga argumento."

3. Magkasalungat na mga pangalan ng variable kapag tumatawag sa isang paraan

Maaaring gamitin ang mga variable bilang mga argumento ng pamamaraan. Ito ay simple at naiintindihan, ngunit maaari itong magdulot ng ilang mga paghihirap. Bumalik tayo sa parehong halimbawa, 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";
     int n = 10;
     printLines(str, n);
   }
}

Sa ngayon, napakahusay: mayroon kaming strvariable. Ang halaga nito ay itinalaga sa textparameter kapag tinawag ang pamamaraan. Mayroon kaming isang nvariable. Ang halaga nito ay itinalaga sa countparameter kapag tinawag ang pamamaraan." Sa ngayon, malinaw ang lahat.

Ngayon ay 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";
     int count = 10;
     printLines(text, count);
   }
}

Bigyang-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. Ang mga ito ay iba't ibang mga variable sa iba't ibang mga pamamaraan dati, at kaya sila ay nananatili. Walang magic na koneksyon sa pagitan ng text at text mga variable.

4. Pagpasa ng mga sanggunian sa mga pamamaraan

Sana ay naunawaan mo ang lahat mula sa nakaraang aralin, dahil ngayon ay babalikan natin ang pagpasa ng mga argumento sa mga pamamaraan, tanging mas malalim ang ating sisisid.

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

Kapag nagtalaga ka ng isa pang array variable sa isang array variable, ano ang mangyayari? Tama iyan. Ang dalawang variable ay nagsisimulang tumukoy 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 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);
   }
}

Eksakto ang parehong bagay na mangyayari: ang data parameter ay maglalaman ng isang reference sa parehong lugar ng memorya bilang monthsvariable. Kapag tinawag ang pamamaraan, isang simpleng takdang-aralin ang 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 printArraySum pamamaraan ay hindi lamang maaaring magbasa ng mga halaga mula sa array, ngunit baguhin din ang mga ito!

Halimbawa, maaari tayong sumulat ng sarili nating pamamaraan na pumupuno sa isang two-dimensional 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);
   }
}

5. Mga pamamaraan na may parehong pangalan

Ngayon ay bumalik tayo sa mga pangalan ng pamamaraan muli.

Ang mga pamantayan ng Java ay nangangailangan ng lahat ng mga pamamaraan sa parehong klase na magkaroon ng mga natatanging pangalan. Sa madaling salita, imposibleng magdeklara ng dalawang magkaparehong pinangalanang pamamaraan sa parehong klase.

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

Bakit ang ilang mga pamamaraan ay itinuturing na pareho , habang ang iba ay iba ? At bakit hindi isinasaalang-alang ang mga pangalan ng parameter kapag tinutukoy ang pagiging natatangi ng isang pamamaraan?

Bakit kailangan ang pagiging natatangi? Ang bagay ay kapag ang compiler ay nag-compile ng isang programa, dapat itong malaman kung aling paraan ang balak mong tawagan sa anumang lugar.

Halimbawa, kung isusulat mo , matalino ang compiler at madaling maghihinuha na balak mong tawagan ang pamamaraan dito na may isang parameter.System.out.println("Hi")println()String

Ngunit kung isusulat mo , ang tagatala ay makakakita ng isang tawag sa pamamaraan na may isang parameter.System.out.println(1.0)println()double

Kapag tinawag ang isang pamamaraan, tinitiyak ng compiler na ang mga uri ng mga argumento ay tumutugma sa mga uri ng mga parameter. Hindi nito binibigyang pansin ang pangalan ng mga argumento. Sa Java, hindi nakakatulong ang mga pangalan ng parameter sa compiler na matukoy kung aling paraan ang tatawagan. At iyon ang dahilan kung bakit hindi sila isinasaalang-alang kapag tinutukoy ang pagiging natatangi ng isang pamamaraan.

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

Ang bawat klase ay dapat may mga pamamaraan na may natatanging mga lagda sa halip na mga pamamaraan na may natatanging mga pangalan.