Android विकास के लिए Java से Kotlin में माइग्रेट करें: दक्षता बढ़ाएं और अपने ऐप्स को भविष्य-प्रूफ बनाएं

पिछले 2 वर्षों में Kotlin एक बड़ी सफलता रही है, यह हर जगह एक ट्रेंडिंग विषय रहा है और इसकी लोकप्रियता अभी भी बढ़ रही है। और यह आधिकारिक भी है कि Google ने Kotlin को Android ऐप डेवलपमेंट के लिए आधिकारिक भाषा बनाने के लिए जोर दिया है।

लेकिन फिर भी, बहुत से लोग Android विकास के लिए Kotlin पर Java को पसंद करते हैं, ऐसा क्यों है? इसका एक मुख्य कारण यह है कि लोग अभी भी Java से Kotlin में अपनी मुख्य पसंद की भाषा को बदलने में सहज नहीं हैं, लोग नई चीजों में बदलने से डरते हैं।

अब Kotlin का उपयोग शुरू करें, आसान तरीका

वास्तव में, Java से Kotlin में स्विच करना बहुत आसान है, एक बहुत लचीली भाषा होने के नाते, आप आसानी से Kotlin कोड कर सकते हैं लेकिन मुहावरे के तौर पर, यह Java है!

तो अब, Java से Kotlin में स्विच करते समय ध्यान देने योग्य कई चीजें हैं:

1. Java इंटरऑपरेबिलिटी
Kotlin Java के साथ पूरी तरह से इंटरऑपरेबल है और इसके विपरीत भी। इसका क्या मतलब है, इसका मतलब है कि आपका Kotlin आपके Java कोड को कॉल कर सकता है, यह ऐप माइग्रेशन के लिए चीजों को बहुत आसान बनाता है, आप पहले से ही आधा Java में कोड कर चुके हैं? कोई बात नहीं, वैसे भी Kotlin कोड करें।

2. कोई प्रिमिटिव डेटा प्रकार नहीं
याद रखें जब Java में int या Int चुनने में आपको आधा दिन लग जाता था? अब Kotlin में कोई प्रिमिटिव डेटा प्रकार नहीं हैं, सब कुछ ऑब्जेक्ट में लपेटा गया है।

3. थोड़ा बदला हुआ सिंटैक्स (लेकिन चिंता न करें इसे पकड़ना आसान है)
वेरिएबल, फंक्शन और क्लास घोषणा जैसे कई सिंटैक्स थोड़ा बदल गए हैं, लेकिन अगर आप Java जैसे OOP बैकग्राउंड से आते हैं, तो यह इतना बड़ा मुद्दा नहीं होगा। और साथ ही, void कीवर्ड और सेमीकोलन (';') हटा दिए गए हैं, उस सेमीकोलन को हटाने के लिए धन्यवाद Kotlin!!
मैं आपको Android क्लास के साथ बुनियादी उदाहरण प्रस्तुत करूंगा:

//Inheritance and implementation is using ':' now class BasicActivity : AppCompatActivity() { //variables declaration is now variable name first then type var a :Int = 10 //var is for mutable val b :Int = 15 //val is for immutable /*lateinit keyword must be added for initialisation of non- primitive type without initial value in Kotlin*/ lateinit var someTextView:TextView //Also, no more new keyword here var gameList:List<Integer> = ArrayList() //overriding is using keyword instead of override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_basic) } } 

4. टाइप इन्फरेंस
Kotlin वेरिएबल्स के लिए टाइप इन्फरेंस प्रदान करके जीवन को आसान बनाएगा:

var a = 5 //will automatically infer this as integer var b = "John" // will automatically infer this as String 

5. नल सेफ्टी चेक
Kotlin ने नल पॉइंटर एक्सेप्शन से बचने के लिए नल सेफ्टी चेकिंग प्रदान की है। हर वेरिएबल जो नल मान वापस कर सकता है, उसे ? चिह्न से चिह्नित किया जाएगा (और होना चाहिए)।

var a:String? = null var b:String = null //not allowed 

यह नल पॉइंटर एक्सेप्शन (Java बिलियन डॉलर मिस्टेक) से बचने के लिए नल सेफ्टी कॉल भी प्रदान करता है

//not allowed, a might be null a.function() // this will not throw null pointer, instead will continue the flow a?.function() //force function call, can cause NPE, use this only if 100% sure that this value will not be null a!!.function()

