आदिम प्रकारांचे रुंदीकरण आणि अरुंदीकरण

हाय! तुम्ही CodeGym मधून प्रगती करत असताना, तुम्हाला अनेक वेळा आदिम प्रकारांचा सामना करावा लागला आहे. आम्हाला त्यांच्याबद्दल काय माहित आहे याची एक छोटी यादी येथे आहे:

1. ते वस्तू नाहीत आणि मेमरीमध्ये साठवलेल्या मूल्याचे प्रतिनिधित्व करतात
2. अनेक प्रकार आहेत
   • पूर्ण संख्या: बाइट , लहान , इंट , लांब
   • फ्लोटिंग-पॉइंट (अपूर्णांक) संख्या: फ्लोट आणि दुहेरी
   • तार्किक मूल्ये: बुलियन
   • प्रतिकात्मक मूल्ये (अक्षरे आणि अंकांचे प्रतिनिधित्व करण्यासाठी): char

3. प्रत्येक प्रकारच्या मूल्यांची स्वतःची श्रेणी असते:

परंतु भिन्न मूल्ये असण्याव्यतिरिक्त, ते मेमरीमध्ये किती जागा व्यापतात यात देखील फरक आहे. इंटला बाइटपेक्षा जास्त वेळ लागतो . आणि एक लहान पेक्षा मोठा आहे. आदिमानवांनी व्यापलेल्या मेमरीची रशियन नेस्टिंग बाहुल्यांशी तुलना केली जाऊ शकते: प्रत्येक नेस्टिंग बाहुलीमध्ये आत जागा उपलब्ध असते. घरटी बाहुली जितकी मोठी तितकी जागा जास्त. एक मोठी नेस्टिंग बाहुली ( लांब ) एक लहान इंट सहज सामावून घेईल . हे सहजपणे बसते आणि आपल्याला दुसरे काहीही करण्याची आवश्यकता नाही. जावामध्ये, आदिम सह कार्य करताना, याला अंतर्निहित रूपांतरण म्हणतात. किंवा वेगळ्या पद्धतीने सांगा, त्याला रुंदीकरण म्हणतात.

जावा मध्ये रुंदीकरण

रुंदीकरण रूपांतरणाचे येथे एक साधे उदाहरण आहे:

public class Main {

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

