Parameter kaedah dalam Java

"Hai Amigo! Saya harap anda seronok menyelesaikan tugasan menggunakan kaedah anda sendiri dan anda sedar betapa mudahnya untuk mencipta kaedah. Sekarang mari kita bincangkan tentang topik yang paling menarik."

"Anda telah menarik minat saya, Diego... Topik baru?"

"Setiap topik adalah baru untuk anda, robot muda saya! Dan yang ini tidak terkecuali. Walaupun sekali lagi ia mengenai kaedah. Anda mungkin telah perasan dari kaedah seperti itu kita boleh menyampaikan System.out.println()hujah kepada kaedah. Sebaik sahaja kita berada di dalam kaedah. , kami merujuknya sebagai parameter."

"Parameter ialah apa yang kita tulis di dalam kurungan?"

"Ya, betul-betul. Dan, sebenarnya, parameter sangat meningkatkan faedah yang kami peroleh daripada mencipta dan menggunakan kaedah."

"Saya mendapat apa yang anda katakan tentang menggunakannya, dan ternyata saya telah melakukannya. Bagaimanakah kita mengisytiharkan kaedah dengan parameter?"

"Ia sebenarnya agak mudah:

public static void name(parameters)
{
  method body
}

"Di manakah namenama unik kaedah dan method bodymewakili arahan yang membentuk kaedah. Dan parametersmerupakan pemegang tempat untuk parameter kaedah, dipisahkan dengan koma."

"Hmm... Saya rasa saya faham... Atau mungkin tidak..."

"Izinkan saya memberikan anda beberapa butiran lanjut tentang templat ini supaya anda pasti bahawa anda faham bahawa anda faham:

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

Berikut adalah beberapa contoh:

public static void print(String str)
{
}

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

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

"Ah... Sekarang sudah jelas. Dan jika kita tidak mahu kaedah itu mempunyai parameter, maka kita biarkan sahaja kurungan itu kosong."

"Tepat sekali. Pada asasnya, parameter ialah pembolehubah khas dalam kaedah. Dengan bantuan mereka, anda boleh menghantar pelbagai nilai kepada kaedah apabila ia dipanggil. Dan jika anda tidak perlu menghantar nilai, maka anda biarkan kurungan kosong.

"Sebagai contoh, mari kita tulis kaedah yang memaparkan baris teks tertentu beberapa kali. Sebarang pemikiran tentang cara melakukan ini?"

"Nah... Nampaknya saya tahu cara menulis kod untuk memaparkan rentetan pada skrin beberapa kali..."

"Bagaimana anda menentukan rentetan untuk dipaparkan? Dan bagaimana anda menentukan bilangan baris yang dipaparkan? Bolehkah anda meneka?"

"Perkara mula menjadi jelas... Mungkin dengan bantuan parameter kaedah?"

"Tepat sekali. Parameter rentetan untuk baris teks dan parameter berangka untuk bilangan baris yang dipaparkan. 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 itu.

Hujah

"Saya mahu anda memberi perhatian khusus kepada kaedah panggilan yang mempunyai parameter. Nilai yang dihantar kepada kaedah biasanya dipanggil argumen apabila ia dihantar kepada kaedah.

Mari kita lihat lagi contoh kita:

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 printLineskaedah 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", 10, dan 20sendiri dipanggil argumen."

"Saya akan cuba mengingati perbezaannya dan tidak mengelirukan konsep ini."

Nama pembolehubah bercanggah apabila memanggil kaedah

"Apabila anda memanggil kaedah, anda boleh menggunakan pembolehubah sebagai hujah.

"Nah, itu masuk akal!"

"Ia masuk akal, tetapi ia berpotensi menghasilkan beberapa kesukaran. Mari kita kembali kepada contoh kita sekali lagi, 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";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... Saya tidak nampak sebarang kesukaran. Kami mempunyai strpembolehubah. Nilainya ditetapkan kepada textparameter apabila kaedah dipanggil. Kami mempunyai npembolehubah. Nilainya ditetapkan kepada countparameter apabila kaedah dipanggil." "Setakat ini, semuanya jelas."