6. कोई स्टेटिक कीवर्ड नहीं
स्टेटिक कीवर्ड को अब ऑब्जेक्ट कीवर्ड से बदल दिया गया है, क्लास और मेथड दोनों के लिए, अधिक विशेष रूप से मेथड्स के लिए Companion Object।

7. स्विच केस संशोधित
स्विच केस को अब एक नए कीवर्ड में संशोधित किया गया है, जिसे when कहा जाता है। जो क्लीनर और अधिक लचीला दिखता है:

when (x) { 1 -> println("One") 2 -> print("Two") else -> print("Others") }

8. कोई चेक्ड एक्सेप्शन नहीं
याद रखें जब आप Java में कुछ ऑपरेशन या कास्टिंग कर रहे थे, और वह लाल चेतावनी आती थी और आपको वहां एक्सेप्शन चेकिंग जोड़ने के लिए कहती थी? इसे अब Kotlin में हटा दिया गया है। अब, आपका IDE आपको कोई एक्सेप्शन करने के लिए मजबूर नहीं करेगा!!

यह उस भाग के लिए सब कुछ है जिसे आपको Kotlin में विकसित करना शुरू करने के लिए चाहिए, लेकिन मुहावरे के तौर पर Java।
अब Kotlin में आना कठिन नहीं है, है ना? अब Kotlin Java से इतना अलग नहीं लगता।

Kotlin द्वारा प्रदान की गई विशेषताएं

अब, यह देखने के बाद कि Kotlin और Java कैसे भिन्न हैं, हमें Kotlin द्वारा प्रदान की गई विशेषताओं को देखने और धीरे-धीरे Kotlin को Kotlin तरीके से करना शुरू करने की भी आवश्यकता है:

1. लचीलापन
Kotlin में मेरे प्यार के मुख्य कारणों में से एक भाषा की लचीलापन है। क्या आप OOP शुद्धतावादी हैं? क्या आप फंक्शनल प्रोग्रामिंग को आज़माने के लिए उत्सुक हैं जो वर्तमान में चर्चा का गर्म विषय है? और कोडिंग देवता के प्यार के लिए, आप Kotlin में दोनों कर सकते हैं! FP द्वारा प्रदान की जाने वाली सभी सुविधाओं को पूरी तरह से प्रदान नहीं करने के बावजूद, इसका समर्थन करने के लिए यह काफी अच्छा है।

2. लैम्ब्डा सपोर्ट
हां, मुझे पता है कि अब Java 8 लैम्ब्डा का समर्थन करता है, लेकिन Kotlin इसमें पहले आया और यह इसमें बहुत अच्छा काम करता है। निश्चित रूप से, लैम्ब्डा फंक्शन का उपयोग करने में संक्रमण पहले कठिन होगा, लेकिन जैसा कि कहा गया है, Kotlin उस पर वास्तव में लचीला है। तो अरे, यह आपकी कॉल है!
Android लाइब्रेरी में से कुछ ने भी लैम्ब्डा सपोर्ट सक्षम किया है, उदाहरण के लिए View.OnClickListener (यदि आप Android बैकग्राउंड से आए हैं, तो मुझे यकीन है कि यह मेथड पहले से ही आपके लिए बहुत परिचित है) :

val randomButton : Button //using lambda function as argument randomButton.setOnClickListener{v -> doRandomStuff(v) }

3. डेटा क्लास
Kotlin ने मॉडल/एंटिटी क्लास के लिए एक विकल्प प्रदान किया है, जिसे डेटा क्लास कहा जाता है। यह अनावश्यक सेटर गेटर की आवश्यकता को हटा देता है और इसमें बिल्ट-इन इक्वल मेथड और toString फंक्शन होता है बिना आपको इसके लिए एक बनाने के। इसका उपयोग करना भी बहुत आसान है:

