Parameter kaedah dalam Java

1. Melepasi hujah

Dan kini keseronokan bermula. Anda mungkin sudah tahu dari kaedah seperti System.out.println()itu kita boleh menyampaikan hujah kepada kaedah. Sebaik sahaja kami berada di dalam kaedah, kami merujuknya sebagai parameter. Malah, parameter sangat meningkatkan faedah yang kami peroleh daripada mencipta dan menggunakan kaedah.

Bagaimanakah kita mengisytiharkan kaedah dengan parameter? Ia sebenarnya agak mudah:

public static void name(parameters)
{
  method body
}

Di manakah name nama unik kaedah dan method body mewakili arahan yang membentuk kaedah. Dan parameters ialah pemegang tempat untuk parameter kaedah, dipisahkan dengan koma. Mari kita terangkan templat ini dengan lebih terperinci:

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

Contoh:

public static void print(String str)
{
}

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

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

Jika kita tidak mahu kaedah mempunyai parameter, maka kita biarkan sahaja kurungan kosong.

Parameter ialah pembolehubah khas dalam sesuatu kaedah. Dengan bantuan mereka, anda boleh menghantar pelbagai nilai kepada kaedah apabila ia dipanggil.

Sebagai contoh, mari kita tulis kaedah yang memaparkan rentetan teks beberapa kali tertentu.

Anda sudah tahu cara menulis kod untuk memaparkan rentetan pada skrin beberapa kali. Tetapi rentetan mana yang harus anda cetak? Dan berapa kali? Itulah yang kita perlukan parameter.

Kod yang melakukan ini akan kelihatan seperti ini:

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

Setiap kali kaedah dipanggil, parameternya diberikan nilai yang diluluskan, dan selepas itu barulah kita mula melaksanakan arahan di dalam kaedah tersebut.

2. Hujah

Saya ingin menarik perhatian anda sedikit lagi untuk memanggil kaedah dengan parameter.

Nilai yang dihantar ke kaedah biasanya dipanggil argumen apabila ia dihantar ke kaedah.

Mari lihat contoh lain:

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

Apabila printLines kaedah itu dipanggil buat kali pertama, parameternya telah diberikan nilai berikut:
String text = "Hi", int count = 10.

Apabila printLineskaedah itu dipanggil kali kedua, parameternya telah diberikan nilai yang berbeza:
String text = "Bye", int count = 20.

Parameter tidak lebih dan tidak kurang daripada pembolehubah yang diberikan nilai tertentu apabila kaedah dipanggil. Nilai "Hi", "Bye", 10dan 20sendiri dipanggil hujah."

3. Nama pembolehubah bercanggah apabila memanggil kaedah

Pembolehubah boleh digunakan sebagai hujah kaedah. Ini mudah dan boleh difahami, tetapi ia berpotensi menghasilkan beberapa kesukaran. Mari kita kembali kepada contoh yang sama, tetapi kali ini kita akan mengalihkan hujah ke dalam pembolehubah yang berasingan:

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

Setakat ini, begitu baik: kami mempunyai strpembolehubah. Nilainya diberikan kepada textparameter apabila kaedah dipanggil. Kami mempunyai npembolehubah. Nilainya diberikan kepada countparameter apabila kaedah dipanggil." Setakat ini, semuanya jelas.

Sekarang mari kita namakan semula pembolehubah kita dalam mainkaedah:

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

Perhatikan dua perkara

Pertama: kami mempunyai pembolehubah dengan nama yang sama dalam kaedah yang berbeza. Ini adalah pembolehubah yang berbeza (kami sengaja menggambarkannya menggunakan warna yang berbeza). Semuanya berfungsi sama seperti dalam contoh sebelumnya, di mana pembolehubah dalam mainkaedah dinamakan strdan n.

Kedua: Tiada perkara ajaib berlaku apabila kaedah dipanggil. Parameter hanya diberikan nilai argumen. Tidak kira sama ada nombor, rentetan, pembolehubah atau ungkapan.

