ஜாவா கம்பைலர் மூலம் அனுமானத்தை டைப் செய்யவும்

1. தொடரியல் சர்க்கரை

சில சிக்கலான குறியீடு அல்லது தர்க்கத்தை ஓரிரு வரிகளில் எழுதி, குறியீட்டைக் கச்சிதமாகவும் படிக்கக்கூடியதாகவும் மாற்றும் போது புரோகிராமர்கள் விரும்புகிறார்கள். நிரலாக்க மொழிகளின் படைப்பாளிகள் சில நேரங்களில் இதற்கு உதவுகிறார்கள்.

குறுக்குவழியை (குறைவான குறியீட்டை எழுத) அனுமதிக்கும் மென்மையாய் மொழி அம்சம் தொடரியல் சர்க்கரை எனப்படும் . ஆனால், உண்மையைச் சொல்வதானால், ஜாவாவில் இது மிகக் குறைவு.

ஜாவாவின் படைப்பாளிகள் ஜாவாவில் உள்ள பணிநீக்கத்தை அகற்ற தங்களால் முடிந்த அனைத்தையும் செய்தனர். C++ உங்களை 20 வழிகளில் செய்ய அனுமதித்தால், ஜாவா அதை ஒரே ஒரு வழியில் செய்ய அனுமதிக்கிறது.

ஆனால் ஜாவா புரோகிராமர்களோ அல்லது ஜாவாவின் படைப்பாளிகளோ சுதந்திரமின்மையை விரும்பவில்லை. சில சமயங்களில் சர்க்கரை உங்களைப் போன்ற சாதாரண மக்களுக்கு வாழ்க்கையை எளிதாக்குகிறது.

மூலம், நீங்கள் ஏற்கனவே சில தொடரியல் சர்க்கரையை சந்தித்திருக்கிறீர்கள்: ஆட்டோ பாக்ஸிங் மற்றும் அன்பாக்சிங் . ஒப்பிடுவோம்:

Integer a = new Integer(5);
int b = a.intValue();

Integer a = 5;
int b = a;

int b = 5;
Integer c = new Integer(b);

int b = 5;
Integer c = b;

Integer a = new Integer(1);
int b = 1;
if (a.intValue() == b)
{
   ...
}

Integer a = 1;
int b = 1;
if (a == b)
{
   ...
}

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

2. ஒரு மாறியின் வகையின் அனுமானம்: varமுக்கிய சொல்

ஜாவா 11 இல், கம்பைலர் இன்னும் புத்திசாலியாகி, இப்போது அறிவிக்கப்பட்ட மாறியின் வகையை அதற்கு ஒதுக்கப்பட்ட மதிப்பின் வகையின் அடிப்படையில் தீர்மானிக்க முடியும் . குறியீட்டில், இது போல் தெரிகிறது:

var name = value;

nameஒரு புதிய மாறியின் பெயர் எங்கே , மதிப்பு என்பது அதன் ஆரம்ப மதிப்பு மற்றும் varமாறியை அறிவிக்கப் பயன்படுத்தப்படும் முக்கிய வார்த்தையாகும். பெயர் மாறியின் வகையும் அதற்கு ஒதுக்கப்பட்ட மதிப்பின் வகையும் ஒரே மாதிரியாக இருக்கும்.

எடுத்துக்காட்டுகள்:

var i = 1;

int i = 1;

var s = "Hello";

String s = "Hello";

var console = new Scanner(System.in);

Scanner console = new Scanner(System.in);

var list = new ArrayList<String>();

ArrayList<String> list = new ArrayList<String>();

var data = new int[]{1, 2, 3};

int[] data = new int[]{1, 2, 3};

கம்பைலரே அதற்கு ஒதுக்கப்பட்ட மதிப்பின் அடிப்படையில் மாறியின் வகையை தீர்மானிக்கிறது அல்லது ஊகிக்கிறது.

புரோகிராமர்கள் அத்தகைய அம்சத்தை மொழியில் சேர்க்கலாமா என்று பரபரப்பாக விவாதித்தனர். varஅது துஷ்பிரயோகம் செய்யப்படலாம் மற்றும் குறியீட்டைப் படிக்கும் திறன் பாதிக்கப்படும் என்று பலர் அஞ்சினார்கள் .

varஇதில் உண்மையின் ஒரு தானியம் உள்ளது, எனவே குறியீட்டின் வாசிப்புத்திறனை அதிகரிக்கும் இடத்தில் பயன்படுத்துவது சிறந்தது . உதாரணமாக, இவை இரண்டு நிகழ்வுகளில்:

வழக்கு 1: மாறிக்கு ஒதுக்கப்பட்ட மதிப்பைப் பார்த்தால், மாறியின் வகை உடனடியாகத் தெளிவாகத் தெரியும்

var stream = url.getInputStream();

var name = person.getFullName();

இந்த சந்தர்ப்பங்களில், நீங்கள் பயன்படுத்தக்கூடாதுvar . சரி, மாறியின் வகை என்ன?

var result = task.execute();

var status = person.getStatus();

வழக்கு 2: குறியீட்டைப் புரிந்துகொள்வதற்கு மாறியின் வகை முக்கியமல்ல

குறியீடானது பெரும்பாலும் ஒரு மாறியில் முறைகளை அழைக்க வேண்டிய அவசியமில்லை, எ.கா. ஒரு மாறியானது தற்காலிகமாக எதையாவது சேமிக்க பயன்படுத்தப்படும் போது. இந்த வழக்கில், varகண்டிப்பாக பயன்படுத்துவது குறியீட்டின் வாசிப்புத்திறனைக் குறைக்காது:

var data = stream.getMetaData();
storage.save(data)

