Kotlin 构造函数（Constructor）

在本文中，您将在示例的帮助下了解Kotlin中的构造函数（主要构造函数和次构造函数）以及初始化程序块。

构造函数是初始化类属性的简洁方法。

它是一个特殊的成员函数，在实例化（创建）对象时调用。但是，它们在Kotlin中的工作方式略有不同。

在Kotlin中，有两个构造函数：

• 主构造函数 - 初始化类的简洁方法

• 次构造函数 - 允许您放置其他初始化逻辑

主构造函数

主构造函数是类标头的一部分。这是一个实例：

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) {
}

عند تشغيل هذا البرنامج، الناتج سيكون:

الاسم الأول = Joe
العمر = 25

当创建 Person 类的对象时，将传递值 Joe 和 25，就好像Person是一个函数一样。

这将 person1 对象的 firstName 和 age 属性分别初始化为 "Joe" 和 25。

还有其他使用主要构造函数的方法。

主构造函数和初始化语句块

主构造函数的语法受约束，不能包含任何代码。

为了放置初始化代码（不仅是初始化属性的代码），使用了初始化程序块。它以 init 关键字为前缀 。让我们用初始化语句块修改以上示例：

fun main(args: Array<String>) {
　　　　val person1 = Person("joe", 25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName: String
　　　　var age: Int
　　　　//كتلة الت�始化
　　　　init {
　　　　　　　　firstName = fName.capitalize()
　　　　　　　　age = personAge
　　　　　　　　println("الاسم الأول = $firstName")
　　　　　　　　println("العمر = $age")
　　　　}
}

عند تشغيل هذا البرنامج، الناتج سيكون:

الاسم الأول = Joe
العمر = 25

في هذا السياق، عند إنشاء كائن person1، يتم تقديم القيم "Joe" و25 للمعلمتين fName وpersonAge في البارانتيز. ولكن عند استخدام fName وpersonAge، لا يتم استخدام var أو val، وهم ليسوا خصائصًا للفئة Person.

استخدمت فئة Person خصائصين firstName وage.

عند إنشاء كائن person1، يتم تنفيذ كود كتلة الت-initialization. كتلة الت-initialization لا تُستخدم فقط لتحديد الخصائص بل أيضًا للإطلاع على الخصائص.

هذه هي طريقة أخرى للقيام بالمهمة نفسها:

fun main(args: Array<String>) {
　　　　val person1 = Person("joe", 25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName = fName.capitalize()
　　　　var age = personAge
　　　　//كتلة الت�始化
　　　　init {
　　　　　　　　println("الاسم الأول = $firstName")
　　　　　　　　println("العمر = $age")
　　　　}
}

لتمييز بين معلمات البنية والخصائص، تم استخدام أسماء مختلفة (fName وFirstName، وPersonage وage). بالنسبة لمعلمات البنية، يتم استخدام _firstName و_age بشكل شائع أكثر من استخدام أسماء مختلفة. على سبيل المثال:

class Person(_firstName: String, _age: Int) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　//كتلة الت-initialization
　　　　init {
　　　　　　　　... .. ...
　　　　}
}

القيم الافتراضية في البنية الرئيسية

يمكنك تقديم القيم الافتراضية للمعلمات في بناء الجسم (مثل تقديمالقيم الافتراضيةمثالًا:

fun main(args: Array<String>) {
　　　　println("person1 تم استنساخها")
　　　　val person1 = Person("joe", 25)
　　　　println("person2 تم استنساخها")
　　　　val person2 = Person("Jack")
　　　　println("person3 تم استنساخها")
　　　　val person3 = Person()
}
class Person(_firstName: String = "UNKNOWN", _age: Int = 0) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　//كتلة الت�始化
　　　　init {
　　　　　　　　println("الاسم الأول = $firstName")
　　　　　　　　println("العمر = $age\n")
　　　　}
}

عند تشغيل هذا البرنامج، الناتج سيكون:

الاسم الأول = Joe
العمر = 25
person2 تم استنساخها
First Name = Jack
Age = 0
person3 تم استخدامه
First Name = UNKNOWN
Age = 0

بناء النص النهائي ثانوي في Kotlin

يمكن للفئة في Kotlin أيضًا أن تحتوي على بناء النص النهائي ثانوي واحد أو أكثر. إنها تُ创建 باستخدام كلمة المفتاح constructor.

بناء النص النهائي ثانوي في Kotlin غير شائع. يظهر الاستخدام الأكثر شيوعًا لبناء النص النهائي ثانوي عند الحاجة إلى توسيع فئة تحتوي على عدة بناء النص النهائي بطرق مختلفة لتعريف كيفية تعريف الفئة. قبل التعلم، تأكد من أنك قد فهمتالتنسيق في Kotlin.

يمكنك إنشاء بناء النص النهائي ثانوي في Kotlin كما يلي:

class Log {
　　　　constructor(data: String) {
　　　　　　　　// بعض الكود
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　// بعض الكود
　　　　}
}

في هذا السياق، الفئة Log تحتوي على بناء النص النهائي ثانويين وليس لديها بناء النص النهائي الرئيسي.

يمكنك توسيع الفئة كالتالي:

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

في هذا السياق، يتم دعوة بناء النص النهائي في الفئة المشتقة AuthLog لبناء النص النهائي في الفئة الأصلية Log. لهذا، يتم استخدام super().

في Kotlin، يمكنك أيضًا استخدام this() للإشارة إلى دعوة بناء النص النهائي من بناء النص النهائي آخر في نفس الفئة (مثل Java).

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

مثال: بناء النص النهائي في Kotlin

fun main(args: Array<String>) {
　　　　val p1 = AuthLog("كلمة المرور سيئة")
}
open class Log {
　　　　var data: String = ""
　　　　var numberOfData = 0
　　　　constructor(_data: String) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int) {
　　　　　　　　data = _data
　　　　　　　　numberOfData = _numberOfData
　　　　　　　　println("$data: $numberOfData مرات")
　　　　}
}
class AuthLog: Log {
　　　　مكون بناء(_data: String): this("From AuthLog -> " + _data, 10) {
　　　　}
　　　　مكون بناء(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
　　　　}
}

عند تشغيل هذا البرنامج، الناتج سيكون:

من AuthLog -> كلمة مرور سيئة: 10 مرات

ملاحظة:إذا لم يكن هناك مكون بناء رئيسي للصفحة، فإن مكون البناء الثانوي يجب أن يبدأ في تحويل الصفحة الأساسية أو الوكيل إلى مكون آخر بناء (مثل المثال أعلاه).