जावा बनाम कोटलिन में एक त्वरित पीक

Kotlin JetBrains की एक नई प्रोग्रामिंग भाषा है, जो दुनिया की सबसे अच्छी IDEs बनाने वाली कंपनी है।

पिछले साल इस समय Google ने Kotlin की घोषणा की, Google I / O17 पर Android App Development के लिए एक और आधिकारिक भाषा के रूप में।

एक वर्ष में, कोटलिन पर बहुत सारे लेख हैं और डेवलपर्स तीव्र गति से कोटलिन की ओर पलायन कर रहे हैं।

Airtel Product Engineering में, हम हमेशा नई तकनीकों के साथ प्रयोग कर रहे हैं और उन्हें अपने उत्पादों में अपना रहे हैं। कोटलिन पर मेरा विश्लेषण निम्नलिखित है।

किसी भाषा का वर्णन करने वाले अधिकांश लेखों के विपरीत, मैं बहुत अधिक प्रोग्रामिंग शब्दों का उपयोग करने से बचने जा रहा हूं। इसके बजाय, मैं सिर्फ सादे अंग्रेजी का उपयोग करूंगा, ताकि यह फ्रेशर्स के लिए सहायक हो।

चलिए मेरे कुछ वर्तमान पसंदीदा के साथ शुरू करते हैं।

  1. परिभाषित चर:

जावा में, हमारे पास Read Only Variable के लिए अंतिम है।

// जावा
अंतिम चार्ट a = ‘A '; // केवल `चार` प्रकार पढ़ें
char b = 'B'; // म्यूटेबल `चार` टाइप
बी = 'सी';

Kotlin में, हमारे पास Mutable Variable के लिए Read Only Variable & var की वैल है।

// कोटलिन
वैल a = 'A' // रीड ओनली `चार` प्रकार का अनुमान है
var b = 'B' // म्यूटेबल `चार` प्रकार का अनुमान है
बी = 'सी'

2. स्ट्रिंग टेम्पलेट्स:

जावा में, हमने स्ट्रिंग्स को फॉर्मेट करने के लिए String.format का उपयोग किया

// जावा
int a = 20;
अंतिम स्ट्रिंग t1 = String.format ("एमी उम्र% d है", ए);
a = 25;
अंतिम स्ट्रिंग t2 = String.format ("% s, अब% d है।", t1.replace ("is", "is"), a);

कोटलिन में, हम टेम्पलेट में अभिव्यक्ति का उपयोग कर सकते हैं।

// कोटलिन
var a = 20
वैल t1 = "एमी की उम्र $ एक" है
a = 25 है
वैल t2 = "$ {t1.replace (" है "," था ")}, अब $ a है।"

अंतर देखें, कोटलिन इतना पठनीय और साफ है।

3. अशक्त सुरक्षा (अशक्त प्रकार और अशक्त प्रकार)

जावा में, डिफ़ॉल्ट रूप से सब कुछ शून्य है। इसलिए, हमें एनपीई से बचने के लिए कई जांचों की आवश्यकता थी

// जावा
स्ट्रिंग नाम = अशक्त;

// एनपीई से बचने का सुरक्षित तरीका
अगर (शून्य! = नाम) {
    int लंबाई = name.length ();
}
// एनपीई फेंकता है
int length2 = name.length ();

कोटलिन का प्रकार प्रणाली कोड से शून्य संदर्भ के खतरे को समाप्त करने के उद्देश्य से है, जिसे बिलियन डॉलर गलती के रूप में भी जाना जाता है।

एक नियमित स्ट्रिंग शून्य नहीं हो सकती है, लेकिन अशक्त स्ट्रिंग की अनुमति देने के लिए, हमें स्ट्रिंग के रूप में टाइप देना होगा।

// कोटलिन
वैल नाम: स्ट्रिंग = "जावा"
name = null // कंपाइलर एरर
वैल अंतिम नाम: स्ट्रिंग? = "कोटलिन"
lastName = null // वर्क्स फाइन

वैरिएबल प्रॉपर्टीज को एक्सेस करने के दौरान रेगुलर स्ट्रिंग NPE नहीं बल्कि स्ट्रींग को फेंकेगा? एनपीई फेंक देंगे।

इससे बचने के कुछ तरीके हैं:

  • अगर-और सामान्य जाँच का उपयोग करना
// सामान्य जाँच
वैल लंबाई = if (lastName! = null) lastName.length और -1
  • SafeCall का उपयोग? ऑपरेटर (कोटलिन में सबसे अच्छी सुविधा में से एक)
// सुरक्षित कॉल
वैल लेंथ = लास्टनाम।? लवलीन // आउटपुट: लास्टनाम लैम या नल

यह अंतिम नाम देता है। सुरक्षित कॉल? वास्तव में सम्राज्ञी की श्रृंखला में उपयोगी है?

यदि हम अशक्त नहीं लौटना चाहते हैं, और कुछ डिफ़ॉल्ट मान लौटना चाहते हैं। हम एल्विस ऑपरेटर का उपयोग कर सकते हैं?