       byte littleNumber = 16;

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

येथे आपण इंट व्हेरिएबलला बाइट व्हॅल्यू नियुक्त करतो . असाइनमेंट कोणत्याही समस्यांशिवाय यशस्वी होते: बाइटमध्ये साठवलेले मूल्य int जे सामावून घेऊ शकते त्यापेक्षा कमी मेमरी घेते. लहान नेस्टिंग डॉल (बाइट व्हॅल्यू) मोठ्या नेस्टिंग डॉलमध्ये ( इंट व्हेरिएबल) सहज बसते. तुम्ही उलट करण्याचा प्रयत्न केलात तर ती वेगळी बाब आहे, म्हणजे व्हेरिएबलमध्ये मोठी व्हॅल्यू टाकणे ज्याची रेंज एवढा मोठा डेटा प्रकार सामावून घेऊ शकत नाही. खऱ्या नेस्टिंग बाहुल्यांसह, संख्या फक्त फिट होणार नाही. Java सह, हे शक्य आहे, परंतु बारकावे सह. लहान व्हेरिएबलमध्ये int टाकण्याचा प्रयत्न करूया :

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 होते ते एका int व्हेरिएबलमध्ये संग्रहित होते, जे 32 बिट्स व्यापते. हे त्याचे बायनरी प्रतिनिधित्व आहे: आम्ही हे मूल्य एका लहान व्हेरिएबलमध्ये लिहितो, जे फक्त 16 बिट संचयित करू शकते! त्यानुसार, आमच्या नंबरचे फक्त पहिले 16 बिट तिथे हलवले जातील. बाकी टाकून दिले जाईल. परिणामी, लहान व्हेरिएबलला खालील मूल्य प्राप्त होते जे दशांश स्वरूपात -27008 च्या बरोबरीचे आहे म्हणूनच कंपाइलर तुम्हाला विशिष्ट प्रकारात स्पष्टपणे संकुचित रूपांतरण दर्शवून "पुष्टी" करण्यास सांगतो. प्रथम, हे दर्शविते की आपण निकालाची जबाबदारी घेत आहात. आणि दुसरे, ते कंपाइलरला सांगते की कन्व्हर्ट करताना किती जागा द्यावी. शेवटी, शेवटच्या उदाहरणात, जर आपण बाइट व्हेरिएबलला शॉर्ट ऐवजी इंट व्हॅल्यू नियुक्त केले , तर आपल्याकडे फक्त 8 बिट असतील, 16 नाही, आणि परिणाम वेगळा असेल. फ्रॅक्शनल प्रकार ( फ्लोट आणि दुहेरी ) ची रूपांतरणे कमी करण्यासाठी स्वतःची प्रक्रिया असते. तुम्ही पूर्णांक प्रकारात दुफळी क्रमांक टाकण्याचा प्रयत्न केल्यास, अंशात्मक भाग टाकून दिला जाईल.

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 श्रेणी दर्शविली आहे . पण याचा अर्थ काय? शेवटी, वर्ण केवळ संख्या दर्शवत नाही तर अक्षरे, विरामचिन्हे देखील दर्शवितात... गोष्ट अशी आहे की Java मध्ये वर्ण मूल्ये युनिकोड स्वरूपात संग्रहित केली जातात. मागील धड्यांपैकी एकामध्ये आम्ही युनिकोडचा सामना केला आहे. तुम्हाला कदाचित आठवत असेल की युनिकोड हे अक्षर एन्कोडिंग मानक आहे ज्यामध्ये जगातील जवळजवळ सर्व लिखित भाषांची चिन्हे समाविष्ट आहेत. दुसऱ्या शब्दांत, ही विशेष कोडची सूची आहे जी कोणत्याही भाषेतील जवळजवळ प्रत्येक वर्ण दर्शवते. संपूर्ण युनिकोड सारणी खूप मोठी आहे आणि अर्थातच ते मनापासून शिकण्याची गरज नाही. त्याचा एक छोटासा भाग येथे आहे: मुख्य गोष्ट म्हणजे वर्ण कसे संग्रहित केले जातात हे समजून घेणे आणि हे लक्षात ठेवणे आवश्यक आहे की जर तुम्हाला एखाद्या विशिष्ट वर्णासाठी कोड माहित असेल तर तुम्ही तुमच्या प्रोग्राममध्ये ते वर्ण नेहमी तयार करू शकता. चला काही यादृच्छिक संख्येसह प्रयत्न करूया:

public static void main(String[] args) {

   int x = 32816;

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

कन्सोल आउटपुट: 耰 हे Java मध्ये char s संचयित करण्यासाठी वापरलेले स्वरूप आहे . प्रत्येक चिन्ह एका संख्येशी संबंधित आहे: 16-बिट (दोन-बाइट) अंकीय कोड. युनिकोडमध्ये, 32816 चायनीज अक्षर 耰 शी संबंधित आहे. खालील मुद्द्याकडे लक्ष द्या. या उदाहरणात, आम्ही int व्हेरिएबल वापरले. ते मेमरीमध्ये 32 बिट व्यापते, तर वर्ण 16 व्यापते. येथे आपण int निवडले आहे, कारण आपला क्रमांक (32816) थोड्या वेळात बसणार नाही . जरी वर्णाचा आकार (फक्त लहान सारखा) 16 बिट्स असला तरी, वर्ण श्रेणीमध्ये कोणत्याही ऋण संख्या नसतात , म्हणून वर्णाचा "सकारात्मक" भागश्रेणी दुप्पट मोठी आहे ( लहान प्रकारासाठी 32767 ऐवजी 65536 ). जोपर्यंत आमचा कोड 65536 च्या खाली राहतो तोपर्यंत आम्ही int वापरू शकतो. परंतु जर तुम्ही 65536 पेक्षा जास्त int व्हॅल्यू तयार केली तर ते 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. :) तुम्ही बघू शकता, येथे अल्गोरिदम अगदी सोपे आहे, परंतु तुम्ही ते विसरू नये. .