data class Person( val id:String, val name:String = "John Doe" //Default Value ) //Initialisation block var person = Person("id","Not John")

4. एक्सटेंशन फंक्शन्स
Kotlin एक्सटेंशन फंक्शन्स के उपयोग की अनुमति देता है, जो कोड को अधिक पठनीय बनाता है। साथ ही, यह आपको क्लास को संशोधित किए बिना क्लास को कार्यक्षमता देने में सक्षम करेगा:

fun Int.superOperation(anotherInt:Int):Int { val superNumber = this * anotherInt + anotherInt return superNumber } //you can now call the functions val someNumber = 5 val superNumber = someNumber.superOperation(10) //65

5. नामित और डिफ़ॉल्ट आर्गुमेंट्स
C# की तरह, Kotlin भी अपने मेथड्स के लिए नामित और डिफ़ॉल्ट पैरामीटर्स का समर्थन करता है। यह प्रत्येक आर्गुमेंट में मान पास करने की आवश्यकता को पूरी तरह से हटा देता है। आप चुन सकते हैं कि आप किस मान को संशोधित करना चाहते हैं, और वोइला! अपने 10 फंक्शन कॉल्स के लिए वही विशेष मान पास करने में कोई परेशानी नहीं!

//variable declaration fun someOperations(var x: Int, var y:Int, var z:Int = 1){ return x+y+z } someOperations(1,2) //return 4 someOpeartions(y = 1, x = 1) //return 3

6. रेफरेंशियल इक्वलिटी
Kotlin रेफरेंशियल इक्वलिटी ('===') के साथ भी आता है, यह जांच करेगा कि क्या दो वेरिएबल्स वर्तमान में उसी ऑब्जेक्ट को संदर्भित कर रहे हैं।

var a = 10 var b = 10 a == b //true a === b //true also, primitive type object equation will only check its value data class Person (val name: String) val p1 = Person("John") val p2 = Person("John") p1 == p2 //true p1 === p2 //false

7. स्मार्ट कास्टिंग
instance of का उपयोग करने के बजाय, Kotlin अब कास्टिंग या टाइप चेकिंग के लिए उपयोग करने के लिए आसान और अधिक पठनीय सिंटैक्स प्रदान करता है:

//type checking //kotlin smart cast mechanism will also automatically change the object into corresponding type if it passes the type checking if (shape is Circle) { println(“it’s a Circle”) shape.radius //automatically be casted as Circle } else if (shapeObject is Square) { println(“it’s a Square”) } else if (shapeObject is Rectangle) { print(“it’s a Rectangle”) }

Kotlin में as कीवर्ड भी है जो एक्सप्लिसिट कास्टिंग को सक्षम करता है:

//It's considered unsafe since it behaves simillarly like static casting var anotherShape = shape as Circle //This can be used instead for safe casting var safeShape = shape as? Circle

8. कोरूटीन
एसिंक्रोनस कॉल हमेशा Java में एक परेशानी रही है। थ्रेड बनाने में इतना कोड स्पेस लगता है और कोड को अपठनीय बना देता है। कोरूटीन को पारंपरिक थ्रेड ऑपरेशन को बदलने के लिए बनाया गया है, जिससे एक क्लीन और मजबूत कोड मिलता है:

import kotlinx.coroutines.* fun main() { // launch a new coroutine in background and continue GlobalScope.launch { // non-blocking delay for 1 second (default time unit is ms) delay(1000L) // print after delay println("World!") } // main thread continues while coroutine is delayed println("Hello,") // block main thread for 2 seconds to keep JVM alive Thread.sleep(2000L) }

कोरूटीन अधिक जटिल ऑपरेशन्स जैसे Job Joining, Channel, Shared Context और Parents का भी समर्थन करता है। विवरण और अधिक उपयोग यहां पढ़े जा सकते हैं।

इसे समेटना

इसे सारांशित करने के लिए, Kotlin का उपयोग शुरू करना बहुत आसान है, आप Kotlin को बहुत उसी तरह कोड कर सकते हैं जैसे आप Java कोड करते हैं। और साथ ही, Kotlin ने कई विशेषताएं प्रदान की हैं जो आपको Java का उपयोग करने पर बढ़त दे सकती हैं।

निश्चित रूप से, Java अभी भी वर्तमान में मजबूत हो रहा है। लेकिन कुछ नया सीखना शुरू करना कभी गलत नहीं है। हम, प्रोग्रामर्स के रूप में, आजीवन सीखने को अपनाने और कभी भी सीखना बंद नहीं करने की आवश्यकता है। Kotlin के बारे में सबसे अच्छी बात यह है कि Java से माइग्रेट करना कितना आसान है।

पढ़ने के लिए धन्यवाद। मुझे आशा है कि आप आनंद लेंगे और उम्मीद है कि यह अच्छे उपयोग का होगा! Kotlin का पता लगाने में शुभकामनाएं, और अगली बार मिलते हैं।