// एल्विस ऑपरेटर का उपयोग करना
वैल लेंथ = लास्टनेम?। लवलीन ?: -1 // आउटपुट: लास्टनाम लेंथ या -1
  • का उपयोग कर !! ऑपरेटर (एनपीई प्रेमियों के लिए)
// का उपयोग !! ऑपरेटर
वैल लंबाई = अंतिम नाम !! लंबाई // फेंको एनपीई, अगर अंतिम नाम शून्य है

4. टाइप चेक एंड ऑटोमैटिक कास्टिंग

जावा में, हम प्रकार की जांच करने के लिए इंस्टाफॉ का उपयोग करते हैं, और फिर इसके गुणों तक पहुंचने के लिए कास्ट टाइप करने की आवश्यकता होती है।

// जावा
अगर (नाम Instof स्ट्रिंग) {
    int length = ((स्ट्रिंग) नाम) .length ();
}

कोटलिन में, हम टाइप चेक करने के लिए उपयोग करते हैं, और कंपाइलर चालाकी से टाइप करते हैं। बहुत बढ़िया

// कोटलिन
अगर (नाम स्ट्रिंग है) {
    वैल लंबाई = name.length
}

अधिक जानकारी यहां दी गई है।

5. जब अभिव्यक्ति

Ex के लिए: मैं ऑब्जेक्ट 1 या 5 या स्ट्रिंग या कुछ अन्य प्रकार ढूंढना चाहता हूं।

जावा में, हमें कार्य करने के लिए Instof और स्विच का उपयोग करना होगा।

// जावा
निजी स्ट्रिंग switchExample (ऑब्जेक्ट नाम) {
    अगर (नाम इंस्टोफ़ इंटेगर) {
        Integer tempInt = (पूर्णांक) नाम;
        स्विच (tempInt) {
            मामला एक:
            केस 5:
                वापसी "1 या 5";
            चूक:
                वापसी "1 या 5 नहीं";
        }
    } और अगर (नाम इंस्टोफ़ स्ट्रिंग) {
        वापसी "स्ट्रिंग";
    }
    वापसी "इंट नहीं या स्ट्रिंग";
}

कोटलिन में, जब अभिव्यक्ति इसे सरल बनाती है। यह स्वचालित प्रकार कास्ट है और हम इसके अंदर कई अभिव्यक्ति का उपयोग कर सकते हैं। उसके ऊपर, यह इतना पठनीय है।

// कोटलिन
मज़ा जबExample (नाम: कोई भी): स्ट्रिंग =
        जब (नाम) {
            1, 5 -> "1 या 5"
            Int है -> "1 या 5 नहीं"
            स्ट्रिंग है -> "स्ट्रिंग"
            और -> "इंट नहीं या स्ट्रिंग"
        }

6. कक्षाएं

जावा में, हमें एक वर्ग में गुणों तक पहुँचने के लिए गेटटर और सेटर बनाना होगा।

// जावा
पब्लिक क्लास कस्टमर {
    निजी स्ट्रिंग नाम;

    सार्वजनिक ग्राहक (स्ट्रिंग नाम) {
        this.name = नाम;
    }

    सार्वजनिक स्ट्रिंग getName () {
        वापसी का नाम;
    }

    सार्वजनिक शून्य सेटनाम (स्ट्रिंग नाम) {
        this.name = नाम;
    }
}

कोटलिन में, कोई अधिक गेटर्स और बसने वाला नहीं है। लेकिन हम बना सकते हैं, यदि आप कस्टम वाले सेट करना चाहते हैं।

// कोटलिन
वर्ग ग्राहक (var नाम: स्ट्रिंग)

कोटलिन में यह सबसे अच्छा है। जब मैंने यह देखा, तो मेरे दिमाग में एक शब्द आया वाह !!! यह कमाल है

इसलिए, बस कुछ बातों पर एक संक्षिप्त नज़र डालें, जो हमारे जीवन को बेहतर बनाती हैं। माध्यम में मेरी पहली पोस्ट पढ़ने के लिए धन्यवाद। आप लिंक में सभी उपरोक्त कोड स्निपेट्स तक पहुँच सकते हैं।

यदि आप कोटलिन का उपयोग शुरू करना चाहते हैं, तो कृपया उनके आधिकारिक दस्तावेज पर एक नज़र डालें। ये वाकई अच्छा हैं।

अधिक अपडेट देखने के लिए, मुझे माध्यम या ट्विटर पर फ़ॉलो करें। अपने विचारों को टिप्पणी अनुभाग में छोड़ दें या ट्विटर पर मेरे पास पहुंचें और मैं श्रृंखला में जुड़ता रहूंगा।

यदि आपको यह पसंद है, तो कृपया ताली बजाएं। यदि आप ताली का बटन पकड़ते हैं, तो आप अधिक ताली छोड़ सकते हैं।