Di Jawa, bagaimanakah parameter diluluskan?

Soalan yang paling biasa ditanya oleh pengaturcara pemula ialah bagaimana parameter dihantar dalam Java. Biasanya, bahasa pengaturcaraan menggunakan nilai lulus dan rujukan lulus untuk menghantar parameter kepada kaedah. Walau bagaimanapun, Java tidak menyokong kedua-dua kaedah ini dan sebaliknya menggunakan nilai pas demi untuk menghantar nilai jenis primitif dan rujukan. Dalam artikel ini, kita akan belajar tentang menghantar parameter mengikut nilai melalui program sampel.

Lepaskan parameter kepada kaedah dalam Java

Mari kita mulakan perbincangan dengan memahami mekanisme storan Java. Nama pembolehubah rujukan, kaedah dan kelas disimpan pada timbunan, dan nilainya disimpan pada timbunan. Walau bagaimanapun, primitif dan nilainya disimpan terus dalam ingatan tindanan.

Seperti yang dinyatakan sebelum ini, Java hanya menyokong nilai lulus jenis asas dan jenis rujukan, yang bermaksud bahawa apabila kaedah dipanggil, salinan setiap nilai parameter dihantar ke kaedah

Untuk jenis asas seperti int, double dan Boolean, nilai parameter adalah sama dengan nilai asal pembolehubah. Sebagai contoh, jika kita mempunyai pembolehubah "x" dengan nilai 10, dan kita menghantar "x" sebagai argumen kepada kaedah, kaedah tersebut menerima salinan nilai asal 10 sebagai argumennya.

Memandangkan pembolehubah rujukan disimpan pada tindanan, untuk jenis rujukan seperti tatasusunan, objek dan rentetan, nilai parameter ialah rujukan atau alamat pembolehubah yang diberikan. Sebagai contoh, jika kita mempunyai tatasusunan 'arr' dengan elemen {1, 2, 3} dan menghantar 'arr' sebagai parameter kepada kaedah, maka kaedah itu akan menerima rujukan atau salinan alamat 'arr' sebagai parameternya.

Mari bincangkan beberapa istilah yang berkaitan dengan passing parameter dalam Java

Kaedah yang ditetapkan pengguna

Kaedah ialah blok kod yang boleh digunakan semula beberapa kali untuk melakukan satu operasi. Ia menjimatkan masa kami dan juga mengurangkan saiz kod.

Tatabahasa

accessSpecifier nonAccessModifier return_Type method_Name(Parameters) {
   // Body of the method
}

Di sini,

accessSpecifier - digunakan untuk menetapkan kebolehcapaian sesuatu kaedah. Ia boleh menjadi awam, dilindungi, lalai dan peribadi.

nonAccessModifier - Ia menunjukkan fungsi atau tingkah laku tambahan kaedah seperti statik dan muktamad.

return_Type - Jenis data yang kaedah akan kembalikan. Kami menggunakan kata kunci void apabila kaedah tidak mengembalikan apa-apa.

parameter vs parameter

Parameter - dinamakan pembolehubah yang diluluskan semasa definisi kaedah yang berfungsi sebagai ruang letak untuk parameter. Mereka sebenarnya mengimport parameter ke dalam kaedah yang ditentukan. Mereka membenarkan kaedah untuk digeneralisasikan. Di sini, generalisasi bermakna kita boleh menggunakan semula satu kaedah pada pelbagai data mengikut keperluan.

Parameter - ialah nilai sebenar yang diluluskan apabila kaedah dipanggil. Mereka mesti sepadan dengan jenis parameter yang diluluskan dalam definisi kaedah.

Kaedah nilai lulus

Dengan menghantar parameter dengan cara ini, salinan nilai parameter dihantar ke kaedah yang diberikan. Kaedah ini boleh mengubah suai salinan tetapi tidak boleh menjejaskan nilai asal parameter.

Lulus dengan rujukan

Dengan cara menghantar parameter ini, rujukan atau alamat parameter dihantar ke kaedah yang diberikan. Kaedah ini boleh mengubah suai nilai asal parameter dengan rujukan

Program Java memaparkan pemindahan parameter

Kaedah

• Tentukan dua kaedah yang ditentukan pengguna. Kaedah "changeVal()" digunakan untuk mengubah suai jenis asal, dan kaedah "changeAray()" digunakan untuk mengubah suai jenis rujukan.

• Dalam kaedah main(), isytiharkan dan mulakan nilai jenis integer dan nilai jenis rujukan.

• Sekarang, hubungi kaedah yang ditentukan pengguna ini untuk melakukan tindakan dan keluar

Contoh

import java.util.*;
public class ParameterPassing {
   public static void changeVal(int n) {
      n = n * 2; // modifying value
      System.out.println("Inside method: n = " + n);
   }
   public static void changeAray(int[] a) {
      a[0] = a[0] * 2; // modifying value
      System.out.println("Inside method: a = " + Arrays.toString(a));
   }
   public static void main(String[] args) {
      // for the Primitive type
      int val1 = 10;
      System.out.println("Before calling changeVal method: val1 = " + val1);
      changeVal(val1); // calling the method
      System.out.println("After calling changeVal method: val1 = " + val1);
      
      // for Reference type
      int[] aray = {1, 2, 3};
      System.out.println("Before calling changeAray method: arr = " + Arrays.toString(aray));
      changeAray(aray); // calling the method
      System.out.println("After calling changeAray method: arr = " + Arrays.toString(aray));
   }
}

Output

Before calling changeVal method: val1 = 10
Inside method: n = 20
After calling changeVal method: val1 = 10
Before calling changeAray method: arr = [1, 2, 3]
Inside method: a = [2, 2, 3]
After calling changeAray method: arr = [2, 2, 3]

Seperti yang anda lihat dalam output, untuk jenis primitif "val1", nilainya tidak berubah selepas memanggil kaedah "changeVal". Untuk jenis rujukan "arr", nilainya akan berubah selepas memanggil kaedah "changeAray".

Kesimpulan

Dalam artikel ini, kami belajar tentang kaedah yang ditentukan pengguna dan membincangkan cara menghantar parameter kaedah dalam Java dengan contoh. Menghantar nilai jenis rujukan sebagai parameter tidak sama dengan jenis primitif. Java hanya menyokong rujukan lulus kepada jenis bukan primitif untuk mengubah suai keadaan mereka, bukan identiti mereka.

Atas ialah kandungan terperinci Di Jawa, bagaimanakah parameter diluluskan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!