రకం మార్పిడి

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

"మీరు ఒకదానికొకటి వివిధ రకాల వేరియబుల్స్‌ను కేటాయించవచ్చు. అలా చేయడం ద్వారా, ఒక వేరియబుల్ (నిర్దిష్ట రకం) విలువ ఇతర రకం విలువగా మార్చబడుతుంది మరియు ఇతర వేరియబుల్‌కు కేటాయించబడుతుంది. "

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

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

"కేవలం రెండు వ్యాఖ్యలు:

1. చార్ యొక్క బాస్కెట్ చిన్న వాటి పరిమాణంలో ఉంటుంది, కానీ మీరు వస్తువులను ఒకదాని నుండి మరొకదానికి స్వేచ్ఛగా తరలించలేరు. మీరు విలువలను షార్ట్ నుండి చార్ కు తరలించినప్పుడు , 0 కంటే తక్కువ ఉన్న విలువలు ఎల్లప్పుడూ పోతాయి. మీరు విలువలను చార్ నుండి చిన్నదానికి తరలించినప్పుడు, 32,000 కంటే ఎక్కువ విలువలు కోల్పోతాయి.

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

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

"మీరు వివిధ రకాల వేరియబుల్స్‌ను ఈ విధంగా కేటాయించాలి:"

byte a = 115;
int b = a;

int c = 10000;
byte d = (byte) c;

int c = 10;
byte d = (byte) c;

float f = 10000;
long l = (long) (f * f);
float f2 = l;
long l2 = (long) f2;

double d = 1;
float f = (float) d;
long l = (long) f;
int i = (int) l;
short s = (short) i;
byte b = (byte) s;

" ఒక తారాగణం ఆపరేటర్ తప్పనిసరిగా సంఖ్య/వేరియబుల్ ముందు ఉంచబడాలి, సంఖ్యలో కొంత భాగం విస్మరించబడినప్పుడు లేదా సంకుచితమైన ఆదిమ మార్పిడి సంభవించినప్పుడు. తారాగణం ఆపరేటర్ దానిని నేరుగా అనుసరించే సంఖ్య/చరరాశిని మాత్రమే ప్రభావితం చేస్తుంది."

float f = 10000;
long l = (long) f * f;

float f = 10000;
long l = (long) (f * f);

"అలాగా."