జావాలో టైప్ కాస్టింగ్

1. టైప్ కాస్టింగ్

వివిధ రకాల సంఖ్యలను నిల్వ చేయడానికి ఆదిమ రకాల వేరియబుల్స్ (రకం మినహా boolean) ఉపయోగించబడతాయి. వేరియబుల్స్ రకాలు ఎప్పుడూ మారనప్పటికీ, మీరు ఒక రకం నుండి మరొక రకంకి మార్చగల స్థలం ఉంది. మరియు ఆ స్థలం అసైన్‌మెంట్ .

వివిధ రకాల వేరియబుల్స్ ఒకదానికొకటి కేటాయించబడతాయి. మీరు ఇలా చేసినప్పుడు ఒక రకం వేరియబుల్ విలువ మరొక రకం విలువగా మార్చబడుతుంది మరియు రెండవ వేరియబుల్‌కు కేటాయించబడుతుంది. ఈ విషయంలో, మేము రెండు రకాలైన రకం మార్పిడిని గుర్తించగలము: వెడల్పు మరియు సంకుచితం.

వెడల్పు చేయడం అనేది విలువను చిన్న బుట్ట నుండి పెద్దదానికి తరలించడం వంటిది: ఈ ఆపరేషన్ అతుకులు మరియు నొప్పిలేకుండా ఉంటుంది. మీరు పెద్ద బుట్ట నుండి చిన్నదానికి విలువను తరలించినప్పుడు సంకుచితం జరుగుతుంది: తగినంత స్థలం ఉండకపోవచ్చు మరియు మీరు ఏదైనా విసిరివేయవలసి ఉంటుంది.

బాస్కెట్ పరిమాణం ఆధారంగా క్రమబద్ధీకరించబడిన రకాలు ఇక్కడ ఉన్నాయి:

2. వైడెనింగ్ రకం మార్పిడులు

ఒక సంఖ్యా రకానికి చెందిన వేరియబుల్‌ను మరొక సంఖ్యా రకానికి చెందిన వేరియబుల్‌కు కేటాయించడం తరచుగా అవసరం. మీరు అది ఎలా చేశారు?

జావాలో 4 పూర్ణాంకాల రకాలు ఉన్నాయి:

చిన్న బుట్టలలో నిల్వ చేయబడిన వేరియబుల్ ఎల్లప్పుడూ పెద్ద బుట్టలలో నిల్వ చేయబడిన వేరియబుల్స్‌కు కేటాయించబడుతుంది.

int, shortమరియు byteవేరియబుల్స్ సులభంగా వేరియబుల్స్‌కు కేటాయించబడతాయి long. shortమరియు byteవేరియబుల్స్ వేరియబుల్స్‌కు కేటాయించబడతాయి int. మరియు byteవేరియబుల్స్‌ను వేరియబుల్స్‌కు కేటాయించవచ్చు short.

ఉదాహరణలు:

byte a = 5;
short b = a;
int c = a + b;
long d = c * c;

అటువంటి మార్పిడిని, చిన్నది నుండి పెద్ద రకానికి, వైడ్నింగ్ టైప్ కన్వర్షన్ అంటారు.

వాస్తవ సంఖ్యల సంగతేంటి?

వారితో, ప్రతిదీ ఒకేలా ఉంటుంది - పరిమాణం ముఖ్యమైనది:

floatdoubleవేరియబుల్స్ ఎటువంటి సమస్యలు లేకుండా వేరియబుల్స్‌కు కేటాయించబడతాయి . కానీ పూర్ణాంకాల రకాలతో విషయాలు మరింత ఆసక్తికరంగా ఉంటాయి.

మీరు వేరియబుల్‌కు ఏదైనా పూర్ణాంకం వేరియబుల్‌ని కేటాయించవచ్చు float. long8 బైట్‌ల పొడవు ఉండే రకం కూడా . floatమరియు మీరు ఏదైనా పూర్ణాంకం వేరియబుల్ లేదా వేరియబుల్ - వేరియబుల్‌కు కావలసినది కేటాయించవచ్చు double:

long a = 1234567890;
float b = a;
double c = a;

b == 1.23456794E9
c == 1.23456789E9

వాస్తవ రకానికి మార్చడం వలన తగినంత ముఖ్యమైన అంకెలు లేకపోవటం వలన ఖచ్చితత్వం కోల్పోవచ్చని గమనించండి.

