பழமையான வகைகளை விரிவுபடுத்துதல் மற்றும் சுருக்குதல்

வணக்கம்! நீங்கள் கோட்ஜிம் மூலம் முன்னேறியதால், நீங்கள் பல முறை பழமையான வகைகளை சந்தித்திருக்கிறீர்கள். அவர்களைப் பற்றி நாம் அறிந்தவற்றின் குறுகிய பட்டியல் இங்கே:

1. அவை பொருள்கள் அல்ல மற்றும் நினைவகத்தில் சேமிக்கப்பட்ட மதிப்பைக் குறிக்கின்றன
2. பல வகைகள் உள்ளன
   • முழு எண்கள்: பைட் , குறுகிய , முழு எண் , நீளம்
   • மிதக்கும் புள்ளி (பிரிவு) எண்கள்: மிதவை மற்றும் இரட்டை
   • தருக்க மதிப்புகள்: பூலியன்
   • குறியீட்டு மதிப்புகள் (எழுத்துகள் மற்றும் எண்களைக் குறிக்கும்): கரி

3. ஒவ்வொரு வகைக்கும் அதன் சொந்த மதிப்புகள் உள்ளன:

ஆனால் வெவ்வேறு மதிப்புகளைக் கொண்டிருப்பது மட்டுமல்லாமல், அவை நினைவகத்தில் எவ்வளவு இடத்தை ஆக்கிரமித்துள்ளன என்பதில் வேறுபடுகின்றன. ஒரு int ஒரு பைட்டை விட அதிகமாக எடுக்கும். மேலும் நீளமானது குட்டையை விட பெரியது. ஆதிகால மனிதர்களால் ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவை ரஷ்ய கூடு கட்டும் பொம்மைகளுடன் ஒப்பிடலாம்: ஒவ்வொரு கூடு கட்டும் பொம்மைக்கும் உள்ளே இடம் உள்ளது. கூடு கட்டும் பொம்மை பெரியது, அதிக இடம் உள்ளது. ஒரு பெரிய கூடு கட்டும் பொம்மை ( நீளமானது ) ஒரு சிறிய எண்ணுக்கு எளிதில் இடமளிக்கும் . இது எளிதில் பொருந்துகிறது மற்றும் நீங்கள் வேறு எதுவும் செய்ய வேண்டியதில்லை. ஜாவாவில், primitives உடன் பணிபுரியும் போது, ​​இது மறைமுகமான மாற்றம் என்று அழைக்கப்படுகிறது. அல்லது வேறுவிதமாகச் சொன்னால், அது அகலப்படுத்துதல் என்று அழைக்கப்படுகிறது.

ஜாவாவில் விரிவடைகிறது

விரிவடையும் மாற்றத்திற்கான எளிய எடுத்துக்காட்டு இங்கே:

public class Main {

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

       byte littleNumber = 16;

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

இங்கே நாம் ஒரு int மாறிக்கு பைட் மதிப்பை ஒதுக்குகிறோம் . எந்த பிரச்சனையும் இல்லாமல் பணி வெற்றி பெறுகிறது: ஒரு பைட்டில் சேமிக்கப்பட்ட மதிப்பு ஒரு முழு எண்ணுக்கு இடமளிக்கும் நினைவகத்தை விட குறைவான நினைவகத்தை எடுக்கும். சிறிய கூடு பொம்மை (பைட் மதிப்பு) பெரிய கூடு பொம்மைக்குள் ( int மாறி) எளிதில் பொருந்துகிறது. நீங்கள் எதிர்மாறாகச் செய்ய முயற்சித்தால் அது வேறு விஷயம், அதாவது ஒரு பெரிய மதிப்பை ஒரு மாறியில் வைப்பது, அதன் வரம்பில் இவ்வளவு பெரிய தரவு வகைக்கு இடமளிக்க முடியாது. உண்மையான கூடு கட்டும் பொம்மைகளுடன், எண் வெறுமனே பொருந்தாது. ஜாவாவுடன், அது முடியும், ஆனால் நுணுக்கங்களுடன். ஒரு எண்ணை ஒரு குறுகிய மாறியில் வைக்க முயற்சிப்போம் :

public static void main(String[] args) {

   int bigNumber = 10000000;
  
   short littleNumber = 1000;

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

பிழை! ஒரு பெரிய கூடு கட்டும் பொம்மையை ( int ) சிறிய ஒன்றின் உள்ளே ( குறுகிய ) நகர்த்துவதன் மூலம் நீங்கள் அசாதாரணமான ஒன்றைச் செய்ய முயற்சிக்கிறீர்கள் என்பதை கம்பைலர் புரிந்துகொள்கிறார் . இந்த வழக்கில், தொகுத்தல் பிழையானது கம்பைலரின் எச்சரிக்கையாகும்: "ஏய், நீங்கள் இதைச் செய்ய விரும்புகிறீர்கள் என்பதில் உறுதியாக இருக்கிறீர்களா?" நீங்கள் உறுதியாக இருந்தால், தொகுப்பாளரிடம் சொல்லுங்கள்: "எல்லாம் சரி. நான் என்ன செய்கிறேன் என்று எனக்குத் தெரியும்!" இந்த செயல்முறை வெளிப்படையான வகை மாற்றம் அல்லது குறுகுதல் என்று அழைக்கப்படுகிறது.

ஜாவாவில் குறுகலானது

குறுகலான மாற்றத்தைச் செய்ய, உங்கள் மதிப்பை மாற்ற விரும்பும் வகையை நீங்கள் வெளிப்படையாகக் குறிப்பிட வேண்டும். வேறு வார்த்தைகளில் கூறுவதானால், தொகுப்பாளரின் கேள்விக்கு நீங்கள் பதிலளிக்க வேண்டும்: "சரி, இந்த சிறிய கூடு கட்டும் பொம்மைகளில் எந்த பெரிய கூடு பொம்மையை வைக்க விரும்புகிறீர்கள்?" எங்கள் விஷயத்தில், இது போல் தெரிகிறது:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

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

நாம் ஒரு முழு எண்ணை ஒரு குறுகிய மாறியில் வைக்க விரும்புகிறோம் என்பதையும் , நாங்கள் பொறுப்பேற்க வேண்டும் என்பதையும் நாங்கள் வெளிப்படையாகக் குறிப்பிடுகிறோம். ஒரு குறுகிய வகை வெளிப்படையாகக் குறிப்பிடப்பட்டிருப்பதைப் பார்த்து, கம்பைலர் மாற்றத்தை செய்கிறது. விளைவு என்ன? கன்சோல் வெளியீடு: -27008 இது சற்றும் எதிர்பாராதது. நாம் ஏன் அதை சரியாகப் பெற்றோம்? உண்மையில், எல்லாம் மிகவும் எளிமையானது. முதலில், மதிப்பு 10000000 இது 32 பிட்களை ஆக்கிரமித்துள்ள ஒரு int மாறியில் சேமிக்கப்பட்டது . இது அதன் பைனரி பிரதிநிதித்துவம்: இந்த மதிப்பை ஒரு குறுகிய மாறியில் எழுதுகிறோம் , இது 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 என்பது சீன எழுத்து 耰 உடன் ஒத்துள்ளது. பின்வரும் குறிப்பைக் கவனியுங்கள். இந்த எடுத்துக்காட்டில், நாம் ஒரு int மாறியைப் பயன்படுத்தினோம். இது நினைவகத்தில் 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. :) நீங்கள் பார்க்கிறபடி, இங்கே அல்காரிதம் மிகவும் எளிமையானது, ஆனால் நீங்கள் அதை மறந்துவிடக் கூடாது. .