ఆదిమ రకాలను విస్తరించడం మరియు తగ్గించడం

హాయ్! మీరు కోడ్‌జిమ్ ద్వారా పురోగమిస్తున్నందున, మీరు చాలాసార్లు ఆదిమ రకాలను ఎదుర్కొన్నారు. వాటి గురించి మనకు తెలిసిన వాటి యొక్క చిన్న జాబితా ఇక్కడ ఉంది:

1. అవి వస్తువులు కావు మరియు మెమరీలో నిల్వ చేయబడిన విలువను సూచిస్తాయి
2. అనేక రకాలు ఉన్నాయి
   • పూర్తి సంఖ్యలు: బైట్ , చిన్నది , పూర్ణాంకం , పొడవు
   • ఫ్లోటింగ్ పాయింట్ (ఫ్రాక్షనల్) సంఖ్యలు: ఫ్లోట్ మరియు డబుల్
   • తార్కిక విలువలు: బూలియన్
   • సింబాలిక్ విలువలు (అక్షరాలు మరియు సంఖ్యలను సూచించడానికి): చార్

3. ప్రతి రకానికి దాని స్వంత విలువల పరిధి ఉంటుంది:

కానీ వేర్వేరు విలువలను కలిగి ఉండటంతో పాటు, అవి మెమరీలో ఎంత స్థలాన్ని ఆక్రమించాలో కూడా తేడా ఉంటుంది. ఒక Int బైట్ కంటే ఎక్కువ పడుతుంది. మరియు పొట్టిదాని కంటే పొడవు పెద్దది. ఆదిమానవులు ఆక్రమించిన మెమరీ మొత్తాన్ని రష్యన్ గూడు బొమ్మలతో పోల్చవచ్చు: ప్రతి గూడు బొమ్మ లోపల స్థలం అందుబాటులో ఉంటుంది. గూడు కట్టుకునే బొమ్మ ఎంత పెద్దదైతే అంత స్థలం ఉంటుంది. ఒక పెద్ద గూడు బొమ్మ ( పొడవాటి ) చిన్న పూర్ణాంకానికి సులభంగా వసతి కల్పిస్తుంది . ఇది సులభంగా సరిపోతుంది మరియు మీరు వేరే ఏమీ చేయవలసిన అవసరం లేదు. జావాలో, ఆదిమలతో పని చేస్తున్నప్పుడు, దీనిని అవ్యక్త మార్పిడి అంటారు. లేదా వేరే విధంగా ఉంచితే, దానిని వెడల్పు అంటారు.

జావాలో విస్తరిస్తోంది

విస్తృత మార్పిడికి ఇక్కడ ఒక సాధారణ ఉదాహరణ:

public class Main {

   public static void main(String[] args) {
      
       int bigNumber = 10000000;

       byte littleNumber = 16;

       bigNumber = littleNumber;
       System.out.println(bigNumber);
   }
}

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

public static void main(String[] args) {

   int bigNumber = 10000000;
  
   short littleNumber = 1000;

   littleNumber = bigNumber;// Error!
   System.out.println(bigNumber);
}

లోపం! మీరు ఒక పెద్ద గూడు బొమ్మను ( పూర్ణాంకానికి ) చిన్నది ( చిన్న ) లోపల ఉంచడం ద్వారా మీరు అసాధారణమైనదాన్ని చేయడానికి ప్రయత్నిస్తున్నారని కంపైలర్ అర్థం చేసుకుంటుంది . ఈ సందర్భంలో, కంపైలేషన్ ఎర్రర్ అనేది కంపైలర్ నుండి ఒక హెచ్చరిక: "హే, మీరు దీన్ని చేయాలనుకుంటున్నారని మీరు ఖచ్చితంగా అనుకుంటున్నారా?" మీకు ఖచ్చితంగా తెలిస్తే, మీరు కంపైలర్‌కి ఇలా చెప్పండి: "అంతా ఓకే. నేను ఏమి చేస్తున్నానో నాకు తెలుసు!" ఈ ప్రక్రియను స్పష్టమైన రకం మార్పిడి లేదా సంకుచితం అంటారు.

జావాలో సంకుచితం

సంకుచిత మార్పిడిని నిర్వహించడానికి, మీరు మీ విలువను మార్చాలనుకుంటున్న రకాన్ని స్పష్టంగా సూచించాలి. మరో మాటలో చెప్పాలంటే, మీరు కంపైలర్ యొక్క ప్రశ్నకు సమాధానం ఇవ్వాలి: "సరే, ఈ చిన్న గూడు బొమ్మలలో ఏ పెద్ద బొమ్మను మీరు ఉంచాలనుకుంటున్నారు?" మా విషయంలో, ఇది ఇలా కనిపిస్తుంది:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = (short) bigNumber;
   System.out.println(littleNumber);
}

