Open classes and inheritance: named parameters and default values; open and abstract; interface; getters and setters; visibility of properties, methods and class

📖 Theory

એ class જેણે લંબાવા દેવાની ના પાડી

Java ના programmer નો Kotlin માં વારસો લેવાનો પહેલો પ્રયત્ન સામાન્ય રીતે ગૂંચવણભરી ભૂલ સાથે નિષ્ફળ જાય છે. તમે class Attendee : Person() લખો છો, અને Kotlin ફરિયાદ કરે છે કે Person તો FINAL છે અને એનો વારસો લઈ શકાય નહીં.

Kotlin નો આ સૌથી નવાઈ પમાડનારો OOP નિયમ છે: classes મૂળભૂત રીતે final હોય છે. વારસો શક્ય બનાવવા માટે તમારે માતાપિતા class ને સ્પષ્ટપણે open ચિહ્નિત કરવો પડે, જે Java થી બરાબર ઊલટું છે, જ્યાં તમે final ન લખો ત્યાં સુધી બધું જ વારસો લેવા યોગ્ય હોય છે. આ સલામતી માટે જાણી જોઈને લેવાયેલી પસંદગી છે. આ પાઠ Kotlin માં વારસો, abstract classes, interfaces, property ના accessors, દૃશ્યતા અને મૂળભૂત parameter કિંમતો આવરી લે છે, અને FestConnect Mobile નો પદાર્થ આધારિત ઢાંચો પૂરો કરે છે.

📖 Theory

વારસો: open હોવું જરૂરી છે

Kotlin માં કોઈ class નો વારસો લેવો હોય તો બંને બાજુએ સહકાર જોઈએ:

• માતાપિતા class open ચિહ્નિત હોવો જોઈએ: open class Person(val name: String)
• જે સભ્યને તમે override કરવા માગો છો તે પણ open હોવો જોઈએ
• બાળક override વાપરે છે: override fun describe()

Syntax: class Attendee(name: String) : Person(name) (colon, અને માતાપિતાનો constructor બોલાવાય છે).

આ Java (BCA403) થી ઊલટું છે, જ્યાં classes અને methods મૂળભૂત રીતે જ open હોય છે અને એમને બંધ કરવા તમે final લખો છો. Kotlin નું મૂળભૂત વલણ final (બંધ) છે; વારસા માટે તમારે જાતે હા પાડવી પડે છે. કારણ આ છે: વારસો એ જાણી જોઈને લેવાયેલો રચનાનો નિર્ણય હોવો જોઈએ, અકસ્માત નહીં, એટલે સલામત મૂળભૂત વલણ એ કે 'ઇરાદો ન હોય ત્યાં સુધી લંબાવી શકાય નહીં'.

⌨️ Practical

open class, override અને મૂળભૂત parameter

// વારસો લેવા માટે માતાપિતા OPEN હોવો જ જોઈએ:
open class Person(val name: String) {
    open fun describe() = "Person: $name"   // override શક્ય બનાવવા open
}

// બાળક : વડે વારસો લે છે અને માતાપિતાનો constructor બોલાવે છે:
class Attendee(name: String, val event: String) : Person(name) {
    override fun describe() = "Attendee $name for $event"   // override
}

// મૂળભૂત PARAMETER કિંમત: role ની મૂળભૂત કિંમત "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 (મૂળભૂત)
    println(register("Zoya", "vip")) // Zoya registered as vip
}

📖 Theory

Abstract, interfaces, accessors, દૃશ્યતા અને મૂળભૂત કિંમતો

Kotlin ના OOP ના બાકીના સાધનો, જે મોટે ભાગે પરિચિત છે:

• abstract classes: એમનો પદાર્થ બનાવી શકાતો નથી; અને abstract સભ્યોને override કરવા જ પડે (Java ની જેમ)
• interfaces: interface, જેમાં abstract સભ્યો પણ હોય અને મૂળભૂત અમલો પણ; અને એક class અનેક interfaces લાગુ કરી શકે
• getters અને setters: properties ને મૂળભૂત accessors મળે છે; જ્યાં logic જોઈએ ત્યાં તમે backing field સાથે પોતાના get() અને set(value) લખી શકો
• દૃશ્યતા: public (મૂળભૂત), private, protected, અને internal (એ જ MODULE માં દેખાય, જે સ્તર Java માં નથી)
• મૂળભૂત parameter કિંમતો: fun greet(name: String = "Guest") બોલાવનારને દલીલો છોડી દેવા દે છે, જેથી અનેક overloaded functions ની જરૂર ઘટે છે

