ரேப்பர் வகுப்புகள்

1. ரேப்பர் வகைகளின் பட்டியல்

ஜாவாவில் 8 பழமையான வகைகள் உள்ளன என்பது உங்களுக்குத் தெரியும், அவை வகுப்புகள் அல்ல. ஒருபுறம், இது நல்லது - அவை எளிமையானவை மற்றும் சிறிய இடத்தை எடுத்துக்கொள்கின்றன. மறுபுறம், சில நேரங்களில் வகுப்புகள் நமக்குத் தேவையானவை. அது ஏன் என்பதை அடுத்த பாடத்தில் சரியாகக் கண்டுபிடிப்பீர்கள்.

அதனால் என்ன செய்ய முடியும்?

ஜாவாவின் ஐந்தாவது பதிப்பில் தொடங்கி, ஒவ்வொரு பழமையான வகையும் ஒரு இரட்டை வகுப்பைப் பெற்றது. அத்தகைய ஒவ்வொரு வகுப்பும் ஒரு குறிப்பிட்ட வகையின் மதிப்புடன் ஒரு புலத்தை சேமிக்கிறது. இந்த வகுப்புகள் ரேப்பர் வகைகள் என்று அழைக்கப்படுகின்றன , ஏனெனில் அவை வகுப்புகளில் பழமையான மதிப்புகளை மூடுகின்றன.

இந்த வகைகளின் பட்டியல் இங்கே. உங்களுக்கு ஏதாவது தெரியுமா?

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

பழமையான வகைகளின் பெயர்கள் சிறிய எழுத்துடன் தொடங்குகின்றன, ஆனால் ரேப்பர் வகுப்புகளின் பெயர்கள் பெரிய எழுத்துடன் தொடங்குகின்றன. சில வகுப்புப் பெயர்களும் சிறிது நீளமாக உள்ளன: Integerinstead of intи Characterinstead of char.

ரேப்பர் வகுப்புகளின் அனைத்து பொருட்களும் மாறாதவை ( மாறாதவை ).

வகுப்பிற்கான எளிமைப்படுத்தப்பட்ட குறியீடு Integerஇதுபோல் தெரிகிறது:

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

int2. அனை அனாக மாற்றுதல்Integer

ரேப்பர் வகைகள் அவற்றின் பழமையான உடன்பிறப்புகளுக்கு இணையாகக் கருதப்படுகின்றன: பழமையான வகைக்கு ஒத்த ரேப்பர் பொருளை நீங்கள் எளிதாக உருவாக்கலாம்.

பழமையான வகைகள் அவற்றின் தொடர்புடைய ரேப்பர் வகைகளுடன் எவ்வாறு தொடர்பு கொள்கின்றன என்பதை பகுப்பாய்வு செய்ய, int வகையை உதாரணமாகப் பயன்படுத்துவோம். intஒரு இலிருந்து ஒரு Integerமற்றும் நேர்மாறாக மாற்றுவதற்கான குறியீடு இப்படி இருக்கும்:

intஒரு க்கு மாற்ற Integer, நீங்கள் இந்த குறியீட்டை எழுத வேண்டும்:

Integer name = new Integer(value);

nameஒரு மாறியின் பெயர் எங்கே Integer, மற்றும் valueமூடப்பட்ட intமதிப்பு.

எடுத்துக்காட்டுகள்:

Integer age = new Integer(18);

Integer hundred = new Integer(100);

Integer zero = new Integer(0);

Integerமற்றும் a ஐ ஒரு க்கு மாற்ற int, நீங்கள் இந்த குறியீட்டை எழுத வேண்டும்:

int name = variable.intValue();

nameஒரு மாறியின் பெயர் எங்கே int, variableஅது ஒரு பொருளின் குறிப்பு Integer.

எடுத்துக்காட்டுகள்:

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. ஆட்டோ பாக்ஸிங் மற்றும் அன் பாக்ஸிங்

ஆனால் வகையுடன் கூடிய எளிய செயல்பாடுகள் கூட Integerஎழுதுவது எளிதல்ல.

நாம் முன்பு கூறியது போல், Integerவகை மாறாதது ( மாறாதது ). Integerபுதிய மதிப்புடன் ஒரு பொருளை உருவாக்க , நீங்கள் வெளிப்படையாக ஒரு புதிய பொருளை intஉருவாக்க வேண்டும் . ஒரு பொருளின் உள்ளே சேமிக்கப்பட்ட Integerமதிப்பைப் பெறுவது எளிது - முறையை அழைக்கவும் .intIntegerintValue()

உதாரணமாக:

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

இது மிகவும் சிக்கலான குறியீடு, நீங்கள் நினைக்கவில்லையா?

ஜாவாவின் படைப்பாளிகள் அப்படி நினைத்தார்கள், எனவே இந்த செயல்பாடுகளை தானாக எப்படி செய்வது என்று கம்பைலருக்கு கற்றுக் கொடுத்தனர். intஒரு இன் தானாக மாற்றுவது Integerஆட்டோ பாக்ஸிங் (தானாக மதிப்பை ஒரு பெட்டியில் வைப்பது) என்றும், தலைகீழ் செயல்பாடு ( Integerஒரு க்கு மாற்றுவது) அன்பாக்சிங்int என்றும் அழைக்கப்படுகிறது .

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

ஆட்டோ பாக்ஸிங் மற்றும் அன் பாக்ஸிங்கிற்கு நன்றி, நீங்கள் intஒரு Integerமாறிக்கு பாதுகாப்பாக ஒதுக்கலாம் மற்றும் நேர்மாறாகவும். intமற்றும் வகைகளுக்கு இடையே வேறுபாட்டைக் காட்டாமல் எந்த சிக்கலான வெளிப்பாடுகளையும் நீங்கள் எழுதலாம் Integer.

எடுத்துக்காட்டுகள்:

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. ரேப்பர் மாறிகளை ஒப்பிடுதல்

ஆட்டோ பாக்ஸிங் மற்றும் அன்பாக்சிங் எளிய மற்றும் வெளிப்படையான செயல்முறைகள். நாங்கள் new Integer()தேவைக்கேற்ப அறிக்கைகளைப் பயன்படுத்துகிறோம், மேலும் intValue()தேவையான முறையை நாங்கள் அழைக்கிறோம்.

புரோகிராமரான உங்களுக்கு எல்லாம் நன்றாகவும் எளிதாகவும் வேலை செய்கிறது. நீங்கள் ஒரு மற்றும் ஒரு வை ஒப்பிட்டுப் பார்த்தால் , அந்த ஒப்பீடு குறிப்பு அடிப்படையிலானதே தவிர மதிப்புகள் அல்ல என்பதை நினைவில் கொள்ளுங்கள் .IntegerInteger

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

மற்றும் மாறிகள் aமதிப்புகளை bசேமிக்காது int. அவை பொருள்களைப் பற்றிய குறிப்புகளைச் சேமிக்கின்றன. அதாவது, அவற்றை எவ்வாறு சரியாக ஒப்பிடுவது என்பதை நினைவில் கொள்வது அவசியம்:

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

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