Selepas kami menamakan semula pembolehubah dalam kaedah utama, tiada apa yang berubah. Mereka adalah pembolehubah yang berbeza dalam kaedah yang berbeza sebelum ini, dan oleh itu ia kekal. Tiada hubungan ajaib antara pembolehubah text dan text .

4. Meluluskan rujukan kepada kaedah

Saya harap anda memahami segala-galanya daripada pelajaran yang lepas, kerana sekarang kita akan meninjau semula hujah yang dihantar kepada kaedah, cuma kita akan menyelam lebih mendalam.

Seperti yang anda sedia maklum, sesetengah pembolehubah Java tidak menyimpan nilai itu sendiri, tetapi sebaliknya rujukan, iaitu alamat blok memori di mana nilai berada. Beginilah cara pembolehubah rentetan dan pembolehubah tatasusunan berfungsi.

Apabila anda menetapkan pembolehubah tatasusunan lain kepada pembolehubah tatasusunan, apakah yang berlaku? betul tu. Kedua-dua pembolehubah mula merujuk kepada ruang yang sama dalam ingatan:

Dan apakah yang berlaku jika salah satu pembolehubah ini ialah parameter kaedah?

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

Perkara yang sama berlaku: data parameter akan mengandungi rujukan kepada kawasan memori yang sama dengan monthspembolehubah. Apabila kaedah dipanggil, tugasan mudah berlaku: .data = months

Dan kerana kedua-dua pembolehubah merujuk kepada kawasan memori yang sama yang menyimpan integer, maka printArraySum kaedah itu bukan sahaja boleh membaca nilai daripada tatasusunan, tetapi juga mengubahnya!

Sebagai contoh, kita boleh menulis kaedah kita sendiri yang mengisi tatasusunan dua dimensi dengan nilai yang sama. Ini adalah bagaimana ia mungkin kelihatan:

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. Kaedah dengan nama yang sama

Sekarang mari kita kembali kepada nama kaedah sekali lagi.

Piawaian Java memerlukan semua kaedah dalam kelas yang sama mempunyai nama unik. Dalam erti kata lain, adalah mustahil untuk mengisytiharkan dua kaedah yang dinamakan dalam kelas yang sama.

Apabila kaedah dibandingkan untuk kesamaan, bukan sahaja nama diambil kira, tetapi juga jenis parameter ! Ambil perhatian bahawa nama parameter tidak diambil kira . Contoh:

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

Mengapakah sesetengah kaedah dianggap sama , manakala yang lain adalah berbeza ? Dan mengapa nama parameter tidak diambil kira semasa menentukan keunikan sesuatu kaedah?

Mengapakah keunikan perlu sama sekali? Masalahnya ialah apabila pengkompil menyusun atur cara, ia mesti mengetahui dengan tepat kaedah yang anda ingin panggil di mana-mana tempat tertentu.

Sebagai contoh, jika anda menulis , pengkompil adalah pintar dan dengan mudah akan membuat kesimpulan bahawa anda berhasrat untuk memanggil kaedah di sini dengan parameter.System.out.println("Hi")println()String

Tetapi jika anda menulis , pengkompil akan melihat panggilan ke kaedah dengan parameter.System.out.println(1.0)println()double

Apabila kaedah dipanggil, pengkompil memastikan bahawa jenis argumen sepadan dengan jenis parameter. Ia tidak memberi perhatian kepada nama hujah. Di Java, nama parameter tidak membantu pengkompil menentukan kaedah yang hendak dipanggil. Dan itulah sebabnya mereka tidak diambil kira semasa menentukan keunikan sesuatu kaedah.

Nama kaedah dan jenis parameternya dipanggil tandatangan kaedah . Sebagai contoh,sum(int, int)

Setiap kelas mesti mempunyai kaedah dengan tandatangan unik dan bukannya kaedah dengan nama unik.