મૂળભૂત કિંમતો ગયા પાઠના named parameters સાથે સરસ રીતે ભળે છે: એક લવચીક function અનેક overloads ની જગ્યા લઈ લે છે.

🧩 Quiz

તમે class Attendee : Person() લખો છો પણ ભૂલ મળે છે કે Person નો વારસો લઈ શકાય નહીં. કેમ, અને એ કઈ રીતે સુધરે?

1. Person ને constructor જોઈએ; એક ઉમેરી દો
2. Kotlin ના classes મૂળભૂત રીતે FINAL હોય છે; વારસો શક્ય બનાવવા માતાપિતાને 'open class Person' ચિહ્નિત કરો (Java થી ઊલટું)
3. તમારે colon નહીં પણ 'extends' keyword વાપરવું પડે
4. Kotlin વારસાને ટેકો જ આપતું નથી

💭 Think first

'મૂળભૂત રીતે final' એ વધુ સલામત પસંદગી કેમ છે?

Java ના classes મૂળભૂત રીતે open (વારસો લેવા યોગ્ય) હોય છે; Kotlin ના classes મૂળભૂત રીતે final (બંધ) હોય છે. Kotlin પોતાના મૂળભૂત વલણને વધુ સલામત કેમ ગણે છે? વિચારીને પછી tap કરો.

⚠️ Watch out

Kotlin માં વારસાના ફાંદા

open ભૂલી જવું: classes અને સભ્યો મૂળભૂત રીતે final છે; વારસો કે override કરવા એમને open ચિહ્નિત કરો (Java ની ટેવથી થતી ભૂલ).

extends અને implements: Kotlin વારસા માટે અને interface લાગુ કરવા માટે, બંને માટે colon (:) વાપરે છે, એ keywords નહીં.

માતાપિતાનો constructor બોલાવવો: : Person(name) એને બોલાવે છે; દલીલો ભૂલી જાઓ તો ભૂલ મળે છે.

override keyword ફરજિયાત: override થતા સભ્ય પર તમારે override લખવું જ પડે (Kotlin તમને અકસ્માતે ઢાંકી દેવા નહીં દે).

internal સામે private: internal આખા module માં દેખાય છે, જ્યારે private ફક્ત class કે file માં: આ ભેદ જાણો (internal એ Java ની સરખામણીએ નવું છે).

📖 Theory

એકમ 2 પૂરો: Kotlin નું OOP હાથમાં આવ્યું

FestConnect Mobile પાસે હવે Kotlin નો પૂરો પદાર્થ આધારિત ઢાંચો છે: ટૂંકા classes, ઇરાદાપૂર્વક open કરેલો સલામત વારસો, abstract classes, interfaces, પોતાના accessors અને મૂળભૂત parameters. ભાષા આટલેથી પૂરી. એકમ 3 હવે ખરેખર Android app બાંધવા તરફ વળે છે: JSON parse કરવું, intents વડે screens વચ્ચે ફરવું, SQLite માં data સંઘરવો, અને સ્થાન તથા કૅમેરા જેવી ઉપકરણની સુવિધાઓ વાપરવી. ભાષામાંથી હવે ખરી, data પર ચાલતી, અનેક screens વાળી mobile app તરફ.

✅ Summary

Key takeaways

• Kotlin ના classes મૂળભૂત રીતે FINAL છે: વારસો શક્ય બનાવવા માતાપિતાને 'open' ચિહ્નિત કરો, અને override કરવા સભ્યોને પણ 'open' (Java થી ઊલટું).
• વારસો colon થી લેવાય: class Attendee(name) : Person(name); અને બાળક override થતા સભ્યો પર 'override' લખે છે.
• abstract classes નો પદાર્થ બનાવી શકાતો નથી; interfaces માં abstract સભ્યો પણ હોય અને મૂળભૂત અમલો પણ, અને એક class અનેક interfaces લાગુ કરી શકે છે.
• Properties ને મૂળભૂત getters અને setters મળે છે; logic જોઈએ ત્યાં backing field સાથે પોતાના get() અને set(value) લખો.
• દૃશ્યતા: public (મૂળભૂત), private, protected અને internal (એ જ module માં: Java ની સરખામણીએ નવું).
• મૂળભૂત parameter કિંમતો (fun greet(name: String = "Guest")) બોલાવનારને દલીલો છોડી દેવા દે છે, જેથી overloads ઘટે છે; અને એ named parameters સાથે જોડીને વાપરો.
• યાદ રાખવાની કડી: મૂળભૂત રીતે final, વારસો લેવા open, અને override કરવા override: એટલે કે વારસો જાતે પસંદ કરવાનો છે.