தங்க சராசரி

இப்போது ஒரே குறியீட்டை எழுத மூன்று வழிகளை தருகிறேன். பயன்படுத்துவது varசிறந்த தேர்வாக இருக்கும்.

dest.writeHeaderInfo(src.getFileMetaInfo());

var headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

FileMetaInfo headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

1 வரி கொண்ட பதிப்பிலிருந்து 2 வரிகளில் உள்ள பதிப்பிற்கு நகர்த்தும்போது, ​​மாறி பெயரைப் பயன்படுத்தி குறியீட்டை இன்னும் கொஞ்சம் படிக்கக்கூடியதாக மாற்றினோம் ( headerInfo). இந்த முறை மெட்டா தகவலை மட்டுமல்ல, தலைப்பு தகவலையும் வழங்குகிறது என்பது இப்போது தெளிவாகிறது.

மூன்றாவது பதிப்பு மிகைப்படுத்தப்பட்டதாக உள்ளது. இது ஏற்கனவே முறையிலிருந்து தெளிவாகத் headerInfoதெரிகிறது . மெட்டா தகவலின் நோக்கம் மிகவும் சுவாரஸ்யமானது.FileMetaInfogetFileMetaInfo()

3. டைமண்ட் ஆபரேட்டருடன் வகையைத் தவிர்க்கவும்:<>

ஆபரேட்டர் தோன்றுவதற்கு முன்பே var, சேகரிப்பு வகைகளை எவ்வாறு ஊகிக்க வேண்டும் என்பதை தொகுப்பாளருக்கு கற்பிக்கும் முயற்சிகள் இருந்தன. இந்த குறியீடானது கொஞ்சம் தேவையற்றதாக இருப்பதை நீங்கள் ஒப்புக்கொள்கிறீர்கள்:

ArrayList<String> list = new ArrayList<String>();

ஜாவாவின் ஏழாவது பதிப்பிலிருந்து தொடங்கி, சேகரிப்பு வகையை எழுதும் போது, ​​ஒரு மாறியை அறிவிக்கும் போது அது குறிப்பிடப்பட்டிருந்தால், சேகரிப்பு கூறுகளின் வகையை நீங்கள் தவிர்க்கலாம். வேறு வார்த்தைகளில் கூறுவதானால், மேலே உள்ள குறியீட்டை சற்று சுருக்கமான வடிவத்தில் எழுதலாம்:

ArrayList<String> list = new ArrayList<>();

நீங்கள் பார்க்க முடியும் என, நீங்கள் இனி இரண்டாவது முறையாக String எழுத தேவையில்லை. var ஆபரேட்டரைப் போல குளிர்ச்சியாக இல்லை, ஆனால் அது அந்த நேரத்தில் முன்னேற்றம் போல் தோன்றியது.

இரண்டு கோண அடைப்புக்குறிகளும் தெளிவற்ற முறையில் வைரத்தை ஒத்திருப்பதால், சேகரிப்பு வகையிலுள்ள வெற்று கோண அடைப்புக்குறிகள் வைர ஆபரேட்டர் என்று அழைக்கப்படுகின்றன.

ஒரே நேரத்தில்var முக்கிய சொல்லையும் டயமண்ட் ஆபரேட்டரையும் பயன்படுத்துவது விரும்பத்தகாதது :

var list = new ArrayList<>();

சேகரிப்பில் சேமிக்கப்பட்ட உறுப்புகளின் வகையைப் பற்றி எந்த தகவலும் இல்லை, மேலும் சேகரிப்பு வகை ArrayList < பொருள் > ஆக இருக்கும்.

4. இரட்டை சுருள் பிரேஸ்கள்

விரைவான வரிசை துவக்கம் நினைவிருக்கிறதா?

இது போன்ற சுருள் பிரேஸ்களில் மதிப்புகளை பட்டியலிட்டுள்ளோம்:

int[] data = new int[] {1, 2, 3, 4, 5, 6, 7};

int[] data = {1, 2, 3, 4, 5, 6, 7};

ஜாவாவின் படைப்பாளிகள் வரிசையின் எழுதும் கூறுகளை எளிமைப்படுத்த சுருள் பிரேஸ்களைப் பயன்படுத்துவதை விரும்பினர். ஆனால் வசூல் பற்றி என்ன?

ஜாவாவின் படைப்பாளிகள் சேகரிப்புகளுக்கு போதுமான ஆக்கப்பூர்வமான சிந்தனையைக் கொண்டிருந்தனர், இதனால் இரட்டை சுருள் பிரேஸ்கள் கொண்ட தந்திரத்தைப் பயன்படுத்த அனுமதித்தனர்.

var list = new ArrayList<String>()
{{
   add("Hello");
   add("How's");
   add("Life?");
}};

var list = new ArrayList<String>();

list.add("Hello");
list.add("How's");
list.add("Life?");

இடதுபுறத்தில் உள்ள எடுத்துக்காட்டில் உள்ளதைப் போன்ற குறியீட்டை கம்பைலர் சந்தித்தால், அது வலதுபுறத்தில் உள்ள குறியீட்டாக மாற்றுகிறது.

குறியீடு மிகவும் கச்சிதமாக மாறாது. listஇங்குள்ள சேமிப்புகள் மிகவும் அற்பமானவை: நீங்கள் ஒவ்வொரு முறையும் எழுத வேண்டியதில்லை . மாறி பெயர் மிக நீளமாக இருந்தால் இது உதவியாக இருக்கும்.

ஆனால் ஒரு திட்டத்தில் இதுபோன்ற குறியீட்டை நீங்கள் கண்டால், ஆச்சரியப்பட வேண்டாம் 🙂