உள்ளடக்கம்

• கோட்லின் Vs ஜாவா, பின்னர் மேலும் சுருக்கமான குறியீட்டை வழங்குகிறது - findViewByIds இல்லாமல்
• கோட்லின் இயல்பாகவே பூஜ்யமானது
• நீட்டிப்பு செயல்பாடுகள்
• கோரூட்டின்கள் முதல் தர குடிமக்கள்
• சரிபார்க்கப்பட்ட விதிவிலக்குகள் எதுவும் இல்லை
• தூதுக்குழுவிற்கு பூர்வீக ஆதரவு
• தரவு வகுப்புகள்
• ஸ்மார்ட் காஸ்ட்கள்
• கட்டமைப்பாளர்களுக்கான ஆதரவு
• மறைமுகமாக விரிவாக்கும் மாற்றங்களுக்கு ஆதரவு இல்லை
• கோட்லினுடன் சிறுகுறிப்பு செயலாக்க நூலகங்கள்
• ஜாவாவுடன் பரிமாற்றம்
• மடக்குதல்

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

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

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

ஆனால் நீங்கள் ஜாவாவிலிருந்து கோட்லினுக்கு மாறினால், நீங்கள் சரியாக என்ன பெறுகிறீர்கள்? கோட்லினுக்கு என்ன அம்சங்கள் உள்ளன, ஜாவா இல்லை, மற்றும் நேர்மாறாக?

இந்த கட்டுரையில், கோட்லின் Vs ஜாவா இடையேயான அனைத்து முக்கிய வேறுபாடுகளையும் நாங்கள் பார்க்கப்போகிறோம்.

கோட்லின் Vs ஜாவா, பின்னர் மேலும் சுருக்கமான குறியீட்டை வழங்குகிறது - findViewByIds இல்லாமல்

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

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

இந்த நீட்டிப்புகளைப் பயன்படுத்துவதற்கு முன்பு, உங்கள் தொகுதி-நிலை build.gradle கோப்பில் கூடுதல் சொருகி சேர்க்க வேண்டும் (சொருகி: 'கோட்லின்-ஆண்ட்ராய்டு-நீட்டிப்புகள்' ஐப் பயன்படுத்துக) ஆனால் அதற்குப் பிறகு நீங்கள் காட்சிகளை இறக்குமதி செய்யத் தயாராக உள்ளீர்கள். எடுத்துக்காட்டாக, உங்கள் activity_main.xml கோப்பில் ஐடி உரைக்காட்சியுடன் உரைக்காட்சி இருந்தால், பின்வருவனவற்றை உங்கள் செயல்பாட்டில் சேர்க்கலாம்:

இறக்குமதி kotlinx.android.synthetic.main.activity_main.textView

அதன் அடையாளத்தைப் பயன்படுத்தி இந்த உரைக்காட்சியை அணுகலாம்:

textView.setText ("ஹலோ வேர்ல்ட்")

இது மிகவும் ஜாவா சமமானதை விட சுருக்கமானது:

உரைக்காட்சி உரை = (உரைக்காட்சி) findViewById (R.id.textView); text.setText ("ஹலோ வேர்ல்ட்");

கோட்லின் இயல்பாகவே பூஜ்யமானது

NullPointerException என்பது ஜாவா டெவலப்பர்களுக்கு பெரும் ஏமாற்றத்தை அளிக்கிறது. எந்தவொரு மாறிக்கும் பூஜ்யத்தை ஒதுக்க ஜாவா உங்களை அனுமதிக்கிறது, ஆனால் பூஜ்ய மதிப்பைக் கொண்ட ஒரு பொருள் குறிப்பைப் பயன்படுத்த முயற்சித்தால், ஒரு NullPointerException ஐ எதிர்கொள்ள உங்களை நீங்களே இணைத்துக் கொள்ளுங்கள்!

இதையும் படியுங்கள்: Android அறிமுகத்திற்கான கோட்டிலின்

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

மதிப்பு பெயர்: சரம் = பூஜ்யம்

fun getName (): சரம் = பூஜ்யம்

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

மதிப்பு எண்: எண்ணாக? = பூஜ்யம்

இது கோட்லினில் NullPointerException ஐ எதிர்கொள்வது கிட்டத்தட்ட சாத்தியமற்றது - உண்மையில், இந்த விதிவிலக்கை நீங்கள் சந்தித்தால், அதற்கான வாய்ப்புகள் என்னவென்றால், நீங்கள் கோட்லினுக்கு ஒருவரை வீசுமாறு வெளிப்படையாகக் கேட்டதால், அல்லது NullPointerException வெளிப்புற ஜாவா குறியீட்டிலிருந்து உருவாகிறது.

நீட்டிப்பு செயல்பாடுகள்

