Mga Klase ng Wrapper sa Java

Hi! Kilalang-kilala mo na ang mga primitive na uri, at medyo nagtrabaho ka na sa kanila. Sa programming (at partikular sa Java), ang mga primitive ay may maraming pakinabang: gumagamit sila ng maliit na memorya (at sa gayon ay ginagawang mas mahusay ang programa) at may malinaw na delineated na hanay ng mga halaga. Gayunpaman, habang nag-aaral ng Java, madalas na naming inulit ang mantra na "lahat ng bagay sa Java ay isang bagay". Ngunit ang mga primitive ay direktang sumasalungat sa mga salitang iyon. Hindi sila bagay. Kaya, mali ba ang ating prinsipyong "lahat ng bagay"? Actually, hindi naman. Sa Java, ang bawat primitive na uri ay may kambal na kapatid, isang klase ng wrapper.

Ano ang Wrapper Class?

Ang wrapper ay isang espesyal na klase na nag-iimbak ng primitive sa loob. Ngunit dahil isa itong klase, maaari kang gumawa ng mga pagkakataon nito. Iniimbak nila ang mga primitive na halaga sa loob, ngunit mga tunay na bagay pa rin. Ang mga pangalan ng klase ng wrapper ay halos kapareho sa (o eksaktong kapareho ng) sa mga pangalan ng kanilang kaukulang primitive. Kaya, madali silang matandaan. Ang mga bagay ng wrapper ay nilikha sa parehong paraan tulad ng anumang iba pang bagay:

public static void main(String[] args) {

   Integer i = new Integer(682);
  
   Double d = new Double(2.33);
  
   Boolean b = new Boolean(false);
}

Hinahayaan tayo ng mga klase ng wrapper na pagaanin ang mga pagkukulang ng mga primitive na uri. Ang pinaka-halata ay ang mga primitive ay walang mga pamamaraan. Halimbawa, wala silang toString() na paraan, kaya hindi mo, halimbawa, mag-convert ng int sa isang String . Ngunit ginagawang madali ito ng klase ng Integer wrapper.

public static void main(String[] args) {

   Integer i = new Integer(432);
  
   String s = i.toString();
}

Gayunpaman, ang pag-convert sa kabilang direksyon ay maaaring maging mas nakakalito. Sabihin nating mayroon tayong String , na alam nating tiyak na naglalaman ng numero. Anuman, walang katutubong paraan upang gumamit ng primitive int upang kunin ang numero mula sa String at i-convert ito sa isang numero. Ngunit, magagawa natin sa mga klase ng wrapper.

public static void main(String[] args) {

   String s = "1166628";

   Integer i = Integer.parseInt(s);

   System.out.println(i);
}

Output:

1166628

Matagumpay naming nakuha ang isang numero mula sa String at itinalaga ito sa Integer reference variable i . Sa pamamagitan ng paraan, tungkol sa mga sanggunian. Alam mo na na ang mga argumento ay ipinapasa sa mga pamamaraan sa iba't ibang paraan: mga primitive ayon sa halaga, at mga bagay sa pamamagitan ng sanggunian. Magagamit mo ang kaalamang ito kapag gumagawa ng sarili mong mga pamamaraan: halimbawa, kung gumagamit ang iyong pamamaraan ng mga fractional na numero ngunit kailangan mo ng lohika upang maipasa sa pamamagitan ng sanggunian, maaari mong ipasa ang mga argumento ng Double / Float sa pamamaraan sa halip na double / float . Bilang karagdagan sa mga pamamaraan ng mga klase ng wrapper, ang kanilang mga static na field ay maaari ding maging napaka-maginhawa. Halimbawa, isipin na mayroon kang sumusunod na gawain: ipakita ang maximum na posibleint na halaga, na sinusundan ng pinakamababang posibleng halaga. Ang problemang ito ay tila basic. Ngunit kung wala ang Google, malamang na hindi mo ito magagawa. Ngunit pinahihintulutan ka ng mga wrapper na madaling mahawakan ang mga ganitong "makamundo na gawain":

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

       System.out.println(Integer.MAX_VALUE);
       System.out.println(Integer.MIN_VALUE);
   }
}

Pinipigilan ka ng mga patlang na ito na hindi makagambala sa pagsasagawa ng mas seryosong mga gawain. Hindi banggitin ang katotohanan na ang pag-type sa 2147483647 (na kung saan ay ang halaga ng MAX_VALUE) ay hindi maliit na gawa! :) Higit pa rito, sa nakaraang aralin, itinuro namin na ang mga bagay na pambalot ay hindi nababago.

public static void main(String[] args) {

   Integer a = new Integer(0);
   Integer b = new Integer(0);

   b = a;
   a = 1;
   System.out.println(b);
}

Output:

0

Ang estado ng bagay na orihinal na itinuro ng a ay hindi nagbago (dahil ang halaga ng b ay nagbago din). Tulad ng String s, sa halip na baguhin ang estado ng wrapper object, isang ganap na bagong object ang nilikha sa memorya. Kaya, bakit nagpasya ang mga tagalikha ng Java na mag-iwan ng mga primitive na uri sa wika? Dahil ang lahat ay dapat na isang bagay, at mayroon kaming mga klase ng wrapper na maaaring ipahayag ang lahat ng ipinahahayag ng mga primitive, bakit hindi lamang panatilihin ang mga wrapper sa wika at alisin ang mga primitive? Ang sagot ay simple: pagganap. Ang mga primitive na uri ay tinatawag na primitive dahil kulang sila ng marami sa mga "mabigat" na katangian ng mga bagay. Oo, ang mga bagay ay may maraming maginhawang pamamaraan, ngunit hindi mo palaging kailangan ang mga ito. Minsan, ang kailangan mo lang ay ang numerong 33, o 2.62, o true / false . Sa mga sitwasyon kung saan ang mga bentahe ng mga bagay ay hindi mahalaga at hindi kinakailangan para gumana ang programa, ang mga primitive ay mas angkop sa gawain.