పూర్ణాంకాల నుండి ఫ్లోటింగ్ పాయింట్ సంఖ్యలకు మార్చేటప్పుడు, సంఖ్యల దిగువ ఆర్డర్ భాగాలు విస్మరించబడవచ్చు. అయితే పాక్షిక సంఖ్యలు సుమారుగా విలువలను నిల్వ చేయడానికి అర్థం చేసుకున్నందున, అటువంటి అసైన్‌మెంట్ కార్యకలాపాలు అనుమతించబడతాయి.

3. సంకుచిత రకం మార్పిడులు

ఇతర అవకాశాల గురించి ఏమిటి? longమీరు వేరియబుల్‌కు విలువను కేటాయించవలసి వస్తే int?

ఒక వేరియబుల్‌ను బుట్టగా ఊహించుకోండి. మేము వివిధ పరిమాణాల బుట్టలను కలిగి ఉన్నాము: 1, 2, 4 మరియు 8 బైట్లు. ఆపిల్‌లను చిన్న బుట్ట నుండి పెద్దదానికి బదిలీ చేయడం సమస్య కాదు. కానీ పెద్ద బుట్ట నుండి చిన్నదానికి మారినప్పుడు, కొన్ని యాపిల్స్ కోల్పోవచ్చు.

ఈ పరివర్తన - పెద్ద రకం నుండి చిన్న రకానికి - సంకుచిత రకం మార్పిడి అంటారు . ఇలాంటి అసైన్‌మెంట్ ఆపరేషన్ చేస్తున్నప్పుడు, నంబర్‌లోని కొంత భాగం కొత్త వేరియబుల్‌కి సరిపోకపోవచ్చు మరియు అందువల్ల విస్మరించబడవచ్చు.

ఒక రకాన్ని తగ్గించేటప్పుడు, మనం పొరపాటు చేయడం లేదని, ఉద్దేశపూర్వకంగా సంఖ్యలోని కొంత భాగాన్ని విస్మరిస్తున్నామని కంపైలర్‌కి స్పష్టంగా చెప్పాలి. టైప్‌కాస్ట్ ఆపరేటర్ దీని కోసం ఉపయోగించబడుతుంది. కుండలీకరణాల్లో ఇది ఒక రకం పేరు .

అటువంటి పరిస్థితులలో, జావా కంపైలర్‌కి టైప్‌కాస్ట్ ఆపరేటర్‌ను పేర్కొనడం ప్రోగ్రామర్ అవసరం. సాధారణంగా, ఇది ఇలా కనిపిస్తుంది:

(type) expression

ఉదాహరణలు:

long a = 1;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

ఇక్కడ aకు సమానం 1, మరియు బహుశా టైప్‌కాస్ట్ ఆపరేటర్ ఓవర్ కిల్ లాగా ఉండవచ్చు. కానీ aపెద్దవి అయితే?

long a = 1000000;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

a == 1000000
b == 1000000
c == 16960
d == 64

longఒక మిలియన్ ఒక మరియు ఒక లోకి ఖచ్చితంగా సరిపోతుంది int. కానీ ఒక వేరియబుల్‌కు ఒక మిలియన్‌ని కేటాయించినప్పుడు short, మొదటి రెండు బైట్‌లు విస్మరించబడతాయి మరియు చివరి రెండు బైట్‌లు మాత్రమే అలాగే ఉంచబడతాయి. మరియు a కి కేటాయించేటప్పుడు byte, చివరి బైట్ మాత్రమే మిగిలి ఉంటుంది.

మెమరీలో సంఖ్యలు ఎలా అమర్చబడి ఉంటాయి:

charరకం

A char, a లాగా short, రెండు బైట్‌లను ఆక్రమిస్తుంది, కానీ ఒకదానిని మరొకదానికి మార్చడానికి, మీరు ఎల్లప్పుడూ టైప్‌కాస్ట్ ఆపరేటర్‌ని ఉపయోగించాలి. ఇక్కడ సమస్య ఏమిటంటే, రకం సంతకం చేయబడింది మరియు నుండి shortవిలువలను కలిగి ఉంటుంది , కానీ రకం సంతకం చేయబడలేదు మరియు నుండి వరకు విలువలను కలిగి ఉంటుంది .-32,768+32,767char065,535

ప్రతికూల సంఖ్యలు a లో నిల్వ చేయబడవు char, కానీ అవి a లో నిల్వ చేయబడతాయి short. మరియు a shortకంటే పెద్ద సంఖ్యలను నిల్వ చేయలేము 32,767, కానీ అటువంటి సంఖ్యలను a లో నిల్వ చేయవచ్చు char.