புதிய செயல்பாட்டுடன் ஒரு வகுப்பை விரிவுபடுத்துவதற்கான திறனை கோட்லின் டெவலப்பர்களுக்கு வழங்குகிறது, இது ஒரு முக்கியமான முறையை காணவில்லை என்று நீங்கள் எப்போதும் உணர்ந்த ஒரு வகுப்பு இருந்தால் சிறந்தது!

இந்த ‘நீட்டிப்பு செயல்பாடுகள்’ ஜாவாவில் கிடைக்காது, இருப்பினும் அவை சி # போன்ற Android மேம்பாட்டிற்கு நீங்கள் பயன்படுத்தக்கூடிய பிற நிரலாக்க மொழிகளில் கிடைக்கின்றன.

அடுத்து படிக்கவும்: ஆரம்பநிலைக்கான ஜாவா பயிற்சி

நீங்கள் நீட்டிக்க விரும்பும் வகுப்பின் பெயரை (‘சரம்’ போன்றவை) நீங்கள் உருவாக்கும் செயல்பாட்டின் பெயருக்கு (‘ஸ்டைல் ​​ஸ்ட்ரிங்’) முன்னொட்டுவதன் மூலம் நீட்டிப்பு செயல்பாட்டை உருவாக்குகிறீர்கள்: எடுத்துக்காட்டாக:

வேடிக்கையான String.styleString (): சரம் {// சரத்தை ஸ்டைல் ​​செய்து அதை திருப்பித் தரவும் //}

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

myString.styleString ()

கோரூட்டின்கள் முதல் தர குடிமக்கள்

நெட்வொர்க் I / O அல்லது CPU- தீவிர வேலை போன்ற நீண்டகால செயல்பாட்டை நீங்கள் தொடங்கும்போதெல்லாம், செயல்பாடு முடியும் வரை அழைப்பு நூல் தடுக்கப்படும். இயல்புநிலையாக Android ஒற்றை-திரிக்கப்பட்டிருப்பதால், நீங்கள் முக்கிய நூலைத் தடுத்தவுடன் உங்கள் பயன்பாட்டின் UI உறைந்து போகும், மேலும் செயல்பாடு முடியும் வரை அது பதிலளிக்காமல் இருக்கும்.

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

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

சரிபார்க்கப்பட்ட விதிவிலக்குகள் எதுவும் இல்லை

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

இது உங்களை கோட்லினுக்கு ஈர்க்கும் விஷயமா, அல்லது ஜாவாவுடன் இணைந்திருக்க விரும்புகிறதா என்பது சரிபார்க்கப்பட்ட விதிவிலக்குகள் குறித்த உங்கள் கருத்தைப் பொறுத்தது, ஏனெனில் இது டெவலப்பர் சமூகத்தைப் பிரிக்கும் அம்சமாகும். உங்கள் ஜாவா குறியீட்டைக் குழப்பிக் கொள்ளும் முயற்சி / பிடிப்புத் தொகுதிகள் உங்களுக்கு உடம்பு சரியில்லை என்றால், நீங்கள் இந்த விடுதலையைப் பற்றி மகிழ்ச்சியடையப் போகிறீர்கள், இருப்பினும் சரிபார்க்கப்பட்ட விதிவிலக்குகள் பிழை மீட்பு பற்றி சிந்திக்க ஊக்குவிப்பதைக் கண்டறிந்து, இறுதியில் உங்களை மேலும் வலுவாக உருவாக்குவதை நோக்கித் தள்ளும் குறியீடு, பின்னர் நீங்கள் இதை ஜாவா கோட்லின் மீது விளிம்பில் வைத்திருக்கும் பகுதியாகக் காணலாம்.

தூதுக்குழுவிற்கு பூர்வீக ஆதரவு

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

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

வகுப்பு பிரதிநிதி {ஆபரேட்டர் வேடிக்கை getValue (...) ... ... ...} ஆபரேட்டர் வேடிக்கை தொகுப்பு மதிப்பு (...) ... ... ... ...}}

பின்னர், நீங்கள் ஒரு சொத்தை உருவாக்கும்போது, ​​இந்த குறிப்பிட்ட சொத்துக்கான பெறுநர் மற்றும் செட்டர் செயல்பாடுகள் மற்றொரு வகுப்பால் கையாளப்படுகின்றன என்று அறிவிக்கலாம்:

வகுப்பு MyClass property var சொத்து: பிரதிநிதியின் சரம் ()}

தரவு வகுப்புகள்

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

கோட்லினில், உங்கள் வகுப்பு வரையறையில் ‘தரவு’ திறவுச்சொல்லை நீங்கள் சேர்த்தால், தேவையான அனைத்து பெறுநர்களையும் அமைப்பாளர்களையும் உருவாக்குவது உட்பட, இந்த வேலை அனைத்தையும் தொகுப்பி உங்களுக்காகச் செய்யும்:

