سازنده ها در برنامه نویسی کاتلین

سازنده ها در برنامه نویسی کاتلین

در این درس از مجموعه آموزش های برنامه نویسی سایت سورس باران، در مورد سازنده ها در برنامه نویسی کاتلین (kotlin-constructors) (سازنده های اولیه و ثانویه) و همچنین بلوک های مقداردهنده اولیه برای شما خواهیم گفت.

سازنده یک روش مختصر و مفید برای مقداردهی مشخصه‌های کلاس است.

سازنده یک تابع عضو خاص است که وقتی یک شی ایجاد می شود (مقدار دهیمی شود) فراخوانی می شود. با این حال، نحوه کار آنها در برنامه نویسی کاتلین کمی متفاوت است.

در برنامه نویسی کاتلین، دو سازنده وجود دارد:

• سازنده اولیه – روش مختصر و مفید برای شروع کلاس
• سازنده ثانویه – به شما امکان تعریف منطق اضافی برای مقداردهی اولیه را فراهم می کند.

سازنده اولیه در برنامه نویسی کاتلین

سازنده اولیه بخشی از هدر کلاس است. مثالی در اینجا آورده شده است:

class Person(val firstName: String, var age: Int) {
    // class body
}

بلوک کدی که توسط پرانتز احاطه شده است سازنده اولیه است:

(val firstName: String, var age: Int)

سازنده دو مشخصه را اعلان می کند: مشخصه firstName ( مشخصه فقط خواندنی که با استفاده از کلید واژه val اعلان می شود) و مشخصه age  ( مشخصه خواندن-نوشتن همانطور که با کلید واژه var اعلان می شود).

مثال: سازنده اولیه در برنامه نویسی کاتلین

fun main(args: Array<String>) {

    val person1 = Person("Joe", 25)

    println("First Name = ${person1.firstName}")
    println("Age = ${person1.age}")
}

class Person(val firstName: String, var age: Int) {

}

خروجی به شکل زیر می باشد؛

First Name = Joe
Age = 25

هنگامی که شی کلاس Person ایجاد می شود، مقدار “Joe” و ۲۵  به گونه ای ارسال می شوند که گویی Person یک تابع است.

این کار مشخصه firstName و age  را به ترتیب به “جو” و ۲۵ مقدار دهی می کند.

روش های دیگری برای استفاده از سازنده های اولیه وجود دارد.

سازندۀ اولیه و بلوک مقداردهی اولیه

سازنده اولیه یک ساختار محدود دارد و نمی تواند حاوی کدی باشد.

برای قرار دادن کد مقداردهی اولیه (و نه فقط کدی که مشخصه‌ ها را مقداردهی کند)، از بلوک مقداردهنده استفاده می شود. برای استفاده از این بلوک از کلید واژه init استفاده می شود. بیایید مثال بالا را با مقداردهی اولیه اصلاح کنیم:

fun main(args: Array<String>) {
    val person1 = Person("joe", 25)
}

class Person(fName: String, personAge: Int) {
    val firstName: String
    var age: Int

    // initializer block
    init {
        firstName = fName.capitalize()
        age = personAge

        println("First Name = $firstName")
        println("Age = $age")
    }
}

خروجی به شکل زیر می باشد؛

First Name = Joe
Age = 25

در اینجا، پارامترهای fName و personAge درون پرانتز هنگام ایجاد شی person1 به ترتیب مقادیر “Joe” و ۲۵ را می پذیرند. با این حال، fName و personAge بدون استفاده از var یا val استفاده می شوند و از مشخصه های کلاس Person نیستند.

کلاس Person  دو مشخصه firstName و age را اعلان می کند.

هنگامی که شی person1 ایجاد می شود، کد درون بلوک مقداردهنده اجرا می شود. بلوک مقداردهنده نه تنها مشخصه های خود را مقداردهی اولیه می کند بلکه آنها را پرینت می کند.

در اینجا روش دیگری برای انجام همان کار وجود دارد:

fun main(args: Array<String>) {
    val person1 = Person("joe", 25)
}

class Person(fName: String, personAge: Int) {
    val firstName = fName.capitalize()
    var age = personAge

    // initializer block
    init {
        println("First Name = $firstName")
        println("Age = $age")
    }
}

برای تشخیص پارامتر و ویژگی سازنده، از نامهای مختلفی استفاده می شود (fName و firstName، و personAge و age). معمولاً استفاده از _firstName و _age به جای نام کاملاً متفاوت برای پارامترهای سازنده معمول است. مثلا:

class Person(_firstName: String, _age: Int) {
    val firstName = _firstName.capitalize()
    var age = _age

    // initializer block
    init {
        ... .. ...
    }
}

مقدار پیش فرض در سازنده اولیه در کاتلین