"Baik, bagus. 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";
     String 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, jadi ia kekal. Tiada sambungan ajaib antara kedua-dua textpembolehubah itu."

"Kini saya tahu."

Meluluskan rujukan kepada kaedah

"Saya harap anda telah mengasimilasikan semua yang saya beritahu anda tentang menyampaikan hujah kepada kaedah. Saya katakan itu, kerana kita kini akan menyelami sedikit lebih dalam topik ini. Dengar dengan teliti."

"Anda sudah tahu bahawa sesetengah pembolehubah dalam 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 pembangun memberikan pembolehubah tatasusunan lain kepada pembolehubah tatasusunan, apakah yang berlaku?"

"Adakah mereka kemudiannya menunjuk ke alamat yang sama?"

"Betul. Kedua-dua pembolehubah mula merujuk kepada ruang yang sama dalam ingatan:

"Dan apa yang berlaku jika salah satu pembolehubah ini adalah parameter kaedah?

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

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

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

"Saya rasa saya faham, tetapi saya perlukan lebih banyak contoh!"

"Nah, sebagai contoh, kita boleh menulis kaedah kita sendiri yang mengisi tatasusunan dua dimensi dengan nilai yang sama. Beginilah rupanya:

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

Kaedah dengan nama yang sama

"Sekarang mari kita kembali kepada nama kaedah sekali lagi."

"Saya tidak dapat bayangkan apa lagi yang boleh dikatakan tentang nama!"

"Nah, standard bahasa Java memerlukan semua kaedah dalam kelas yang sama untuk mempunyai nama yang unik.

"Jadi, mustahil untuk mengisytiharkan dua kaedah yang dinamakan dalam kelas yang sama?"

"Sekarang — perhatikan betul-betul! Kaedah dalam kelas memang boleh mempunyai nama yang sama! Tetapi dalam kes ini, mereka mesti mempunyai parameter yang berbeza. Dalam erti kata lain, kaedah dibandingkan untuk kesamaan, bukan sahaja nama diambil kira, tetapi juga jenis parameter ! Ambil perhatian bahawa saya secara khusus mengatakan jenis. 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) {
}

"Saya benar-benar keliru! Mengapa kita memerlukan semua ini? Mengapa sesetengah kaedah dianggap sama , manakala yang lain adalah berbeza ? Dan mengapa nama parameter tidak diambil kira semasa menentukan keunikan kaedah? Mengapakah keunikan diperlukan pada semua?"

"Perkaranya 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. Tetapi jika anda menulis , pengkompil akan melihat panggilan ke kaedah dengan parameter. Ia tidak mempunyai idea nama apa yang diberikan pengaturcara kepada parameter semasa mengisytiharkan kaedah."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, nampaknya sudah mula terlintas!

"Apabila kaedah dipanggil, pengkompil memastikan bahawa jenis argumen sepadan dengan jenis parameter. Ia tidak memberi perhatian kepada nama argumen. Dalam Java, nama parameter tidak membantu pengkompil menentukan kaedah yang hendak digunakan. panggilan. Pengaturcara memerlukannya, bukan pengkompil.

"Dan saya rasa itulah sebabnya mereka tidak diambil kira semasa menentukan keunikan sesuatu kaedah?"

"Ya, itu betul sepenuhnya. Nama kaedah dan jenis parameternya dipanggil tandatangan kaedah . Contohnya, sum (int, int)"

"Jadi setiap kelas mesti mempunyai kaedah dengan tandatangan unik dan bukannya kaedah dengan nama unik."

"Syabas, Amigo! Anda telah meringkaskan pelajaran ini dengan sempurna. Jika ada sesuatu yang masih tidak jelas, jangan panik. Topik ini akan menjadi jelas selepas beberapa tugasan."