Object oriented concepts: properties, methods and basics of objects and classes in Kotlin; named parameters, constructors

📖 Theory

એક જ લીટીમાં પોતાની જાહેરાત કરતો class

BCA403 ના Java માં Event નામનો class વ્યાખ્યાયિત કરવો એટલે fields જાહેર કરવાં, constructor લખવો અને દરેક field ને કિંમત આપવી: સાવ સાદા data ના પાત્ર માટે ડઝનેક લીટીનો દેખાડો.

Kotlin આ બધું સંકેલી લે છે. તમે class ની PROPERTIES સીધી એના constructor ના મથાળામાં જ જાહેર કરી શકો છો:

class Event(val name: String, var seats: Int)

એક જ લીટી, અને તમારી પાસે બે properties, એક constructor, અને શું ફક્ત વાંચી શકાય તથા શું બદલી શકાય એનો કાબૂ, બધું આવી ગયું. આ પાઠમાં Kotlin ના classes, એમના ટૂંકા constructors, properties અને methods, તથા named parameters શીખશો, અને FestConnect Mobile નો Event class Java ના boilerplate ના નાનકડા અંશમાં જ બનાવશો. તમારા OOP ના ખ્યાલો સાથે જ આવે છે; ફક્ત syntax ઘણો પાતળો છે.

📖 Theory

Classes, ટૂંકી રીતે

મથાળામાં primary constructor વાળો Kotlin class properties ને એકસાથે જ જાહેર કરે છે અને શરૂઆતની કિંમત પણ આપી દે છે:

class Event(val name: String, var seats: Int)

• val name: ફક્ત વાંચી શકાય એવી property
• var seats: બદલી શકાય એવી property

એ એક જ મથાળું Java ના fields જાહેર કરવા વત્તા constructor માં કિંમત આપવા વાળા આખા ભાગની જગ્યા લે છે. Object new વગર જ બનાવો (Kotlin માં new નામનો keyword છે જ નહીં):

val e = Event("Garba Night", 350)

Properties સુધી ટપકા વડે પહોંચો: e.name, e.seats. સાદી કિંમત આપવા ઉપરાંતની ગોઠવણ કરવી હોય તો init { } નો ખંડ object બનતી વખતે ચાલે છે. Methods એટલે class ની અંદર જાહેર કરેલા functions (fun) જ. ટૂંકું છે, પણ છે તો એ જ data અને વર્તન વાળા objects જે તમે જાણો છો.

⌨️ Practical

Method અને named parameters વાળો Event class

class Event(val name: String, var seats: Int) {
    // એક METHOD (class ની અંદરનું fun)
    fun book(): Boolean {
        return if (seats > 0) { seats--; true } else false
    }

    fun describe() = "$name: $seats seats"   // એક જ expression વાળું function
}

fun main() {
    // 'new' વગર જ બનાવો:
    val e = Event("Garba Night", 350)
    println(e.describe())        // Garba Night: 350 seats
    e.book()                     // હવે seats 349 છે
    println(e.seats)             // 349

    // NAMED PARAMETERS: નામ પ્રમાણે, ગમે તે ક્રમમાં મોકલો
    val e2 = Event(seats = 60, name = "Coding Contest")
    println(e2.describe())       // Coding Contest: 60 seats
}

📖 Theory

Named parameters

Kotlin તમને કોઈ function કે constructor ને arguments નામ પ્રમાણે, ગમે તે ક્રમમાં મોકલવા દે છે:

Event(name = "Garba", seats = 350) અથવા Event(seats = 350, name = "Garba")

બંને ચાલે છે, કારણ કે દરેક argument પર એનું નામ લખેલું છે. એથી વાચનક્ષમતા સુધરે છે, ખાસ કરીને ઘણા parameters હોય ત્યારે: createUser("Riya", 18, true, false) ને બદલે (એ booleans નો અર્થ શો?) createUser(name = "Riya", age = 18, isActive = true, isAdmin = false) બોલાવવાની જગ્યાએ જ પોતાની સમજૂતી આપી દે છે.