தரவு வகுப்பு தேதி (var மாதம்: சரம், var நாள்: Int)

ஸ்மார்ட் காஸ்ட்கள்

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

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

if (ஹலோ சரம்) {printString (ஹலோ)}

கட்டமைப்பாளர்களுக்கான ஆதரவு

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

வகுப்பு மெயின் ஆக்டிவிட்டி கட்டமைப்பாளர் (முதல் பெயர்: சரம்) {}

மறைமுகமாக விரிவாக்கும் மாற்றங்களுக்கு ஆதரவு இல்லை

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

கோட்லினுடன் சிறுகுறிப்பு செயலாக்க நூலகங்கள்

சில ஜாவா நூலகங்கள் ஏற்கனவே RxKotlin போன்ற கோட்லின் நீட்டிப்புகளை வழங்கினாலும், சிறுகுறிப்பு செயலாக்கத்தை நம்பியுள்ள மேம்பட்ட கட்டமைப்புகள் உட்பட தற்போதுள்ள அனைத்து ஜாவா கட்டமைப்புகள் மற்றும் நூலகங்களை கோட்லின் ஆதரிக்கிறது.

சிறுகுறிப்பு செயலாக்கத்தை நம்பியிருக்கும் ஜாவா நூலகத்தை நீங்கள் பயன்படுத்த விரும்பினால், அதை உங்கள் கோட்லின் திட்டத்தில் சேர்ப்பது சற்று வித்தியாசமானது, ஏனெனில் நீங்கள் இதைப் பயன்படுத்தி சார்புநிலையைக் குறிப்பிட வேண்டும். kotlin-kapt சொருகி, பின்னர் annotationProcessor க்கு பதிலாக கோட்லின் சிறுகுறிப்பு செயலாக்க கருவியை (kapt) பயன்படுத்தவும். உதாரணத்திற்கு:

// சொருகி விண்ணப்பிக்கவும் // சொருகி விண்ணப்பிக்கவும்: கோட்லின்-காப்ட் // காப்ட் உள்ளமைவைப் பயன்படுத்தி அந்தந்த சார்புகளைச் சேர்க்கவும் // சார்புநிலைகள் {kapt "com.google.dagger: dagger-compiler: $ dagger-version" ... ... ...}

ஜாவாவுடன் பரிமாற்றம்

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

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

நீங்கள் கோட்லினை நீங்களே முயற்சி செய்ய விரும்பினால், நீங்கள் Android ஸ்டுடியோ 3.0 முன்னோட்டம் அல்லது அதற்கு மேற்பட்டவற்றை நிறுவியிருக்கும் வரை, நீங்கள் தொடங்க சில வழிகள் உள்ளன:

• புதிய Android ஸ்டுடியோ திட்டத்தை உருவாக்கவும். ஒரு புதிய திட்டத்தை உருவாக்கி, திட்ட உருவாக்கும் வழிகாட்டியிலிருந்து ‘கோட்லின் ஆதரவைச் சேர்க்கவும்’ தேர்வுப்பெட்டியைத் தேர்ந்தெடுப்பதே எளிதான முறை.

• ஏற்கனவே உள்ள கோப்பகத்தில் கோட்லின் வகுப்பைச் சேர்க்கவும். கேள்விக்குரிய கோப்பகத்தைக் கட்டுப்படுத்து-கிளிக் செய்து, பின்னர் ‘கோப்பு> புதிய> கோட்லின் கோப்பு / வகுப்பு’ என்பதைத் தேர்ந்தெடுக்கவும். கோட்லினுக்கு ஆதரவாக உங்கள் திட்டத்தை உள்ளமைக்க ஆண்ட்ராய்டு ஸ்டுடியோ ஒரு பேனரைக் காண்பிக்கும்; ‘உள்ளமை’ இணைப்பைக் கிளிக் செய்து, திரை வழிமுறைகளைப் பின்பற்றவும்.

• இருக்கும் ஜாவா கோப்புகளை கோட்லினுக்கு மாற்றவும். கோட்லின் மாற்றி மூலம் எந்த ஜாவா கோப்பையும் இயக்கலாம், கோப்பைக் கட்டுப்பாட்டு-கிளிக் செய்து, ‘குறியீடு> ஜாவா கோப்பை கோட்லின் கோப்பாக மாற்று’ என்பதைத் தேர்ந்தெடுப்பதன் மூலம்.

மடக்குதல்

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

அடுத்து படிக்கவும்: Android மேம்பாட்டிற்கான ஜாவா தொடரியல் அறிமுகம்