1. టైప్ కాస్టింగ్
వివిధ రకాల సంఖ్యలను నిల్వ చేయడానికి ఆదిమ రకాల వేరియబుల్స్ (రకం మినహా boolean
) ఉపయోగించబడతాయి. వేరియబుల్స్ రకాలు ఎప్పుడూ మారనప్పటికీ, మీరు ఒక రకం నుండి మరొక రకంకి మార్చగల స్థలం ఉంది. మరియు ఆ స్థలం అసైన్మెంట్ .
వివిధ రకాల వేరియబుల్స్ ఒకదానికొకటి కేటాయించబడతాయి. మీరు ఇలా చేసినప్పుడు ఒక రకం వేరియబుల్ విలువ మరొక రకం విలువగా మార్చబడుతుంది మరియు రెండవ వేరియబుల్కు కేటాయించబడుతుంది. ఈ విషయంలో, మేము రెండు రకాలైన రకం మార్పిడిని గుర్తించగలము: వెడల్పు మరియు సంకుచితం.
వెడల్పు చేయడం అనేది విలువను చిన్న బుట్ట నుండి పెద్దదానికి తరలించడం వంటిది: ఈ ఆపరేషన్ అతుకులు మరియు నొప్పిలేకుండా ఉంటుంది. మీరు పెద్ద బుట్ట నుండి చిన్నదానికి విలువను తరలించినప్పుడు సంకుచితం జరుగుతుంది: తగినంత స్థలం ఉండకపోవచ్చు మరియు మీరు ఏదైనా విసిరివేయవలసి ఉంటుంది.
బాస్కెట్ పరిమాణం ఆధారంగా క్రమబద్ధీకరించబడిన రకాలు ఇక్కడ ఉన్నాయి:
2. వైడెనింగ్ రకం మార్పిడులు
ఒక సంఖ్యా రకానికి చెందిన వేరియబుల్ను మరొక సంఖ్యా రకానికి చెందిన వేరియబుల్కు కేటాయించడం తరచుగా అవసరం. మీరు అది ఎలా చేశారు?
జావాలో 4 పూర్ణాంకాల రకాలు ఉన్నాయి:
టైప్ చేయండి | పరిమాణం |
---|---|
byte |
1 byte |
short |
2 bytes |
int |
4 bytes |
long |
8 bytes |
చిన్న బుట్టలలో నిల్వ చేయబడిన వేరియబుల్ ఎల్లప్పుడూ పెద్ద బుట్టలలో నిల్వ చేయబడిన వేరియబుల్స్కు కేటాయించబడుతుంది.
int
, short
మరియు byte
వేరియబుల్స్ సులభంగా వేరియబుల్స్కు కేటాయించబడతాయి long
. short
మరియు byte
వేరియబుల్స్ వేరియబుల్స్కు కేటాయించబడతాయి int
. మరియు byte
వేరియబుల్స్ను వేరియబుల్స్కు కేటాయించవచ్చు short
.
ఉదాహరణలు:
కోడ్ | వివరణ |
---|---|
|
ఈ కోడ్ బాగా కంపైల్ చేస్తుంది. |
అటువంటి మార్పిడిని, చిన్నది నుండి పెద్ద రకానికి, వైడ్నింగ్ టైప్ కన్వర్షన్ అంటారు.
వాస్తవ సంఖ్యల సంగతేంటి?
వారితో, ప్రతిదీ ఒకేలా ఉంటుంది - పరిమాణం ముఖ్యమైనది:
టైప్ చేయండి | పరిమాణం |
---|---|
float |
4 bytes |
double |
8 bytes |
float
double
వేరియబుల్స్ ఎటువంటి సమస్యలు లేకుండా వేరియబుల్స్కు కేటాయించబడతాయి . కానీ పూర్ణాంకాల రకాలతో విషయాలు మరింత ఆసక్తికరంగా ఉంటాయి.
మీరు వేరియబుల్కు ఏదైనా పూర్ణాంకం వేరియబుల్ని కేటాయించవచ్చు float
. long
8 బైట్ల పొడవు ఉండే రకం కూడా . float
మరియు మీరు ఏదైనా పూర్ణాంకం వేరియబుల్ లేదా వేరియబుల్ - వేరియబుల్కు కావలసినది కేటాయించవచ్చు double
:
కోడ్ | గమనిక |
---|---|
|
|
వాస్తవ రకానికి మార్చడం వలన తగినంత ముఖ్యమైన అంకెలు లేకపోవటం వలన ఖచ్చితత్వం కోల్పోవచ్చని గమనించండి.
పూర్ణాంకాల నుండి ఫ్లోటింగ్ పాయింట్ సంఖ్యలకు మార్చేటప్పుడు, సంఖ్యల దిగువ ఆర్డర్ భాగాలు విస్మరించబడవచ్చు. అయితే పాక్షిక సంఖ్యలు సుమారుగా విలువలను నిల్వ చేయడానికి అర్థం చేసుకున్నందున, అటువంటి అసైన్మెంట్ కార్యకలాపాలు అనుమతించబడతాయి.
3. సంకుచిత రకం మార్పిడులు
ఇతర అవకాశాల గురించి ఏమిటి? long
మీరు వేరియబుల్కు విలువను కేటాయించవలసి వస్తే int
?
ఒక వేరియబుల్ను బుట్టగా ఊహించుకోండి. మేము వివిధ పరిమాణాల బుట్టలను కలిగి ఉన్నాము: 1, 2, 4 మరియు 8 బైట్లు. ఆపిల్లను చిన్న బుట్ట నుండి పెద్దదానికి బదిలీ చేయడం సమస్య కాదు. కానీ పెద్ద బుట్ట నుండి చిన్నదానికి మారినప్పుడు, కొన్ని యాపిల్స్ కోల్పోవచ్చు.
ఈ పరివర్తన - పెద్ద రకం నుండి చిన్న రకానికి - సంకుచిత రకం మార్పిడి అంటారు . ఇలాంటి అసైన్మెంట్ ఆపరేషన్ చేస్తున్నప్పుడు, నంబర్లోని కొంత భాగం కొత్త వేరియబుల్కి సరిపోకపోవచ్చు మరియు అందువల్ల విస్మరించబడవచ్చు.
ఒక రకాన్ని తగ్గించేటప్పుడు, మనం పొరపాటు చేయడం లేదని, ఉద్దేశపూర్వకంగా సంఖ్యలోని కొంత భాగాన్ని విస్మరిస్తున్నామని కంపైలర్కి స్పష్టంగా చెప్పాలి. టైప్కాస్ట్ ఆపరేటర్ దీని కోసం ఉపయోగించబడుతుంది. కుండలీకరణాల్లో ఇది ఒక రకం పేరు .
అటువంటి పరిస్థితులలో, జావా కంపైలర్కి టైప్కాస్ట్ ఆపరేటర్ను పేర్కొనడం ప్రోగ్రామర్ అవసరం. సాధారణంగా, ఇది ఇలా కనిపిస్తుంది:
(type) expression
ఉదాహరణలు:
కోడ్ | వివరణ |
---|---|
|
ప్రతిసారీ టైప్కాస్ట్ ఆపరేటర్ని స్పష్టంగా సూచించాలి |
ఇక్కడ a
కు సమానం 1
, మరియు బహుశా టైప్కాస్ట్ ఆపరేటర్ ఓవర్ కిల్ లాగా ఉండవచ్చు. కానీ a
పెద్దవి అయితే?
కోడ్ | వివరణ |
---|---|
|
|
long
ఒక మిలియన్ ఒక మరియు ఒక లోకి ఖచ్చితంగా సరిపోతుంది int
. కానీ ఒక వేరియబుల్కు ఒక మిలియన్ని కేటాయించినప్పుడు short
, మొదటి రెండు బైట్లు విస్మరించబడతాయి మరియు చివరి రెండు బైట్లు మాత్రమే అలాగే ఉంచబడతాయి. మరియు a కి కేటాయించేటప్పుడు byte
, చివరి బైట్ మాత్రమే మిగిలి ఉంటుంది.
మెమరీలో సంఖ్యలు ఎలా అమర్చబడి ఉంటాయి:
టైప్ చేయండి | బైనరీ సంజ్ఞామానం | దశాంశ సంజ్ఞామానం |
---|---|---|
int |
0b 00000000 00001111 01000010 01000000 | 1000000 |
short |
0b 01000010 01000000 | 16.960 |
byte |
0b 01000000 | 64 |
char
రకం
A char
, a లాగా short
, రెండు బైట్లను ఆక్రమిస్తుంది, కానీ ఒకదానిని మరొకదానికి మార్చడానికి, మీరు ఎల్లప్పుడూ టైప్కాస్ట్ ఆపరేటర్ని ఉపయోగించాలి. ఇక్కడ సమస్య ఏమిటంటే, రకం సంతకం చేయబడింది మరియు నుండి short
విలువలను కలిగి ఉంటుంది , కానీ రకం సంతకం చేయబడలేదు మరియు నుండి వరకు విలువలను కలిగి ఉంటుంది .-32,768
+32,767
char
0
65,535
ప్రతికూల సంఖ్యలు a లో నిల్వ చేయబడవు char
, కానీ అవి a లో నిల్వ చేయబడతాయి short
. మరియు a short
కంటే పెద్ద సంఖ్యలను నిల్వ చేయలేము 32,767
, కానీ అటువంటి సంఖ్యలను a లో నిల్వ చేయవచ్చు char
.
4. వ్యక్తీకరణ రకం
ఒకే వ్యక్తీకరణలో వివిధ రకాల వేరియబుల్స్ ఉపయోగించినట్లయితే? తార్కికంగా, వాటిని మొదట సాధారణ రకానికి మార్చాల్సిన అవసరం ఉందని మేము అర్థం చేసుకున్నాము. అయితే ఏది?
పెద్దదానికి, వాస్తవానికి.
జావా ఎల్లప్పుడూ పెద్ద రకానికి మారుస్తుంది. స్థూలంగా చెప్పాలంటే, రకంలో ఒకటి మొదట విస్తృతం చేయబడింది మరియు ఆ తర్వాత మాత్రమే అదే రకమైన విలువలను ఉపయోగించి ఆపరేషన్ నిర్వహించబడుతుంది.
ఒక ఎక్స్ప్రెషన్లో ఒక int
మరియు ఎ long
ప్రమేయం ఉన్నట్లయితే, విలువ యొక్క విలువ int
aకి మార్చబడుతుంది long
మరియు అప్పుడు మాత్రమే ఆపరేషన్ కొనసాగుతుంది:
కోడ్ | వివరణ |
---|---|
|
a a కి విస్తరించబడుతుంది long మరియు తరువాత అదనంగా జరుగుతుంది. |
ఫ్లోటింగ్ పాయింట్ సంఖ్యలు
వ్యక్తీకరణలో పూర్ణాంకం మరియు ఫ్లోటింగ్ పాయింట్ సంఖ్య ( float
లేదా ) చేరి ఉంటే, పూర్ణాంకం ఫ్లోటింగ్ పాయింట్ నంబర్ ( లేదా ) double
గా మార్చబడుతుంది మరియు అప్పుడు మాత్రమే ఆపరేషన్ చేయబడుతుంది.float
double
ఆపరేషన్లో a float
మరియు a ఉంటే double
, అది float
a గా మార్చబడుతుంది double
. నిజానికి ఊహించినదే.
ఒకదానితో ఒకటి సంభాషించేటప్పుడు byte
, short
, మరియు రకాలు char
ఎల్లప్పుడూ మార్చబడతాయి . రకాన్ని ప్రామాణిక పూర్ణాంక రకంగా పరిగణించడానికి int
మంచి కారణం ఉంది .int
byte
మీరు aతో గుణిస్తే short
, మీకు ఒక వస్తుంది int
. byte
మీరు aతో గుణిస్తే byte
, మీకు ఒక వస్తుంది int
. byte
మీరు ఒక మరియు ఒక జోడించినప్పటికీ byte
, మీరు ఒక పొందుతారు int
.
దీనికి అనేక కారణాలు ఉన్నాయి. ఉదాహరణలు:
కోడ్ | వివరణ |
---|---|
|
110 * 120 , ఇది 13,200 రకం గరిష్ట విలువ కంటే కొంచెం ఎక్కువగా ఉంటుంది byte :127 |
|
110 + 120 , ఇది 230 రకం గరిష్ట విలువ కంటే కొంచెం ఎక్కువగా ఉంటుంది byte :127 |
సాధారణంగా, 8-బిట్ (1 బైట్) సంఖ్యను 8-బిట్ (1 బైట్) సంఖ్యతో గుణించినప్పుడు, మనకు 16-బిట్ల బిట్లను (2 బైట్లు) ఆక్రమించే సంఖ్య వస్తుంది.
తత్ఫలితంగా, పూర్ణాంకాల రకాలు కలిగిన అన్ని కార్యకలాపాలు int
ఎల్లప్పుడూ int
sకి మార్చబడతాయి. మరియు మీరు గణన ఫలితాన్ని ఒక కంటే చిన్న రకం వేరియబుల్లో నిల్వ చేయాలనుకుంటే int
, మీరు ఎల్లప్పుడూ టైప్కాస్ట్ ఆపరేటర్ని స్పష్టంగా పేర్కొనవలసి ఉంటుంది.
ఉదాహరణలు:
కోడ్ | వివరణ |
---|---|
|
వ్యక్తీకరణ byte * byte ఒక ఉంటుందిint |
|
వ్యక్తీకరణ byte + byte ఒక ఉంటుందిint |
|
వ్యక్తీకరణ byte + int ఒక ఉంటుంది int అక్షరార్థం ఒక int . |
5. ఒక ముఖ్యమైన స్వల్పభేదాన్ని
టైప్కాస్ట్ ఆపరేటర్కు చాలా ఎక్కువ ప్రాధాన్యత ఉంది.
అంటే ఎక్స్ప్రెషన్లో, ఉదాహరణకు, అదనంగా మరియు టైప్కాస్ట్ ఆపరేటర్ ఉంటే, టైప్కాస్ట్ జోడింపుకు ముందు ప్రదర్శించబడుతుంది.
ఉదాహరణ:
కోడ్ | వివరణ |
---|---|
|
టైప్కాస్ట్ ఆపరేటర్ వేరియబుల్కు మాత్రమే వర్తించబడుతుంది a , ఇది ఇప్పటికే ఒక byte . ఈ కోడ్ కంపైల్ చేయబడదు. |
|
ఇదే సరైన మార్గం. |
మీరు ఎక్స్ప్రెషన్లోని ఒక భాగం మాత్రమే కాకుండా మొత్తం వ్యక్తీకరణను నిర్దిష్ట రకానికి మార్చాలనుకుంటే, మొత్తం వ్యక్తీకరణను కుండలీకరణాల్లో చుట్టి, టైప్కాస్ట్ ఆపరేటర్ను ముందు ఉంచండి.
GO TO FULL VERSION