Theory
वह Crash जिसे रोकने के लिए Kotlin बनी थी
BCA403 में, आप Java के सबसे infamous crash से मिले: NullPointerException, एक variable पर एक method call करना जो null निकली। यह RUNTIME पर strike करता है, अक्सर एक user के सामने।
Kotlin के designers ने इस bug को KILL करने की कोशिश की, और largely किया। Kotlin में, एक variable null hold नहीं कर सकता जब तक आप explicitly इसे permit न करें, और COMPILER यह enforce करता है। यह lesson Kotlin के variables cover करता है, इसका val/var distinction, और इसका signature feature: null safety, Java पर Kotlin prefer करने का single biggest reason। FestConnect Mobile का data design से crash-resistant होगा।
Theory
val, var, और Types
Kotlin के पास दो variable keywords हैं:
- val: read-only, एक बार assigned (Java के
finalजैसा)। Default से इसे prefer कीजिए - var: mutable, reassign हो सकता है
val fest = "TechnoUtsav" (बदल नहीं सकता); var seats = 350 (बदल सकता है)। Types आमतौर पर INFERRED होते हैं (val x = 5 एक Int है), या explicitly declared (val x: Int = 5)।
Types Java से familiar हैं: Byte, Short, Int, Long, Float (एक f suffix के साथ), Double, Boolean, Char (single quotes), String (double quotes, $ templates के साथ)। val prefer करना code को safer और clearer बनाता है: यह signal करता है 'यह नहीं बदलेगा', जो compiler enforce करता है।
Theory
Null Safety: Signature Feature
यहाँ Kotlin का defining idea है। Default से, एक type null hold नहीं कर सकता:
val name: String = null एक COMPILE ERROR है।
Null allow करने के लिए, आप type को ? से nullable mark करते हैं:
val name: String? = null fine है।
यह आपको FORCE करता है DECIDE करने के लिए, up front, कि एक value null हो सकती है या नहीं, और compiler आपसे nullable case को safely handle करवाता है। एक nullable value इस्तेमाल करने के लिए:
- safe call `?.`:
name?.lengthlength return करता है, याnullअगर name null है (कोई crash नहीं) - Elvis `?:`:
name?.length ?: 0null होने पर एक DEFAULT (0) देता है - not-null assertion `!!`:
name!!.lengthइसे force करता है, null होने पर THROWING (rarely इस्तेमाल कीजिए)
चूँकि nullability TYPE में है और compile time पर checked है, ज़्यादातर NullPointerExceptions impossible हो जाते हैं।
Practical
Action में Null Safety
fun main() {
val fest: String = "TechnoUtsav" // non-null: cannot be null
// val bad: String = null // COMPILE ERROR
var nickname: String? = null // nullable: ? allows null
// Safe call: returns null instead of crashing
println(nickname?.length) // null (nickname is null)
nickname = "Techno"
println(nickname?.length) // 6
// Elvis operator: a default when null
val len = nickname?.length ?: 0 // 6 here; 0 if null
println(len)
}
Quiz
Kotlin में, val name: String = null क्या cause करता है?
- यह काम करता है: name null hold करता है
- एक COMPILE ERROR: एक non-nullable String null hold नहीं कर सकता; null allow करने के लिए आपको इसे String? declare करना पड़ेगा
- एक runtime NullPointerException
- name एक empty string बन जाता है
Show the answer
एक COMPILE ERROR: एक non-nullable String null hold नहीं कर सकता; null allow करने के लिए आपको इसे String? declare करना पड़ेगा
Default से Kotlin types NON-NULLABLE हैं, तो एक String को null assign करना एक COMPILE ERROR है, compiler आपको program चलने से पहले रोकता है। Null permit करने के लिए आपको type को nullable mark करना पड़ेगा: String? (question mark के साथ)। यह compile-time enforcement exactly वह तरीका है जिससे Kotlin ज़्यादातर NullPointerExceptions eliminate करता है: danger compilation के दौरान पकड़ा जाता है, runtime crash की तरह नहीं। Option A ग़लत है (non-nullable null reject करता है)। Option C JAVA का behaviour describe करता है (null assigned, बाद में crash); Kotlin check को EARLIER move करता है, compile time पर। Option D एक default invent करता है। Core idea: nullability type का हिस्सा है, और compiler इसे enforce करता है, तो null bugs जल्दी surface होते हैं।
Think first
Kotlin NullPointerException को कैसे Kill करता है
Java (BCA403) में, एक NullPointerException runtime पर strike करता है जब आप एक null पर एक method call करते हैं। Kotlin का design इसे कभी एक user तक पहुँचने से कैसे रोकता है? फिर tap कीजिए।
Show the answer
Kotlin NULLABILITY को TYPE का हिस्सा बनाता है और इसे COMPILE TIME पर enforce करता है। एक String null नहीं हो सकता; सिर्फ़ एक String? हो सकता है। और जब आपके पास एक String? है, compiler आपको इस पर directly एक method call करने से REFUSE करता है (name.length एक nullable पर एक error है): आपको null case handle करना PADEGA, safe call ?. इस्तेमाल करते हुए (crash की बजाय null return करता है), Elvis operator ?: (एक default), या explicit !! (जिसे आप deliberately choose करते हैं, risk accept करते हुए)। तो 'अगर यह null हो तो?' वाला question जो Java आपको IGNORE करने देती है जब तक यह crash न हो, Kotlin आपको ANSWER करने के लिए force करती है coding करते हुए। Bug compilation के दौरान पकड़ा जाता है, app ship होने से पहले, तो यह कभी एक crash की तरह user तक नहीं पहुँचता। Check को runtime से compile time पर move करना पूरी trick है, और यही वजह है null safety Kotlin का flagship feature है।
Watch out
Variable और Null-Safety Traps
एक val Reassign करना: val read-only है; अगर इसे बदलना ज़रूरी है var इस्तेमाल कीजिए।
!! Overuse करना: not-null assertion !! उस crash risk को फिर introduce करता है जो Kotlin ने हटाया; ?. और ?: prefer कीजिए।
Genuinely Nullable Data के लिए ? भूलना: network या एक form से data null हो सकता है; इसे nullable type कीजिए और handle कीजिए।
बिना f वाला Float: 3.5 एक Double है; एक Float को 3.5f चाहिए।
var को Default बनाना: reassign करने की ज़रूरत न होने तक val prefer कीजिए; यह safer और clearer है।
Theory
Data Safe है; अब Decisions
FestConnect Mobile के variables अब typed और null-safe हैं। अगला, app को DECISIONS लेने चाहिए: Kotlin का if और, especially, इसका powerful when expression (एक supercharged switch), plus ranges। एक Kotlin twist जो आपको पसंद आएगा: if और when EXPRESSIONS हैं जो एक value return करते हैं, सिर्फ़ statements नहीं। Conditionals अगले हैं, फिर arrays/lists और loops Kotlin की basics complete करते हैं।
Summary
Key takeaways
- val read-only है (एक बार assign, Java final की तरह); var mutable है; default से val prefer कीजिए।
- Types आमतौर पर inferred होते हैं (val x = 5 एक Int है) या declared (val x: Int = 5); familiar set: Byte, Short, Int, Long, Float (f), Double, Boolean, Char, String।
- Null safety: default से एक type null hold नहीं कर सकता; val name: String = null एक compile error है।
- एक type को ? से nullable mark कीजिए: val name: String? = null null allow करता है।
- Nullable values को safe call ?. से handle कीजिए (crash की बजाय null), Elvis ?: (एक default), या !! (force करता है, null होने पर throw करता है: rare)।
- Nullability type में है और compile time पर checked है, ज़्यादातर NullPointerExceptions (Java का runtime crash) eliminate करते हुए।
- Memory hook: var पर val, null allow करने के लिए ?, इसे safely handle करने के लिए ?. और ?:, sure होने पर ही !!।