می توانید مقدار پیش فرض پارامترهای سازنده را ارائه دهید (مشابه ارائه آرگومان های پیش فرض توابع). مثلا:

fun main(args: Array<String>) {

    println("person1 is instantiated")
    val person1 = Person("joe", 25)

    println("person2 is instantiated")
    val person2 = Person("Jack")

    println("person3 is instantiated")
    val person3 = Person()
}

class Person(_firstName: String = "UNKNOWN", _age: Int = 0) {
    val firstName = _firstName.capitalize()
    var age = _age

    // initializer block
    init {
        println("First Name = $firstName")
        println("Age = $age\n")
    }
}

خروجی به شکل زیر می باشد؛

First Name = Joe
Age = 25

person2 is instantiated
First Name = Jack
Age = 0

person3 is instantiated
First Name = UNKNOWN
Age = 0

سازنده ثانویه در برنامه نویسی کاتلین

در برنامه نویسی کاتلین، یک کلاس می تواند شامل یک یا چند سازنده ثانویه باشد. این سازنده ها با استفاده از کلید واژه constructor ایجاد می شوند.

سازنده های ثانویه در کاتلین معمول نیستند. متداول ترین کاربرد سازنده ثانویه زمانی به وجود می آید که شما نیاز به گسترش یک کلاس دارید که چندین سازنده را ارائه می دهد که کلاس را به روش های مختلف شروع می کنند.

در اینجا نحوه ایجاد سازنده ثانویه در برنامه نویسی کاتلین آورده شده است:

class Log {
    constructor(data: String) {
        // some code
    }
    constructor(data: String, numberOfData: Int) {
        // some code
    }
}

در اینجا، کلاس Log دارای دو سازنده ثانویه است، اما سازنده اولیه ندارد.

می توانید کلاس را به صورت زیر گسترش دهید:

class Log {
    constructor(data: String) {
        // code
    }
    constructor(data: String, numberOfData: Int) {
        // code
    }
}

class AuthLog: Log {
    constructor(data: String): super(data) {
        // code
    }
    constructor(data: String, numberOfData: Int): super(data, numberOfData) {
        // code
    }
}

در اینجا سازندگان کلاس مشتق شده AuthLog سازنده مربوط به کلاس پایه Log را فراخوانی می کنند. برای آن از super () استفاده می شود.

در کاتلین می توانید با استفاده از ()this سازنده دیگری از همان کلاس (مانند جاوا) را فراخوانی کنید.

class AuthLog: Log {
    constructor(data: String): this(data, 10) {
        // code
    }
    constructor(data: String, numberOfData: Int): super(data, numberOfData) {
        // code
    }
}

مثال: سازنده ثانویه در برنامه نویسی کاتلین

fun main(args: Array<String>) {

    val p1 = AuthLog("Bad Password")
}

open class Log {
    var data: String = ""
    var numberOfData = 0
    constructor(_data: String) {

    }
    constructor(_data: String, _numberOfData: Int) {
        data = _data
        numberOfData = _numberOfData
        println("$data: $numberOfData times")
    }
}

class AuthLog: Log {
    constructor(_data: String): this("From AuthLog -> " + _data, 10) {
    }

    constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
    }
}

خروجی به شکل زیر می باشد؛

From AuthLog -> Bad Password: 10 times

توجه: اگر کلاس سازنده ولیه ندارد، سازنده ثانویه باید کلاس پایه را مقداردهی اولیه کند یا  سازنده دیگری را نمایندگی کند (مانند مثال بالا).

منبع.

لیست جلسات قبل آموزش برنامه نویسی کاتلین

1. معرفی کاتلین،  Kotlin Hello World – اولین برنامه کاتلین
2. انواع متغیرهای پایه در کاتلین
3. عملگرهای برنامه نویسی کاتلین
4. تبدیل نوع در برنامه نویسی کاتلین
5. عبارت ها، گزاره ها و بلوک ها در برنامه نویسی کاتلین
6. کامنت ها در برنامه نویسی کاتلین
7. ورودی / خروجی پایه در برنامه نویسی کاتلین
8. عبارت if در برنامه نویسی کاتلین
9. عبارت when در برنامه نویسی کاتلین
10. حلقه های while و do … while در برنامه نویسی کاتلین
11. حلقه for در برنامه نویسی کاتلین
12. عبارت break در برنامه نویسی کاتلین
13. عبارت continue در برنامه نویسی کاتلین
14. توابع در برنامه نویسی کاتلین
15. فراخوانی تابع میانوندی در برنامه نویسی کاتلین
16. آرگومان ‌های پیش ‌فرضآرگومان ‌های پیش ‌فرض و نام ‌دار در برنامه نویسی کاتلین
17. توابع بازگشتی در برنامه نویسی کاتلین
18. کلاس و شی در برنامه نویسی کاتلین