Mga klase ng wrapper

1. Listahan ng mga uri ng wrapper

Alam mo na ang Java ay may 8 primitive na uri, na mga uri na hindi mga klase. Sa isang banda, ito ay mabuti — sila ay simple at kumukuha ng kaunting espasyo. Sa kabilang banda, minsan klase lang ang kailangan natin. Malalaman mo kung bakit ganoon sa susunod na aralin.

Kaya ano ang maaaring gawin?

Simula sa ikalimang bersyon ng Java, ang bawat primitive na uri ay nakakuha ng kambal na klase. Ang bawat naturang klase ay nag-iimbak ng isang field na may halaga ng isang partikular na uri. Ang mga klase na ito ay tinatawag na mga uri ng wrapper , dahil binabalot nila ang mga primitive na halaga sa mga klase.

Narito ang isang listahan ng mga ganitong uri. May nalalaman ka ba na kahit ano?

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

Ang mga pangalan ng mga primitive na uri ay nagsisimula sa isang maliit na titik, ngunit ang mga pangalan ng mga klase ng wrapper ay nagsisimula sa isang malaking titik. Ang ilan sa mga pangalan ng klase ay medyo mas mahaba din: Integerinstead of intи Characterinstead of char.

Ang lahat ng mga bagay ng mga klase ng wrapper ay hindi nababago ( hindi nababago ).

Ang pinasimpleng code para sa Integerklase ay mukhang ganito:

public class Integer
{
   private int value;

   Integer(int x)
   {
      this.value = x;
   }

   public int intValue()
   {
      return this.value;
   }

   public static Integer valueOf(int x)
   {
      return new Integer(x);
   }
}

2. Pag-convert ng isang intsa isangInteger

Ang mga uri ng wrapper ay itinuturing na katapat ng kanilang mga primitive na kapatid: madali kang makakagawa ng wrapper object na tumutugma sa isang primitive na uri.

Gamitin natin ang uri ng int bilang isang halimbawa upang suriin kung paano nakikipag-ugnayan ang mga primitive na uri sa kanilang mga kaukulang uri ng wrapper. Ang code para sa pag-convert mula sa isang inttungo sa isang Integerat vice versa ay magiging ganito:

Upang i-convert ang isang intsa isang Integer, kailangan mong isulat ang code na ito:

Integer name = new Integer(value);

Nasaan nameang pangalan ng isang Integervariable, at valueang nakabalot intna halaga.

Mga halimbawa:

Integer age = new Integer(18);

Integer hundred = new Integer(100);

Integer zero = new Integer(0);

At para ma-convert ang an Integersa isang int, kailangan mong isulat ang code na ito:

int name = variable.intValue();

Nasaan nameang pangalan ng isang intvariable, at variableisang sanggunian sa isang Integerbagay.

Mga halimbawa:

Integer age = new Integer(18);
int x = age.intValue();

x == 18

Integer hundred = new Integer(100);
int y = hundred.intValue();

y == 100

Integer zero = new Integer(0);
int z = zero.intValue();

z == 0

int i = 110;
Integer zero = new Integer(i);
int z = zero.intValue();

z == 110

3. Autoboxing at unboxing

Ngunit kahit na ang mga simpleng operasyon na may Integeruri ay hindi madaling isulat.

Tulad ng sinabi namin dati, ang Integeruri ay hindi nababago ( hindi nababago ). Upang lumikha ng isang Integerbagay na may bagong inthalaga, kailangan mong tahasang lumikha ng isang bagong Integerbagay. Iyon ay sinabi, madaling makuha ang halaga ng isang intnaka-imbak sa loob ng isang Integerbagay — tawagan lang ang intValue()pamamaraan.

Halimbawa:

Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = new Integer(b + 5)

Ito ay medyo mahirap na code, sa tingin mo ba?

Naisip ng mga tagalikha ng Java, kaya tinuruan nila ang compiler kung paano awtomatikong gawin ang mga operasyong ito. Ang awtomatikong pag-convert ng isang intsa isang Integeray tinatawag na autoboxing (awtomatikong paglalagay ng halaga sa isang kahon), at ang reverse na operasyon (pag-convert ng isang Integersa isang int) ay tinatawag na unboxing .

Integer a = 10;

Integer a = Integer.valueOf(10);

int b = a;

int b = a.intValue();

Integer c = a + b;

Integer c = Integer.valueOf(a.intValue() + b);

Salamat sa autoboxing at unboxing, maaari mong ligtas na magtalaga ng intsa isang Integervariable at vice versa. Maaari kang magsulat ng mga expression ng anumang kumplikado nang hindi gumagawa ng pagkakaiba sa pagitan ng intat Integermga uri.

Mga halimbawa:

Integer a = 5;
int b = a;
Integer c = a + b;
int d = a + b + c;

Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = Integer.valueOf(a.intValue() + b);
int d = a.intValue() + b + c.intValue();

Integer a = 5;
int b = 5;

if (a == b)
{
   ...
}

Integer a = Integer.valueOf (5);
int b = 5;

if (a.intValue() == b)
{
   ...
}

4. Paghahambing ng mga variable ng wrapper

Ang autoboxing at unboxing ay simple at transparent na proseso. Gumagamit kami new Integer()ng mga pahayag kung kinakailangan, at tinatawag namin ang intValue()pamamaraan kung kinakailangan.

Ang lahat ay gumagana nang maganda at madali para sa iyo, ang programmer. Tandaan na kung ihahambing mo ang isang Integerat isang Integer, ang paghahambing ay batay sa sanggunian at hindi mga halaga.

Integer a = 1000;
Integer b = 1000;

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

false

Integer a = 1000;
Integer b = 1000;

System.out.println(a.equals(b));

true

Ang aat bmga variable ay hindi nag-iimbak intng mga halaga. Nag-iimbak sila ng mga sanggunian sa mga bagay. Ibig sabihin, mahalagang tandaan kung paano ihambing ang mga ito nang tama:

Integer a = 1000;
Integer b = 1000;
if (a == b)
{
   ...
}

Integer a = 1000;
Integer b = 1000;
if (a.equals(b))
{
   ...
}