4. వ్యక్తీకరణ రకం

ఒకే వ్యక్తీకరణలో వివిధ రకాల వేరియబుల్స్ ఉపయోగించినట్లయితే? తార్కికంగా, వాటిని మొదట సాధారణ రకానికి మార్చాల్సిన అవసరం ఉందని మేము అర్థం చేసుకున్నాము. అయితే ఏది?

పెద్దదానికి, వాస్తవానికి.

జావా ఎల్లప్పుడూ పెద్ద రకానికి మారుస్తుంది. స్థూలంగా చెప్పాలంటే, రకంలో ఒకటి మొదట విస్తృతం చేయబడింది మరియు ఆ తర్వాత మాత్రమే అదే రకమైన విలువలను ఉపయోగించి ఆపరేషన్ నిర్వహించబడుతుంది.

ఒక ఎక్స్‌ప్రెషన్‌లో ఒక intమరియు ఎ longప్రమేయం ఉన్నట్లయితే, విలువ యొక్క విలువ intaకి మార్చబడుతుంది longమరియు అప్పుడు మాత్రమే ఆపరేషన్ కొనసాగుతుంది:

int a = 1;
long b = 2;
long c = a + b;

ఫ్లోటింగ్ పాయింట్ సంఖ్యలు

వ్యక్తీకరణలో పూర్ణాంకం మరియు ఫ్లోటింగ్ పాయింట్ సంఖ్య ( floatలేదా ) చేరి ఉంటే, పూర్ణాంకం ఫ్లోటింగ్ పాయింట్ నంబర్ ( లేదా ) doubleగా మార్చబడుతుంది మరియు అప్పుడు మాత్రమే ఆపరేషన్ చేయబడుతుంది.floatdouble

ఆపరేషన్‌లో a floatమరియు a ఉంటే double, అది floata గా మార్చబడుతుంది double. నిజానికి ఊహించినదే.

byteమీరు aతో గుణిస్తే short, మీకు ఒక వస్తుంది int. byteమీరు aతో గుణిస్తే byte, మీకు ఒక వస్తుంది int. byteమీరు ఒక మరియు ఒక జోడించినప్పటికీ byte, మీరు ఒక పొందుతారు int.

దీనికి అనేక కారణాలు ఉన్నాయి. ఉదాహరణలు:

byte a = 110;
byte b = 120;
byte c = a * b;  // Error

byte a = 110;
byte b = 120;
byte c = a + b; // Error

సాధారణంగా, 8-బిట్ (1 బైట్) సంఖ్యను 8-బిట్ (1 బైట్) సంఖ్యతో గుణించినప్పుడు, మనకు 16-బిట్‌ల బిట్‌లను (2 బైట్‌లు) ఆక్రమించే సంఖ్య వస్తుంది.

తత్ఫలితంగా, పూర్ణాంకాల రకాలు కలిగిన అన్ని కార్యకలాపాలు intఎల్లప్పుడూ intsకి మార్చబడతాయి. మరియు మీరు గణన ఫలితాన్ని ఒక కంటే చిన్న రకం వేరియబుల్‌లో నిల్వ చేయాలనుకుంటే int, మీరు ఎల్లప్పుడూ టైప్‌కాస్ట్ ఆపరేటర్‌ని స్పష్టంగా పేర్కొనవలసి ఉంటుంది.

ఉదాహరణలు:

byte a = 110;
byte b = 120;
byte c = (byte) (a * b);

byte a = 110;
byte b = 120;
byte c = (byte) (a + b);

byte a = 1;
byte b = (byte) (a + 1);

5. ఒక ముఖ్యమైన స్వల్పభేదాన్ని

టైప్‌కాస్ట్ ఆపరేటర్‌కు చాలా ఎక్కువ ప్రాధాన్యత ఉంది.

అంటే ఎక్స్‌ప్రెషన్‌లో, ఉదాహరణకు, అదనంగా మరియు టైప్‌కాస్ట్ ఆపరేటర్ ఉంటే, టైప్‌కాస్ట్ జోడింపుకు ముందు ప్రదర్శించబడుతుంది.

ఉదాహరణ:

byte a = 1;
byte b = 2;
byte c = (byte) a * b;

byte a = 1;
byte b = 2;
byte c = (byte) (a * b);

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