మేము ఒక చిన్న వేరియబుల్‌లో పూర్ణాంకాన్ని ఉంచాలనుకుంటున్నామని మరియు మేము బాధ్యత తీసుకుంటామని మేము స్పష్టంగా సూచిస్తాము. ఇరుకైన రకం స్పష్టంగా సూచించబడిందని చూసినప్పుడు, కంపైలర్ మార్పిడిని నిర్వహిస్తుంది. ఫలితం ఏమిటి? కన్సోల్ అవుట్‌పుట్: -27008 అది కొంచెం ఊహించనిది. మనం సరిగ్గా ఎందుకు పొందాము? నిజానికి, ఇదంతా చాలా సులభం. వాస్తవానికి, విలువ 10000000 ఇది 32 బిట్‌లను ఆక్రమించే పూర్ణాంక వేరియబుల్‌లో నిల్వ చేయబడింది. ఇది దాని బైనరీ ప్రాతినిధ్యం: మేము ఈ విలువను చిన్న వేరియబుల్‌గా వ్రాస్తాము, ఇది 16 బిట్‌లను మాత్రమే నిల్వ చేయగలదు! దీని ప్రకారం, మన నంబర్‌లోని మొదటి 16 బిట్‌లు మాత్రమే అక్కడికి తరలించబడతాయి. మిగిలినవి విస్మరించబడతాయి. ఫలితంగా, చిన్న వేరియబుల్ క్రింది విలువను పొందుతుంది దశాంశ రూపంలో ఇది -27008కి సమానం కాబట్టి కంపైలర్ ఒక నిర్దిష్ట రకానికి స్పష్టమైన సంకుచిత మార్పిడిని సూచించడం ద్వారా "నిర్ధారించమని" అడుగుతుంది. మొదట, మీరు ఫలితానికి బాధ్యత వహిస్తున్నారని ఇది చూపిస్తుంది. మరియు రెండవది, కన్వర్టింగ్ జరిగినప్పుడు ఎంత స్థలాన్ని కేటాయించాలో కంపైలర్‌కి తెలియజేస్తుంది. అన్నింటికంటే, చివరి ఉదాహరణలో, మేము చిన్నదిగా కాకుండా బైట్ వేరియబుల్‌కు పూర్ణాంక విలువను కేటాయించినట్లయితే , మన వద్ద 16 కాకుండా 8 బిట్‌లు మాత్రమే ఉంటాయి మరియు ఫలితం భిన్నంగా ఉంటుంది. పాక్షిక రకాలు ( ఫ్లోట్ మరియు డబుల్ ) సంకుచిత మార్పిడుల కోసం వాటి స్వంత ప్రక్రియను కలిగి ఉంటాయి. మీరు ఫ్యాక్షన్ సంఖ్యను పూర్ణాంక రకానికి ప్రసారం చేయడానికి ప్రయత్నిస్తే, పాక్షిక భాగం విస్మరించబడుతుంది.

public static void main(String[] args) {

   double d = 2.7;

   long x = (int) d;
   System.out.println(x);
}

కన్సోల్ అవుట్‌పుట్: 2

చార్

వ్యక్తిగత అక్షరాలను ప్రదర్శించడానికి చార్ ఉపయోగించబడుతుందని మీకు ఇప్పటికే తెలుసు .

public static void main(String[] args) {

   char c = '!';
   char z = 'z';
   char i = '8';
  
}

కానీ ఈ డేటా రకం అర్థం చేసుకోవడానికి ముఖ్యమైన అనేక లక్షణాలను కలిగి ఉంది. విలువ పరిధుల పట్టికను మళ్లీ చూద్దాం: చార్ రకం కోసం పరిధి 0 నుండి 65536 వరకు సూచించబడింది . కానీ దాని అర్థం ఏమిటి? అన్నింటికంటే, అక్షరం కేవలం సంఖ్యలను మాత్రమే సూచిస్తుంది, కానీ అక్షరాలు, విరామ చిహ్నాలను కూడా సూచిస్తుంది... విషయం ఏమిటంటే జావాలో చార్ విలువలు యూనికోడ్ ఆకృతిలో నిల్వ చేయబడతాయి. మేము ఇప్పటికే మునుపటి పాఠాలలో ఒకదానిలో యూనికోడ్‌ని ఎదుర్కొన్నాము. యూనికోడ్ అనేది ప్రపంచంలోని దాదాపు అన్ని లిఖిత భాషల చిహ్నాలను కలిగి ఉండే అక్షర ఎన్‌కోడింగ్ ప్రమాణం అని మీరు బహుశా గుర్తుంచుకోవచ్చు. మరో మాటలో చెప్పాలంటే, ఇది ఏ భాషలోనైనా దాదాపు ప్రతి అక్షరాన్ని సూచించే ప్రత్యేక కోడ్‌ల జాబితా. మొత్తం యూనికోడ్ పట్టిక చాలా పెద్దది, అయితే, దానిని హృదయపూర్వకంగా నేర్చుకోవాల్సిన అవసరం లేదు. దానిలోని చిన్న భాగం ఇక్కడ ఉంది: ప్రధాన విషయం ఏమిటంటే, అక్షరాలు ఎలా నిల్వ చేయబడతాయో అర్థం చేసుకోవడం మరియు నిర్దిష్ట పాత్ర కోసం మీకు కోడ్ తెలిస్తే, మీరు ఎల్లప్పుడూ మీ ప్రోగ్రామ్‌లో ఆ అక్షరాన్ని ఉత్పత్తి చేయవచ్చని గుర్తుంచుకోండి. కొన్ని యాదృచ్ఛిక సంఖ్యతో ప్రయత్నిద్దాం:

public static void main(String[] args) {

   int x = 32816;

   char c = (char) x ;
   System.out.println(c);
}

కన్సోల్ అవుట్‌పుట్: 耰 ఇది జావాలో చార్ లను నిల్వ చేయడానికి ఉపయోగించే ఫార్మాట్ . ప్రతి గుర్తు ఒక సంఖ్యకు అనుగుణంగా ఉంటుంది: 16-బిట్ (రెండు-బైట్) సంఖ్యా కోడ్. యూనికోడ్‌లో, 32816 చైనీస్ అక్షరం 耰కి అనుగుణంగా ఉంటుంది. కింది విషయాన్ని గమనించండి. ఈ ఉదాహరణలో, మేము పూర్ణాంక వేరియబుల్‌ని ఉపయోగించాము. ఇది మెమరీలో 32 బిట్‌లను ఆక్రమిస్తుంది, అయితే ఒక చార్ 16ని ఆక్రమిస్తుంది. ఇక్కడ మనం ఒక పూర్ణాంకాన్ని ఎంచుకున్నాము, ఎందుకంటే మన సంఖ్య (32816) చిన్నదానికి సరిపోదు . చార్ యొక్క పరిమాణం 16 బిట్‌లు అయినప్పటికీ , చార్ పరిధిలో ప్రతికూల సంఖ్యలు లేవు , కాబట్టి చార్ యొక్క "పాజిటివ్" భాగంపరిధి రెండు రెట్లు పెద్దది ( చిన్న రకానికి 32767కి బదులుగా 65536 ). మా కోడ్ 65536 కంటే తక్కువగా ఉన్నంత వరకు మేము పూర్ణాంకాన్ని ఉపయోగించవచ్చు. కానీ మీరు 65536 కంటే ఎక్కువ పూర్ణాంక విలువను సృష్టిస్తే, అది 16 బిట్‌ల కంటే ఎక్కువ ఆక్రమిస్తుంది. మరియు ఇది సంకుచిత మార్పిడికి దారి తీస్తుంది

char c = (char) x;

అదనపు బిట్‌లు విస్మరించబడతాయి (పైన చర్చించినట్లు) మరియు ఫలితం ఊహించని విధంగా ఉంటుంది.

అక్షరాలు మరియు పూర్ణాంకాలను జోడించే ప్రత్యేక లక్షణాలు

అసాధారణమైన ఉదాహరణను చూద్దాం:

public class Main {

   public static void main(String[] args) {

      char c = '1';

      int i = 1;

       System.out.println(i + c);
   }
}

కన్సోల్ అవుట్‌పుట్: 50 O_О ఎలా అర్ధమవుతుంది? 1+1. 50 ఎక్కడి నుంచి వచ్చాయి?! charవిలువలు మెమరీలో 0 నుండి 65536 పరిధిలోని సంఖ్యలుగా నిల్వ చేయబడతాయని మరియు ఈ సంఖ్యలు అక్షరానికి యూనికోడ్ ప్రాతినిధ్యం అని మీకు ఇప్పటికే తెలుసు . మేము చార్ మరియు కొంత మొత్తం-సంఖ్య రకాన్ని జోడించినప్పుడు , చార్ సంబంధిత యూనికోడ్ నంబర్‌కి మార్చబడుతుంది. మా కోడ్‌లో, మేము 1 మరియు '1'ని జోడించినప్పుడు, '1' గుర్తు దాని స్వంత కోడ్‌గా మార్చబడింది, అది 49 (మీరు దీన్ని పై పట్టికలో ధృవీకరించవచ్చు). కాబట్టి, ఫలితం 50. మరోసారి మన పాత స్నేహితుని 耰 ఉదాహరణగా తీసుకుని, దానిని కొంత సంఖ్యకు జోడించి ప్రయత్నించండి.

public static void main(String[] args) {

   char c = '耰';
   int x = 200;

   System.out.println(c + x);
}

కన్సోల్ అవుట్‌పుట్: 33016 耰 32816కి అనుగుణంగా ఉందని మేము ఇప్పటికే కనుగొన్నాము. మరియు మేము ఈ సంఖ్యను మరియు 200ని జోడించినప్పుడు, మన ఫలితాన్ని పొందుతాము: 33016. :) మీరు చూడగలిగినట్లుగా, ఇక్కడ అల్గోరిథం చాలా సులభం, కానీ మీరు దానిని మరచిపోకూడదు. .