Theory
वह Class जिसने Extend होने से Refuse किया
एक Java programmer की पहली Kotlin inheritance attempt आमतौर पर एक confusing error से fail होती है। आप लिखते हैं class Attendee : Person(), और Kotlin complain करता है कि Person FINAL है और inherit नहीं हो सकता।
यह Kotlin का सबसे surprising OOP rule है: classes default से final होती हैं। Inheritance allow करने के लिए, आपको explicitly parent को open mark करना पड़ता है, Java का exact OPPOSITE, जहाँ आप final न लिखें तो सब कुछ inheritable है। यह एक deliberate safety choice है। यह lesson Kotlin inheritance, abstract classes, interfaces, property accessors, visibility, और default parameter values cover करता है, FestConnect Mobile का object model complete करते हुए।
Theory
Inheritance: open चाहिए
Kotlin में, एक class से inherit करने के लिए, दोनों को cooperate करना पड़ता है:
- parent class को open mark होना चाहिए:
open class Person(val name: String) - जिस member को आप override करना चाहते हैं वह भी
openहोना चाहिए - child override इस्तेमाल करता है:
override fun describe()
Syntax: class Attendee(name: String) : Person(name) (एक colon, और parent constructor call होता है)।
यह Java (BCA403) का REVERSE है, जहाँ classes और methods default से open हैं और इन्हें CLOSE करने के लिए आप final लिखते हैं। Kotlin का default final (closed) है; आप inheritance में opt IN करते हैं। Reasoning: inheritance एक deliberate design decision होना चाहिए, accident नहीं, तो safe default 'extend नहीं हो सकता जब तक intended न हो' है।
Practical
open class, override, और एक Default Parameter
// Parent must be OPEN to be inherited:
open class Person(val name: String) {
open fun describe() = "Person: $name" // open to allow override
}
// Child inherits with : and calls the parent constructor:
class Attendee(name: String, val event: String) : Person(name) {
override fun describe() = "Attendee $name for $event" // override
}
// DEFAULT PARAMETER VALUE: role defaults to "guest"
fun register(name: String, role: String = "guest") =
"$name registered as $role"
fun main() {
val p: Person = Attendee("Riya", "Garba")
println(p.describe()) // Attendee Riya for Garba
println(register("Aman")) // Aman registered as guest (default)
println(register("Zoya", "vip")) // Zoya registered as vip
}
Theory
Abstract, Interfaces, Accessors, Visibility, Defaults
Kotlin के OOP toolkit का बाकी हिस्सा, ज़्यादातर familiar:
- abstract classes: instantiate नहीं हो सकतीं; abstract members override होने चाहिए (Java की तरह)
- interfaces:
interface, abstract members AND default implementations के साथ; एक class कई implement कर सकती है - getters/setters: properties में default accessors होते हैं; जब आपको logic चाहिए तो आप एक backing field वाला custom
get()/set(value)लिख सकते हैं - visibility:
public(default),private,protected, औरinternal(same MODULE में visible, एक level जो Java के पास नहीं है) - default parameter values:
fun greet(name: String = "Guest")callers को arguments omit करने देता है, overloaded functions की ज़रूरत कम करते हुए
Default values named parameters (last lesson) के साथ खूबसूरती से pair होती हैं: एक flexible function कई overloads को replace करता है।
Quiz
आप class Attendee : Person() लिखते हैं पर एक error मिलता है कि Person inherit नहीं हो सकता। क्यों, और क्या इसे fix करता है?
- Person को एक constructor चाहिए; एक add कीजिए
- Kotlin classes default से FINAL होती हैं; inheritance allow करने के लिए parent को 'open class Person' mark कीजिए (Java का opposite)
- आपको 'extends' keyword इस्तेमाल करना पड़ेगा, colon नहीं
- Kotlin inheritance support नहीं करता
Show the answer
Kotlin classes default से FINAL होती हैं; inheritance allow करने के लिए parent को 'open class Person' mark कीजिए (Java का opposite)
Kotlin classes DEFAULT से FINAL (closed) होती हैं, तो एक plain class Person inherit नहीं हो सकता; इसे allow करने के लिए आपको explicitly इसे open class Person mark करना पड़ेगा (और किसी भी member पर open जिसे आप override करना चाहते हैं)। यह Java का REVERSE है, जहाँ classes default से open हैं और इन्हें close करने के लिए आप final लिखते हैं। Option A इसे misdiagnose करता है (issue finality है, missing constructor नहीं)। Option C ग़लत है: Kotlin inheritance के लिए एक colon (: Person()) इस्तेमाल करता है, extends नहीं। Option D false है: Kotlin inheritance को पूरी तरह support करता है, बस इसमें opt IN करना ज़रूरी है। Design reason: inheritance intentional होनी चाहिए, तो safe default accidental extension रोकता है। याद रखिए: inherit करने के लिए open, override करने के लिए override।
Think first
'Final by Default' Safer Choice क्यों है?
Java classes default से open (inheritable) हैं; Kotlin classes default से final (closed) हैं। Kotlin अपने default को safer क्यों मानता है? फिर tap कीजिए।
Show the answer
क्योंकि inheritance एक POWERFUL पर RISKY relationship है: एक subclass अपने parent के internal behaviour पर depend करता है, और अगर parent extend होने के लिए DESIGNED नहीं था, एक subclass subtle तरीकों से break हो सकता है जब parent बदलता है ('fragile base class' problem)। Java का open-by-default मतलब है EVERY class inheritable है चाहे इसके author ने intend किया हो या नहीं, तो subclasses उन classes को extend कर सकते हैं जो कभी extend होने के लिए meant नहीं थीं, hidden, brittle dependencies बनाते हुए। Kotlin का final-by-default इसे flip करता है: एक class closed है जब तक इसका author DELIBERATELY इसे open mark न करे, signal करते हुए 'मैंने इसे safely extend होने के लिए design किया'। तो inheritance एक intentional, documented decision बन जाता है, accident नहीं। यह 'design for inheritance or prohibit it' principle follow करता है। आप कुछ नहीं खोते (जब आप मतलब रखते हों तो open mark कीजिए) और safety पाते हैं: कोई accidental, fragile subclassing नहीं। Safe default वह है जो आपको risky feature में opt-in करने के लिए कहता है।
Watch out
Kotlin Inheritance Traps
open भूलना: classes और members default से final हैं; inherit/override करने के लिए इन्हें open mark कीजिए (Java-reflex bug)।
extends/implements: Kotlin inheritance और interface implementation दोनों के लिए एक colon (:) इस्तेमाल करता है, वे keywords नहीं।
Parent Constructor Call करना: : Person(name) इसे call करता है; arguments भूलना error देता है।
override Keyword चाहिए: एक overriding member पर आपको override लिखना पड़ेगा (Kotlin आपको accidentally shadow नहीं करने देगा)।
internal बनाम private: internal module-wide है, private class/file है: फ़र्क़ जानिए (internal Java के मुक़ाबले नया है)।
Theory
Unit 2 Complete: Kotlin OOP Mastered
FestConnect Mobile के पास अब एक full Kotlin object model है: concise classes, safe inheritance (intent से open), abstract classes, interfaces, custom accessors, और default parameters। यह language है, complete। Unit 3 actually Android app BUILD करने की तरफ़ मुड़ता है: JSON parse करना, intents के साथ screens के बीच move करना, SQLite में data store करना, और location और camera जैसे device features इस्तेमाल करना। Language से एक real, data-driven, multi-screen mobile app तक।
Summary
Key takeaways
- Kotlin classes default से FINAL होती हैं: inheritance allow करने के लिए parent को 'open' mark कीजिए, और override करने के लिए members को 'open' (Java का opposite)।
- एक colon से inherit कीजिए: class Attendee(name) : Person(name); overridden members पर child 'override' इस्तेमाल करता है।
- abstract classes instantiate नहीं हो सकतीं; interfaces में abstract members और default implementations हो सकते हैं, और एक class कई implement कर सकती है।
- Properties में default getters/setters हैं; logic के लिए एक backing field वाला custom get()/set(value) लिखिए।
- Visibility: public (default), private, protected, internal (same module: Java के मुक़ाबले नया)।
- Default parameter values (fun greet(name: String = "Guest")) callers को arguments omit करने देते हैं, overloads कम करते हुए; named parameters के साथ pair होते हैं।
- Memory hook: default से final, inherit करने के लिए open, override करने के लिए override: inheritance opt-in है।