આ જ વિચાર તમને Dart માં (BCA405-02) મળ્યો હતો, જ્યાં named parameters એ Flutter ની રૂઢ શૈલી હતી. Kotlin માં પણ એ છે, અને એ DEFAULT parameter ની કિંમતો સાથે (હવે પછીના પાઠમાં) જોડાઈને functions ને overloading વગર જ લવચીક બનાવે છે. Named parameters થોડી લંબાણ આપીને બદલામાં ઘણી સ્પષ્ટતા લાવે છે.

🧩 Quiz

Kotlin ના class Event(val name: String, var seats: Int) માંથી object કઈ રીતે બનાવશો?

1. new Event("Garba", 350), એટલે કે Java ની જેમ new keyword વાપરીને
2. Event("Garba", 350): Kotlin માં 'new' નામનો keyword છે જ નહીં; તમે constructor ને સીધો બોલાવો છો
3. Event.create("Garba", 350)
4. Kotlin માં objects બનાવી શકાતાં જ નથી

💭 Think first

Kotlin એ કેટલી લીટીઓ બચાવી એ ગણો

Java માં name અને seats વાળા Event class માટે fields ની જાહેરાત, એક constructor, અને (ઘણી વાર) getters તથા setters જોઈએ છે. Kotlin એ જ કામ મથાળાની એક લીટીમાં કરી નાખે છે. Kotlin એ શું દૂર કર્યું, અને એનું મહત્ત્વ શા માટે છે? વિચારીને પછી tap કરો.

⚠️ Watch out

Kotlin ના classes માં થતી ભૂલો

'new' વાપરવું: Kotlin માં new છે જ નહીં; constructor ને સીધો બોલાવો (Event(...)).

મથાળામાં val કે var ભૂલી જવું: class Event(name: String) લખો તો name એ constructor નો PARAMETER બને છે, સચવાયેલી property નહીં; એને property બનાવવા val કે var ઉમેરો.

Named parameters અને defaults ને ગૂંચવવાં: named parameters (નામ પ્રમાણે) અને default કિંમતો સંબંધિત તો છે, પણ જુદાં છે (defaults હવે પછીના પાઠમાં).

fun વગરના methods: methods class ની અંદર fun વડે જ જાહેર થાય છે.

Java જેવા getters ની અપેક્ષા: Kotlin ની properties સાથે અંતર્ગત accessors આવે છે; e.getSeats() નહીં પણ e.seats વાપરો.

📖 Theory

Classes પતી ગયા; હવે inheritance, એક વળાંક સાથે

FestConnect Mobile પાસે હવે ટૂંકા Kotlin classes છે. હવે પછીનો પાઠ INHERITANCE શીખવે છે, અને એનો એ Kotlin-આગવો નિયમ પણ જે દરેક Java programmer ને ભૂલાવે છે: classes મૂળભૂત રીતે FINAL હોય છે, અને inheritance થવા દેવા માટે તમારે class ને સ્પષ્ટપણે open લખવો પડે છે (Java થી બરાબર ઊલટું). એ ઉપરાંત abstract classes, interfaces, properties ના getters તથા setters, અને visibility modifiers પણ. સલામતીને પહેલી મૂકતાં એનાં મૂળભૂત વલણો સાથે Kotlin નું OOP Android ના unit પહેલાં ભાષાને પૂરી કરે છે.

✅ Summary

Key takeaways

• Kotlin નો class પોતાની properties primary constructor ના મથાળામાં જ જાહેર કરી શકે છે: class Event(val name: String, var seats: Int).
• મથાળામાં val એટલે ફક્ત વાંચી શકાય એવી property; var એટલે બદલી શકાય એવી; આ Java ના fields વત્તા constructor વાળા boilerplate ની જગ્યા લે છે.
• Objects 'new' વગર બનાવો: val e = Event("Garba", 350); અને properties સુધી ટપકા વડે પહોંચો (e.name).
• Methods એટલે class ની અંદરના functions (fun); init { } object બનતી વખતે ગોઠવણ ચલાવે છે.
• Named parameters arguments ને નામ પ્રમાણે, ગમે તે ક્રમમાં મોકલે છે: Event(name = "Garba", seats = 350), જેથી વાચનક્ષમતા સુધરે છે.
• Kotlin ની properties સાથે અંતર્ગત getters તથા setters આવે છે; e.getSeats() નહીં પણ e.seats વાપરો.
• યાદ રાખવાની કડી: મથાળામાં properties, new નહીં, methods માટે fun, અને arguments નામ પ્રમાણે.