Autoboxing at Unboxing sa Java

Sa Java, isang tampok ng mga primitive at ang kanilang mga wrapper ay autoboxing / unboxing. Isaalang-alang natin ang konseptong ito. Tulad ng natutunan na natin, ang Java ay isang object-oriented na wika. Nangangahulugan iyon na ang lahat ng mga program na nakasulat sa Java ay gawa sa mga bagay. Ang mga primitive ay hindi mga bagay. Ngunit kahit na, ang isang variable ng wrapper ay maaaring magtalaga ng isang primitive na halaga. Ang prosesong ito ay tinatawag na autoboxing. Katulad nito, ang isang primitive variable ay maaaring magtalaga ng isang wrapper object. Ang prosesong ito ay tinatawag na unboxing. Halimbawa:

public class Main {
   public static void main(String[] args) {
       int x = 7;
       Integer y = 111;
       x = y; // Unboxing
       y = x * 123; // Autoboxing
   }
}

Sa linya 5, itinalaga namin ang y, na isang Integer na bagay, sa primitive x . Tulad ng nakikita mo, hindi namin kailangang gumawa ng anumang karagdagang mga hakbang: alam ng compiler na ang int at Integer ay, mahalagang, ang parehong bagay. Unboxing yan. May katulad na nangyayari sa autoboxing sa linya 6: ang primitive na halaga (x * 123) ay madaling italaga sa object y . Ito ay isang halimbawa ng autoboxing. Iyon ang dahilan kung bakit kasama sa termino ang salitang "auto": dahil hindi mo kailangang gumawa ng anumang bagay na espesyal para magtalaga ng mga primitive sa kanilang mga katumbas na bagay sa wrapper (at kabaliktaran). Awtomatikong nangyayari ang lahat. Maginhawa, ha? :) Nakikita namin ang isa pang halimbawa ng kaginhawaan ng autoboxing / unboxing kapag nagtatrabaho sa mga pamamaraan. Ito ay dahil ang mga argumento ng pamamaraan ay naka-autobox at naka-unbox din. Halimbawa, kung ang isang pamamaraan ay tumatagal ng dalawang Integer na bagay bilang mga input, madali nating maipapasa ang ordinaryong int s sa halip!

public class Main {
   public static void main(String[] args) {

       printNumber(7);// A standard int, not even an int variable
   }

   public static void printNumber(Integer i) {
       System.out.println("You entered the number " + i);
   }
}

Output:

You entered the number 7

Gumagana din ito sa kabilang direksyon:

public class Main {
   public static void main(String[] args) {

       printNumber(new Integer(632));
   }

   public static void printNumber(int i) {
       System.out.println("You entered the number " + i);
   }
}

Ang isang mahalagang punto na kailangan mong tandaan ay ito: ang autoboxing at unboxing ay hindi gumagana para sa mga array!

public class Main {
   public static void main(String[] args) {

       int[] i = {1,2,3,4,5};

       printArray(i);// Error, this won't compile!
   }

   public static void printArray(Integer[] arr) {
       System.out.println(Arrays.toString(arr));
   }
}

Ang pagtatangkang magpasa ng hanay ng mga primitive sa isang paraan na kumukuha ng hanay ng mga bagay ay magreresulta sa isang error sa compilation. Sa konklusyon, isa pang beses nating ihambing ang mga primitive at wrapper.

Primitives:

• Magkaroon ng mga pakinabang sa pagganap

Mga wrapper:

• Pahintulutan kaming hindi labagin ang prinsipyong "lahat ng bagay," na nangangahulugan na ang mga numero, character, at boolean na halaga ay hindi lumalabag sa konseptong ito
• Palawakin ang mga posibilidad para sa pagtatrabaho sa mga halagang ito sa pamamagitan ng pagbibigay ng mga maginhawang pamamaraan at field
• Kinakailangan kapag ang isang pamamaraan ay gumagana lamang sa mga bagay

Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course