类和对象Kotlin

Dans cet article, je vous présenterai la programmation orientée objet dans Kotlin. Vous apprendrez ce qu'est une classe, comment créer un objet et comment l'utiliser dans un programme.

Kotlin prend en charge la programmation fonctionnelle et orientée objet.

Kotlin prend en charge tels queFonctions de haut niveau,Type de fonction et LambdaClasseFonctionCe qui en fait une sélection idéale pour une utilisation de style de programmation fonctionnelle. Vous découvrirez ces concepts dans les chapitres suivants. Cet article se concentrera sur le style de programmation orientée objet dans Kotlin.

Programmation orientée objet (OOP)

Dans le style de programmation orienté objet, les problèmes complexes peuvent être divisés en ensembles plus petits en créant des objets.

Ces objets ont deux caractéristiques :

• États
  

• Comportement

Laissez-nous donner quelques exemples :

1. Lamp（lampe） est un objet

• Il peut être dans un état on（allumé） ou off（éteint).

• Vous pouvez turn on（allumer） et turn off （éteindre）（comportements).

2. Bicycle est un objet

• Il a des états tels que les vitesses, deux roues, le nombre de gears.

• Il a des comportements tels que freinage, accélération, changement de vitesse.

Vous continuerez à apprendre des fonctionnalités détaillées de la programmation orientée objet, telles que :encapsulation des données,héritage et Polymorphisme. Cet article se concentrera sur les connaissances de base qui rendent les choses simples.

Classe Kotlin

Avant de créer un objet en Kotlin, vous devez définir une classe.

Une classe est un plan de l'objet.

Nous pouvons considérer une classe comme un esquisse (prototype) de maison. Elle contient toutes les détails concernant le sol, les portes, les fenêtres, etc. Sur la base de ces descriptions, nous construisons des maisons. Les maisons sont des objets.

Comme de nombreux maisons peuvent être construites avec la même description, nous pouvons créer de nombreux objets à partir d'une classe.

Comment définir une classe en Kotlin ?

Pour définir une classe en Kotlin, vous pouvez utiliser la keyword class :

class　ClassName　{
　　　　//　Attribut
　　　　//　函数成员
　　　　...　..　...
}

Voici un exemple :

class Lamp {
　　　　//属性（数据成员）
　　　　private var isOn: Boolean = false
　　　　//　函数成员
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　函数成员
　　　　fun turnOff() {
　　　　　　　　isOn = false
　　　　}
}

Ici, nous définissons une classe nommée Lamp.

Cette classe a un attribut isOn (défini de la même manière qu'un variable) et deux fonctions membres turnOn() et turnOff().

Dans Kotlin, il est soit nécessaire d'initialiser les attributs, soit de les déclarer comme abstract. Dans l'exemple ci-dessus, l'attribut isOn est initialisé à false.

Les classes, les objets, les attributs, les fonctions membres, etc. peuvent avoir des modificateurs de visibilité. Par exemple, l'attribut isOn est privé. Cela signifie que l'attribut isOn ne peut être modifié que dans la classe Lamp.

D'autres modificateurs de visibilité sont :

• private - Visible uniquement à l'intérieur de la classe (accessible).

• public - Visible partout.

• protected - Visible pour la classe et ses sous-classes.

• internal - Tous les clients dans le module peuvent y accéder.

Vous en apprendrez davantage plus tard surModificateurs de visibilité KotlinDans cet article, vous découvrirez les modificateurs protected et internal.

Si le modificateur de visibilité n'est pas spécifié, la valeur par défaut est public.

Dans le programme ci-dessus, les fonctions membres turnOn() et turnOff() sont publiques, tandis que l'attribut isOn est privé.

Objet Kotlin

Lors de la définition d'une classe, ne définissez que les spécifications de l'objet ; ne分配内存或存储空间。

要访问在类中定义的成员，您需要创建对象。让我们创建 Lamp 类的对象。

class Lamp {
　　　　//　属性（数据成员）
　　　　private var isOn: Boolean = false
　　　　//　函数成员
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　函数成员
　　　　fun turnOff() {
　　　　　　　　isOn = false
　　　　}
}
fun main(args: Array<String>) {
　　　　val l1　= Lamp()　//　创建 Lamp 类的 l1对象
　　　　val l2　= Lamp()　//　创建 Lamp 类的 l2对象
}

此程序创建两个对象 l1和 l2类 Lamp。该 isOn 两个灯泡性能 l1和 l2会 false。

如何访问成员？

您可以使用 . 符号来访问类的属性和成员函数。例如，

l1.turnOn()

该语句调用对象 l1 的 turnOn() 函数。

让我们再举一个实例：

l2.isOn = true

在这里，我们尝试分配 true 给对象 l2 的 isOn 属性。请注意，isOn property 是 private，如果您尝试从类外部访问 isOn ，则会引发异常。

示例：Kotlin 类和对象

class Lamp {
　　　　//　属性（数据成员）
　　　　private var isOn: Boolean = false
　　　　//　函数成员
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　函数成员
　　　　fun turnOff() {
　　　　　　　　isOn = false
　　　　}
　　　　fun displayLightStatus(lamp: String) {
　　　　　　　　if (isOn == true)
　　　　　　　　　　　　println("$lamp 灯是亮着的。")
　　　　　　　　else
　　　　　　　　　　　　println("$lamp 灯是熄灭的。")
　　　　}
}
fun main(args: Array<String>) {
　　　　val l1　= Lamp()　//　创建 Lamp 类的 l1对象
　　　　val l2　= Lamp()　//　创建 Lamp 类的 l2对象
　　　　l1.turnOn()
　　　　l2.turnOff()
　　　　l1.displayLightStatus("l1）
　　　　l2.displayLightStatus("l2）
}

运行该程序时，输出为：

l1　灯是亮着的。
l2　灯是熄灭的。

在上面的程序中，

• Lamp 类已创建。

• 该类具有一个属性 isOn 和三个成员函数 turnOn()，turnOff() 以及 displayLightStatus()。

• 在 main() 函数中创建了 Lamp 类的两个对象 L1和 L2。

• 在这里，使用 l1对象 l1.turnOn() 调用 turnOn() 函数。 此方法将 l1对象的 isOn 实例变量设置为 true。
  

• 同时，使用 l2 对象：l2.turnOff() 调用 turnOff() 函数。 此方法将 l2对象的 isOff 实例变量设置为 false。
  

• 然后，对 l1和 l2对象调用 displayLightStatus() 函数，该函数根据 isOn 属性是 true 还是 false 来打印适当的消息。

注意，在类内部，isOn 属性被初始化为 false。 创建该类的对象时，该对象的 isOn 属性将自动初始化为 false。 因此，不需要 l2 对象调用 turnOff() 将 isOn 属性设置为 false。

例如：

class Lamp {
　　　　//　属性（数据成员）
　　　　private var isOn: Boolean = false
　　　　//　函数成员
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　函数成员
　　　　fun turnOff() {
　　　　　　　　isOn = false
　　　　}
　　　　fun displayLightStatus() {
　　　　　　　　if (isOn == true)
　　　　　　　　　　　　println("灯亮着。")
　　　　　　　　else
　　　　　　　　　　　　println("灯熄灭了。")
　　　　}
}
fun main(args: Array<String>) {
　　　　val lamp = Lamp()
　　　　lamp.displayLightStatus()
}

运行该程序时，输出为：

灯熄灭了。

本文仅是Kotlin中面向对象编程的基础知识。