విషయము
- కోట్లిన్ వర్సెస్ జావా, తరువాత మరింత క్లుప్తమైన కోడ్‌ను అందిస్తుంది - ఫైండ్‌వ్యూ వ్యూబైడ్స్ లేకుండా
- కోట్లిన్ అప్రమేయంగా శూన్యమైనది
- పొడిగింపు విధులు
- కొరౌటిన్లు ఫస్ట్ క్లాస్ పౌరులు
- తనిఖీ చేసిన మినహాయింపులు లేవు
- ప్రతినిధి బృందానికి స్థానిక మద్దతు
- డేటా తరగతులు
- స్మార్ట్ కాస్ట్‌లు
- కన్స్ట్రక్టర్లకు మద్దతు
- అవ్యక్త విస్తృత మార్పిడులకు మద్దతు లేదు
- కోట్లిన్‌తో ఉల్లేఖన ప్రాసెసింగ్ లైబ్రరీలు
- జావాతో పరస్పర మార్పిడి
- చుట్టి వేయు
మీరు Android గురించి ఆలోచించినప్పుడు గుర్తుకు వచ్చే మొదటి ప్రోగ్రామింగ్ భాష జావా ఇప్పటికీ కావచ్చు, కానీ మీరు అలా చేయరు కలిగి Android అభివృద్ధి కోసం జావాను ఉపయోగించడానికి. వాస్తవానికి, కోట్లిన్ ఇప్పుడు గూగుల్ఇష్టపడేAndroid కోసం అధికారిక భాష!
జావా గురించి మరింత తెలుసుకోవడానికి మేక్ ఆండ్రాయిడ్ యాప్స్ వద్ద జావా కోర్సుకు ఉచిత పరిచయాన్ని పొందండి.
ఈ రోజు, ఆండ్రాయిడ్ స్టూడియో అంతర్నిర్మిత కోట్లిన్ మద్దతుతో రవాణా చేస్తుంది, కాబట్టి కోట్లిన్ కోడ్‌ను అర్థం చేసుకునే Android ప్రాజెక్ట్ను సృష్టించడం Android స్టూడియో యొక్క ప్రాజెక్ట్ సృష్టి విజార్డ్‌లో చెక్‌బాక్స్‌ను ఎంచుకున్నంత సులభం. ఆప్షన్ కోసం ఓవర్ టైం కోసం మద్దతు పెరిగింది, ఈ నిర్ణయం ఇప్పుడు ప్రధానంగా ప్రాధాన్యతకి వస్తుంది.
మీరు జావా నుండి కోట్లిన్‌కు మారినట్లయితే, మీరు ఖచ్చితంగా ఏమి పొందుతున్నారు? కోట్లిన్‌కు ఏ లక్షణాలు ఉన్నాయి, జావా లేనివి మరియు దీనికి విరుద్ధంగా?
ఈ వ్యాసంలో, మేము కోట్లిన్ వర్సెస్ జావా మధ్య ఉన్న అన్ని ప్రధాన తేడాలను చూడబోతున్నాం.
కోట్లిన్ వర్సెస్ జావా, తరువాత మరింత క్లుప్తమైన కోడ్‌ను అందిస్తుంది - ఫైండ్‌వ్యూ వ్యూబైడ్స్ లేకుండా
మీరు అదే పనిని చేస్తున్న కోట్లిన్ క్లాస్ మరియు జావా క్లాస్‌లను పోల్చినట్లయితే, కోట్లిన్ క్లాస్ సాధారణంగా చాలా సంక్షిప్తంగా ఉంటుంది, అయితే ప్రత్యేకంగా మీరు వ్రాయవలసిన బాయిలర్‌ప్లేట్ కోడ్‌ను కోట్లిన్ తీవ్రంగా తగ్గించగల ఒక ప్రాంతం ఉంది: findViewByIds.
కోట్లిన్ ఆండ్రాయిడ్ ఎక్స్‌టెన్షన్స్ మీ కార్యాచరణ ఫైల్‌లోకి వీక్షణకు సూచనను దిగుమతి చేసుకోవడానికి మిమ్మల్ని అనుమతిస్తాయి, ఆ సమయంలో మీరు ఆ వీక్షణతో కార్యాచరణలో భాగమైనట్లుగా పని చేయగలుగుతారు. ఫలితం? మీరు మరలా మరొక ఫైండ్‌వ్యూ వ్యూబైడ్ పద్ధతిని వ్రాయవలసిన అవసరం లేదు!
మీరు ఈ పొడిగింపులను ఉపయోగించే ముందు, మీరు మీ మాడ్యూల్-స్థాయి బిల్డ్.గ్రాడిల్ ఫైల్‌కు అదనపు ప్లగిన్‌ను జోడించాలి (ప్లగ్ఇన్ను వర్తింపజేయండి: 'కోట్లిన్-ఆండ్రాయిడ్-ఎక్స్‌టెన్షన్స్') కానీ ఆ తర్వాత మీరు వీక్షణలను దిగుమతి చేయడం ప్రారంభించడానికి సిద్ధంగా ఉన్నారు. ఉదాహరణకు మీ activity_main.xml ఫైల్‌లో ID టెక్స్ట్ వ్యూతో టెక్స్ట్ వ్యూ ఉంటే, మీరు ఈ క్రింది వాటిని మీ కార్యాచరణకు జోడిస్తారు:
kotlinx.android.synthetic.main.activity_main.textView ను దిగుమతి చేయండి
మీరు దాని టెక్స్ట్ వ్యూని దాని ఐడిని ఉపయోగించి యాక్సెస్ చేయవచ్చు:
textView.setText ("హలో వరల్డ్")
ఇది చాలా జావా సమానమైనదానికంటే ఎక్కువ క్లుప్తమైనది:
టెక్స్ట్ వ్యూ టెక్స్ట్ = (టెక్స్ట్ వ్యూ) findViewById (R.id.textView); text.setText ("హలో వరల్డ్");
కోట్లిన్ అప్రమేయంగా శూన్యమైనది
NullPointerExceptions జావా డెవలపర్‌లకు నిరాశకు గురిచేస్తుంది. ఏదైనా వేరియబుల్‌కు శూన్యతను కేటాయించడానికి జావా మిమ్మల్ని అనుమతిస్తుంది, కానీ మీరు శూన్య విలువను కలిగి ఉన్న ఆబ్జెక్ట్ రిఫరెన్స్‌ను ఉపయోగించడానికి ప్రయత్నిస్తే, అప్పుడు నల్‌పాయింటర్ ఎక్సెప్షన్‌ను ఎదుర్కోవటానికి మీరే బ్రేస్ చేయండి!
ఇవి కూడా చదవండి: Android పరిచయం కోసం కోటిల్న్
కోట్లిన్‌లో, అన్ని రకాలు అప్రమేయంగా శూన్యమైనవి (శూన్య విలువను కలిగి ఉండలేవు). మీరు మీ కోట్లిన్ కోడ్‌లో శూన్యంగా కేటాయించడానికి లేదా తిరిగి ఇవ్వడానికి ప్రయత్నిస్తే, అది కంపైల్ సమయంలో విఫలమవుతుంది, కాబట్టి ఈ క్రింది పంక్తులు రెండూ కంపైల్ చేయవు:
విలువ పేరు: స్ట్రింగ్ = శూన్య
fun getName (): స్ట్రింగ్ = శూన్య
ఒకవేళ నువ్వు నిజంగా కోట్లిన్‌లో వేరియబుల్‌కు శూన్య విలువను కేటాయించాలనుకుంటే, ఆ రకం తర్వాత ప్రశ్న గుర్తును జోడించడం ద్వారా మీరు ఆ వేరియబుల్‌ను శూన్యమని స్పష్టంగా గుర్తించాలి:
వాల్ సంఖ్య: Int? = శూన్య
ఇది కోట్లిన్‌లో నల్‌పాయింటర్ ఎక్సెప్షన్స్‌ను ఎదుర్కోవడం దాదాపు అసాధ్యం చేస్తుంది - వాస్తవానికి, మీరు ఈ మినహాయింపును ఎదుర్కొంటే, అప్పుడు మీరు కోట్లిన్‌ను విసిరేయాలని స్పష్టంగా కోరినందున లేదా నల్‌పాయింటర్ ఎక్సెప్షన్ బాహ్య జావా కోడ్ నుండి ఉద్భవించినందున అవకాశాలు ఉన్నాయి.
పొడిగింపు విధులు
క్రొత్త కార్యాచరణతో తరగతిని విస్తరించే సామర్థ్యాన్ని కోట్లిన్ డెవలపర్‌లకు ఇస్తుంది, ఒక ముఖ్యమైన పద్ధతి లేదు అని మీరు ఎప్పుడూ భావించే తరగతి ఉంటే ఇది చాలా మంచిది!
ఈ ‘పొడిగింపు విధులు’ జావాలో అందుబాటులో లేవు, అయినప్పటికీ అవి సి # వంటి Android అభివృద్ధి కోసం మీరు ఉపయోగించగల ఇతర ప్రోగ్రామింగ్ భాషలలో అందుబాటులో ఉన్నాయి.
తదుపరి చదవండి: ప్రారంభకులకు జావా ట్యుటోరియల్
మీరు విస్తరించదలిచిన తరగతి పేరును (‘స్ట్రింగ్’ వంటివి) మీరు సృష్టించే ఫంక్షన్ పేరుకు (‘స్టైల్ స్ట్రింగ్’) ప్రిఫిక్స్ చేయడం ద్వారా మీరు ఎక్స్‌టెన్షన్ ఫంక్షన్‌ను సృష్టిస్తారు: ఉదాహరణకు:
సరదా స్ట్రింగ్.స్టైల్ స్ట్రింగ్ (): స్ట్రింగ్ {// స్ట్రింగ్‌ను స్టైల్ చేసి, ఆపై దాన్ని తిరిగి ఇవ్వండి //}
అప్పుడు మీరు ఈ ఫంక్షన్‌ను విస్తరించిన తరగతి యొక్క సందర్భాలలో కాల్ చేయవచ్చు. సంజ్ఞామానం, అది ఆ తరగతిలో భాగమైనట్లుగా:
కొరౌటిన్లు ఫస్ట్ క్లాస్ పౌరులు
మీరు నెట్‌వర్క్ I / O లేదా CPU- ఇంటెన్సివ్ వర్క్ వంటి దీర్ఘకాలిక ఆపరేషన్‌ను ప్రారంభించినప్పుడల్లా, ఆపరేషన్ పూర్తయ్యే వరకు కాలింగ్ థ్రెడ్ నిరోధించబడుతుంది. ఆండ్రాయిడ్ డిఫాల్ట్‌గా సింగిల్-థ్రెడ్ అయినందున, మీరు ప్రధాన థ్రెడ్‌ను బ్లాక్ చేసిన వెంటనే మీ అనువర్తనం యొక్క UI స్తంభింపజేయబడుతుంది మరియు ఆపరేషన్ పూర్తయ్యే వరకు ఇది స్పందించదు.
జావాలో, సాంప్రదాయకంగా మీరు ఈ ఇంటెన్సివ్ లేదా దీర్ఘకాలిక పనిని చేయగల నేపథ్య థ్రెడ్‌ను సృష్టించడం, కానీ బహుళ థ్రెడ్‌లను నిర్వహించడం సంక్లిష్టమైన, లోపం సంభవించే కోడ్‌కు దారితీస్తుంది మరియు క్రొత్త థ్రెడ్‌ను సృష్టించడం ఖరీదైన ఆపరేషన్.
మీరు కోట్లిన్‌లో అదనపు థ్రెడ్‌లను సృష్టించగలిగినప్పటికీ, మీరు కోరౌటిన్‌లను కూడా ఉపయోగించవచ్చు. కొరౌటిన్లు థ్రెడ్‌ను నిరోధించకుండా ఒక నిర్దిష్ట సమయంలో అమలును నిలిపివేయడం ద్వారా దీర్ఘకాలిక మరియు ఇంటెన్సివ్ పనులను చేస్తారు, ఆపై ఈ ఫంక్షన్‌ను తరువాతి దశలో, బహుశా మరొక థ్రెడ్‌లో తిరిగి ప్రారంభిస్తారు. ఇది నిరోధించని అసమకాలిక కోడ్‌ను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది లుక్స్ సమకాలిక, అందువల్ల మరింత స్పష్టంగా, సంక్షిప్త మరియు మానవ-చదవగలిగేది. కొరౌటిన్లు కూడా స్టాక్‌లెస్‌గా ఉంటాయి, కాబట్టి అవి థ్రెడ్‌లతో పోలిస్తే తక్కువ మెమరీ వినియోగాన్ని కలిగి ఉంటాయి మరియు అవి ఎసిన్క్ / వెయిట్ వంటి అసమకాలిక నాన్-బ్లాకింగ్ ప్రోగ్రామింగ్ యొక్క అదనపు శైలులకు తలుపులు తెరుస్తాయి.
తనిఖీ చేసిన మినహాయింపులు లేవు
కోట్లిన్ తనిఖీ చేసిన మినహాయింపులను కలిగి లేదు, కాబట్టి మీరు మినహాయింపులను పట్టుకోవడం లేదా ప్రకటించడం అవసరం లేదు.
ఇది మిమ్మల్ని కోట్లిన్‌కు ఆకర్షిస్తుంది, లేదా మీరు జావాతో కలిసి ఉండాలని కోరుకుంటున్నారా అనేది తనిఖీ చేసిన మినహాయింపుల గురించి మీ అభిప్రాయం మీద ఆధారపడి ఉంటుంది, ఎందుకంటే ఇది డెవలపర్ సంఘాన్ని విభజించే లక్షణం. మీ జావా కోడ్‌ను చిందరవందర చేయుటకు ప్రయత్నిస్తే / క్యాచ్ బ్లాక్‌లతో మీరు అనారోగ్యంతో ఉంటే, మీరు ఈ మినహాయింపుతో సంతోషంగా ఉండబోతున్నారు, అయితే తనిఖీ చేసిన మినహాయింపులు లోపం రికవరీ గురించి ఆలోచించమని మిమ్మల్ని ప్రోత్సహిస్తాయి మరియు చివరికి మిమ్మల్ని మరింత బలంగా సృష్టించే దిశగా నెట్టివేస్తాయి కోడ్, అప్పుడు మీరు దీనిని కోట్లిన్‌పై జావా అంచు ఉన్న ప్రాంతంగా చూడవచ్చు.
ప్రతినిధి బృందానికి స్థానిక మద్దతు
కోట్లిన్, జావా వలె కాకుండా, ఫస్ట్-క్లాస్ ప్రతినిధి బృందం ద్వారా (కొన్నిసార్లు అవ్యక్త ప్రతినిధి బృందం అని పిలుస్తారు) “వారసత్వానికి పైగా కూర్పు” రూపకల్పన నమూనాకు మద్దతు ఇస్తుంది. ప్రతినిధి అనేది స్వీకరించే వస్తువు రెండవ ప్రతినిధి వస్తువుకు కార్యకలాపాలను అప్పగిస్తుంది, ఇది అసలు సందర్భంతో సహాయక వస్తువు.
కోట్లిన్ యొక్క తరగతి ప్రతినిధి బృందం వారసత్వానికి ప్రత్యామ్నాయం, ఇది బహుళ వారసత్వాన్ని ఉపయోగించడం సాధ్యం చేస్తుంది. ఇంతలో, కోట్లిన్ యొక్క ప్రతినిధి లక్షణాలు కోడ్ యొక్క నకిలీని నిరోధించడంలో సహాయపడతాయి, ఉదాహరణకు మీరు బహుళ లక్షణాల సంపాదించేవారు మరియు సెట్టర్‌ల కోసం ఒకే కోడ్‌ను తిరిగి ఉపయోగించాల్సిన అవసరం ఉంటే, మీరు ఈ కోడ్‌ను అప్పగించిన ఆస్తిలో సేకరించవచ్చు. ప్రాపర్టీ ప్రతినిధికి GetValue ఆపరేటర్ ఫంక్షన్‌ను నిర్వచించాల్సిన అవసరం ఉంది మరియు ఐచ్ఛికంగా, setValue ఆపరేటర్:
తరగతి ప్రతినిధి {ఆపరేటర్ సరదా getValue (...) ... ... ...} ఆపరేటర్ సరదా సెట్‌వాల్యూ (...) ... ... ...}}
అప్పుడు, మీరు ఆస్తిని సృష్టిస్తున్నప్పుడు, ఈ ప్రత్యేక ఆస్తి కోసం సంపాదించేవారు మరియు సెట్టర్ విధులు మరొక తరగతి చేత నిర్వహించబడుతున్నాయని మీరు ప్రకటించవచ్చు:
తరగతి మైక్లాస్ property var ఆస్తి: స్ట్రింగ్ బై డెలిగేట్ ()}
డేటా తరగతులు
ఒక ప్రాజెక్ట్ డేటాను కలిగి ఉండటమే కాకుండా ఏమీ చేయని బహుళ తరగతులను కలిగి ఉండటం అసాధారణం కాదు. జావాలో, తరగతులకు చాలా తక్కువ కార్యాచరణ ఉన్నప్పటికీ, ఈ తరగతుల కోసం మీరు చాలా బాయిలర్‌ప్లేట్ కోడ్‌ను వ్రాస్తారు. సాధారణంగా, మీరు ఒక కన్స్ట్రక్టర్, డేటాను నిల్వ చేయడానికి ఫీల్డ్‌లు, ప్రతి ఫీల్డ్‌కు గెట్టర్ మరియు సెట్టర్ ఫంక్షన్‌లు, ప్లస్ హాష్‌కోడ్ (), సమానం () మరియు టో స్ట్రింగ్ () ఫంక్షన్‌లను నిర్వచించాలి.
కోట్లిన్‌లో, మీరు మీ తరగతి నిర్వచనంలో ‘డేటా’ కీవర్డ్‌ని చేర్చినట్లయితే, కంపైలర్ ఈ పనిని మీ కోసం చేస్తుంది, అవసరమైన అన్ని సంపాదించేవారిని మరియు సెట్టర్‌లను ఉత్పత్తి చేయడంతో సహా:
డేటా క్లాస్ తేదీ (var నెల: స్ట్రింగ్, var రోజు: Int)
స్మార్ట్ కాస్ట్‌లు
జావాలో, మీరు తరచూ రకాన్ని తనిఖీ చేసి, ఆ వస్తువును ప్రసారం చేయవచ్చని ఇప్పటికే స్పష్టంగా ఉన్న పరిస్థితులలో ఒక వస్తువును ప్రసారం చేయాలి.
కోట్లిన్ యొక్క స్మార్ట్ కాస్ట్‌లు మీ కోసం ఈ పునరావృత కాస్ట్‌లను నిర్వహించగలవు, కాబట్టి మీరు కోట్లిన్ యొక్క ‘ఈజ్’ ఆపరేటర్‌తో ఇప్పటికే దాన్ని తనిఖీ చేసినట్లయితే మీరు స్టేట్‌మెంట్‌లోకి ప్రసారం చేయనవసరం లేదు. ఉదాహరణకు, కంపైలర్ కింది తారాగణం సురక్షితమని తెలుసు:
if (హలో స్ట్రింగ్) {printString (హలో)}
కన్స్ట్రక్టర్లకు మద్దతు
జావా మాదిరిగా కాకుండా, కోట్లిన్ తరగతికి ప్రాధమిక కన్స్ట్రక్టర్ మరియు ఒకటి లేదా అంతకంటే ఎక్కువ సెకండరీ కన్స్ట్రక్టర్లు ఉండవచ్చు, వాటిని మీ క్లాస్ డిక్లరేషన్‌లో చేర్చడం ద్వారా మీరు సృష్టించవచ్చు:
తరగతి మెయిన్ఆక్టివిటీ కన్స్ట్రక్టర్ (మొదటి పేరు: స్ట్రింగ్) {}
అవ్యక్త విస్తృత మార్పిడులకు మద్దతు లేదు
కోట్లిన్ సంఖ్యల కోసం విస్తరించే మార్పిడులకు మద్దతు ఇవ్వదు, కాబట్టి చిన్న రకాలు పెద్ద రకాలుగా మార్చబడవు. కోట్లిన్‌లో, మీరు బైట్ రకం విలువను Int వేరియబుల్‌కు కేటాయించాలనుకుంటే, మీరు స్పష్టమైన మార్పిడిని చేయవలసి ఉంటుంది, అయితే జావాకు అవ్యక్త మార్పిడులకు మద్దతు ఉంది.
కోట్లిన్‌తో ఉల్లేఖన ప్రాసెసింగ్ లైబ్రరీలు
ఉల్లేఖన ప్రాసెసింగ్‌పై ఆధారపడే అధునాతన ఫ్రేమ్‌వర్క్‌లతో సహా ఇప్పటికే ఉన్న అన్ని జావా ఫ్రేమ్‌వర్క్‌లు మరియు లైబ్రరీలకు కోట్లిన్ మద్దతు ఇస్తుంది, అయినప్పటికీ కొన్ని జావా లైబ్రరీలు ఇప్పటికే Rx కోట్లిన్ వంటి కోట్లిన్ పొడిగింపులను అందిస్తున్నాయి.
మీరు ఉల్లేఖన ప్రాసెసింగ్‌పై ఆధారపడే జావా లైబ్రరీని ఉపయోగించాలనుకుంటే, దాన్ని మీ కోట్లిన్ ప్రాజెక్ట్‌కు జోడించడం కొద్దిగా భిన్నంగా ఉంటుంది, ఎందుకంటే మీరు దీనిని ఉపయోగించి డిపెండెన్సీని పేర్కొనాలి. kotlin-kapt ప్లగ్ఇన్ చేసి, ఆపై ఉల్లేఖన ప్రాసెసర్‌కు బదులుగా కోట్లిన్ ఉల్లేఖన ప్రాసెసింగ్ సాధనాన్ని (కాప్ట్) ఉపయోగించండి. ఉదాహరణకి:
// ప్లగ్ఇన్ను వర్తించండి // ప్లగిన్‌ను వర్తింపజేయండి: కోట్లిన్-కాప్ట్ // కాప్ట్ కాన్ఫిగరేషన్‌ను ఉపయోగించి సంబంధిత డిపెండెన్సీలను జోడించండి // డిపెండెన్సీలు {kapt "com.google.dagger: dagger-compiler: $ dagger-version" ... ... ...}
జావాతో పరస్పర మార్పిడి
Android అభివృద్ధి కోసం కోట్లిన్ లేదా జావా ఉపయోగించాలా అని చర్చించేటప్పుడు, మూడవ ఎంపిక ఉందని మీరు తెలుసుకోవాలి: రెండింటినీ ఉపయోగించండి. రెండు భాషల మధ్య అన్ని తేడాలు ఉన్నప్పటికీ, జావా మరియు కోట్లిన్ 100% పరస్పరం పనిచేస్తాయి. మీరు జావా నుండి కోట్లిన్ కోడ్‌కు కాల్ చేయవచ్చు మరియు మీరు కోట్లిన్ నుండి జావా కోడ్‌ను కాల్ చేయవచ్చు, కాబట్టి ఒకే ప్రాజెక్ట్‌లో కోట్లిన్ మరియు జావా తరగతులను పక్కపక్కనే కలిగి ఉండటం సాధ్యమే, మరియు ప్రతిదీ ఇప్పటికీ కంపైల్ చేస్తుంది.
మీరు కోట్లిన్‌తో ప్రారంభించేటప్పుడు రెండు భాషల మధ్య వెళ్ళడానికి ఈ వశ్యత ఉపయోగపడుతుంది, ఎందుకంటే ఇది ఇప్పటికే ఉన్న ప్రాజెక్ట్‌లోకి కోట్లిన్‌ను పెంచడానికి మిమ్మల్ని అనుమతిస్తుంది, అయితే మీరు రెండు భాషలను శాశ్వత ప్రాతిపదికన ఉపయోగించడానికి కూడా ఇష్టపడవచ్చు. ఉదాహరణకు, మీరు కోట్లిన్‌లో వ్రాయడానికి ఇష్టపడే కొన్ని లక్షణాలు మరియు జావాలో వ్రాయడానికి మీకు తేలికైన కొన్ని లక్షణాలు ఉండవచ్చు. కోట్లిన్ మరియు జావా రెండూ బైట్‌కోడ్‌కు కంపైల్ చేసినందున, మీ జావా కోడ్ ఎక్కడ ముగుస్తుందో మీ తుది వినియోగదారులకు చెప్పలేరు మరియు కోట్లిన్ కోడ్ ప్రారంభమవుతుంది, కాబట్టి మీరు జావాతో కూడిన అనువర్తనాన్ని విడుదల చేయలేకపోవడానికి ఎటువంటి కారణం లేదు మరియు కోట్లిన్ కోడ్.
మీరు మీ కోసం కోట్లిన్‌ను ప్రయత్నించాలనుకుంటే, మీరు Android స్టూడియో 3.0 ప్రివ్యూ లేదా అంతకంటే ఎక్కువ ఇన్‌స్టాల్ చేసినంత వరకు, మీరు ప్రారంభించడానికి కొన్ని మార్గాలు ఉన్నాయి:
- క్రొత్త Android స్టూడియో ప్రాజెక్ట్ను సృష్టించండి. క్రొత్త ప్రాజెక్ట్ను సృష్టించడం మరియు ప్రాజెక్ట్ సృష్టి విజార్డ్ నుండి ‘కోట్లిన్ మద్దతును చేర్చు’ చెక్‌బాక్స్‌ను ఎంచుకోవడం సులభమైన పద్ధతి.
- ఇప్పటికే ఉన్న డైరెక్టరీకి కోట్లిన్ తరగతిని జోడించండి. సందేహాస్పద డైరెక్టరీని కంట్రోల్-క్లిక్ చేసి, ఆపై ‘ఫైల్> న్యూ> కోట్లిన్ ఫైల్ / క్లాస్’ ఎంచుకోండి. ఆండ్రాయిడ్ స్టూడియో కోట్లిన్‌కు మద్దతుగా మీ ప్రాజెక్ట్ను కాన్ఫిగర్ చేయమని అడుగుతున్న బ్యానర్‌ను ప్రదర్శిస్తుంది; ‘కాన్ఫిగర్’ లింక్‌పై క్లిక్ చేసి, స్క్రీన్ సూచనలను అనుసరించండి.
- ఇప్పటికే ఉన్న జావా ఫైళ్ళను కోట్లిన్‌గా మార్చండి. ఫైల్‌ను కంట్రోల్-క్లిక్ చేసి, ‘కోడ్> జావా ఫైల్‌ను కోట్లిన్ ఫైల్‌గా మార్చండి’ ఎంచుకోవడం ద్వారా మీరు కోట్లిన్ కన్వర్టర్ ద్వారా ఏదైనా జావా ఫైల్‌ను అమలు చేయవచ్చు.
చుట్టి వేయు
మీరు చూడగలిగినట్లుగా, కోట్లిన్‌ను జావా కంటే ఇష్టపడటానికి చాలా మంచి కారణాలు ఉన్నాయి, అయితే జావా పైచేయి ఉన్న కొన్ని ప్రాంతాలు ఉన్నాయి. బహుశా ముఖ్యంగా: చాలా మంది ఆండ్రాయిడ్ డెవలపర్లు ఈ సమయంలో జావాతో బాగా పరిచయం కలిగి ఉన్నారు. కోట్లిన్ వర్సెస్ జావా చర్చ ఎప్పుడైనా పరిష్కరించబడదు, ఇద్దరికీ వారి స్వంత అర్హతలు ఉన్నాయి. కాబట్టి, మీరు కోట్లిన్‌కు మారబోతున్నారా లేదా ఆండ్రాయిడ్ అభివృద్ధికి జావా ఇప్పటికీ ఉత్తమ ఎంపిక అని మీరు భావిస్తున్నారా?
తదుపరి చదవండి: Android అభివృద్ధి కోసం జావా సింటాక్స్ పరిచయం
