జావాలో రేపర్ రకాలు

1. రేపర్ రకాల జాబితా

జావాలో 8 ఆదిమ రకాలు ఉన్నాయని మీకు తెలుసు, అవి తరగతులు కాని రకాలు. ఒక వైపు, ఇది మంచిది - అవి సరళమైనవి మరియు తక్కువ స్థలాన్ని తీసుకుంటాయి. మరోవైపు, కొన్నిసార్లు తరగతులు మనకు అవసరమైనవి మాత్రమే. అది ఎందుకు అని మీరు తదుపరి పాఠంలో ఖచ్చితంగా కనుగొంటారు.

కాబట్టి ఏమి చేయవచ్చు?

జావా యొక్క ఐదవ సంస్కరణతో ప్రారంభించి, ప్రతి ఆదిమ రకం జంట తరగతిని పొందింది. అటువంటి ప్రతి తరగతి ఒక నిర్దిష్ట రకం విలువతో ఒకే ఫీల్డ్‌ను నిల్వ చేస్తుంది. ఈ తరగతులను రేపర్ రకాలు అంటారు , ఎందుకంటే అవి తరగతులలో ఆదిమ విలువలను చుట్టేస్తాయి.

ఈ రకాల జాబితా ఇక్కడ ఉంది. మీకు ఏమైనా తెలుసా?

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

ఆదిమ రకాల పేర్లు చిన్న అక్షరంతో ప్రారంభమవుతాయి, అయితే రేపర్ తరగతుల పేర్లు పెద్ద అక్షరంతో ప్రారంభమవుతాయి. కొన్ని తరగతి పేర్లు కూడా కొంచెం పొడవుగా ఉన్నాయి: Integerబదులుగా intమరియు Characterబదులుగా 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);
   }
}

2. aని intఒక గా మార్చడంInteger

రేపర్ రకాలు వారి ఆదిమ తోబుట్టువులకు ప్రతిరూపాలుగా పరిగణించబడతాయి: మీరు ఆదిమ రకానికి అనుగుణంగా ఉండే రేపర్ వస్తువును సులభంగా సృష్టించవచ్చు.

ఆదిమ రకాలు వాటి సంబంధిత రేపర్ రకాలతో ఎలా సంకర్షణ చెందుతాయో విశ్లేషించడానికి పూర్ణాంక రకాన్ని ఉదాహరణగా ఉపయోగిస్తాము. 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. intఒక వస్తువు లోపల నిల్వ చేయబడిన విలువను పొందడం చాలా సులభం Integer- కేవలం intValue()పద్ధతిని కాల్ చేయండి.

ఉదాహరణ:

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

ఇది చాలా గజిబిజిగా ఉన్న కోడ్, మీరు అనుకోలేదా?

జావా సృష్టికర్తలు అలా భావించారు, కాబట్టి వారు స్వయంచాలకంగా ఈ కార్యకలాపాలను ఎలా చేయాలో కంపైలర్‌కు నేర్పించారు. intaని ఆటోమేటిక్‌గా మార్చడాన్ని ఆటోబాక్సింగ్Integer అంటారు (విలువను ఆటోమేటిక్‌గా బాక్స్‌లో ఉంచడం), మరియు రివర్స్ ఆపరేషన్ (aని ఒక గా మార్చడం) అన్‌బాక్సింగ్ అంటారు .Integerint

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))
{
   ...
}