Clases y objetos en Kotlin

En este artículo, le presentaremos la programación orientada a objetos en Kotlin. Aprenderás qué es una clase, cómo crear un objeto y cómo usarlo en tu programa.

Kotlin admite programación funcional y orientada a objetos.

Kotlin admite funciones comofunciones de orden superior,tipo de función y lambdade claseFunciónlo que lo hace una opción ideal para el estilo de programación funcional. Conocerás estos conceptos en los capítulos posteriores. Este artículo se centrará en el estilo de programación orientada a objetos en Kotlin.

Programación orientada a objetos (OOP)

En el estilo de programación orientada a objetos, se pueden dividir problemas complejos en conjuntos más pequeños mediante la creación de objetos.

Estos objetos tienen dos características:

• Estado
  

• Comportamiento

Vamos a dar algunos ejemplos:

1. Lamp (lámpara) es un objeto

• Puede estar en estado on (encendido) o off (apagado).

• Puedes turn on (encender) y turn off (apagar) (comportamientos).

2. Bicycle es un objeto

• Tiene estados como marchas, dos ruedas, número de engranajes.

• Tiene comportamientos como frenar, acelerar, cambiar de marcha.

Usted continuará aprendiendo características detalladas de la programación orientada a objetos, como:Encapsulamiento de datos,Herencia y Polimorfismo. Este artículo se centrará en la base que hace que las cosas sean más fáciles.

Clase Kotlin

Antes de crear un objeto en Kotlin, necesita definir una clase.

La clase es el plano del objeto.

Podemos ver a la clase como un plano de casa (prototipo). Contiene toda la información sobre el suelo, puertas, ventanas, etc. Basado en estas descripciones, construimos casas. La casa es un objeto.

Dado que se pueden construir muchas casas con la misma descripción, podemos crear muchos objetos basados en una clase.

¿Cómo se define una clase en Kotlin?

Para definir una clase en Kotlin, se puede usar la palabra clave class:

class　ClassName　{
　　　　//　Propiedad
　　　　//　Métodos miembros
　　　　...　..　...
}

Este es un ejemplo:

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

Aquí, definimos una clase llamada Lamp.

La clase tiene una propiedad isOn (definida de la misma manera que una variable) y dos funciones miembro turnOn() y turnOff().

En Kotlin, debe inicializar la propiedad o declararla como abstracta. En el ejemplo anterior, la propiedad isOn se inicializa como false.

Las clases, objetos, propiedades, funciones miembro, etc. pueden tener modificadores de visibilidad. Por ejemplo, la propiedad isOn es privada. Esto significa que solo se puede cambiar la propiedad isOn dentro de la clase Lamp.

Otras modificadores de visibilidad son:

• private - Visible solo dentro de la clase (accesible).

• public - Visible en todas partes.

• protected - Visible para la clase y sus subclases.

• internal - Cualquier cliente dentro del módulo puede acceder a ellos.

Usted lo verá más tarde enModificadores de visibilidad de KotlinEn el artículo se explica el modificador de protección y internal.

Si no se especifica el modificador de visibilidad, el valor predeterminado es public.

En el programa anterior, las funciones miembro turnOn() y turnOff() son públicas, mientras que la propiedad isOn es privada.

Objeto Kotlin

Al definir una clase, solo se define la especificación del objeto; no se asigna memoria ni espacio de almacenamiento.

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

class Lamp {
　　　　//　属性（数据成员）
　　　　private var isOn: Boolean = false
　　　　//　Métodos miembros
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　Métodos miembros
　　　　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
　　　　//　Métodos miembros
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　Métodos miembros
　　　　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)
}

La salida del programa cuando se ejecuta es:

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
　　　　//　Métodos miembros
　　　　fun turnOn() {
　　　　　　　　isOn = true
　　　　}
　　　　//　Métodos miembros
　　　　fun turnOff() {
　　　　　　　　isOn = false
　　　　}
　　　　fun displayLightStatus() {
　　　　　　　　if (isOn == true)
　　　　　　　　　　　　println("La luz está encendida.")
　　　　　　　　else
　　　　　　　　　　　　println("La luz se apagó.")
　　　　}
}
fun main(args: Array<String>) {
　　　　val lamp = Lamp()
　　　　lamp.displayLightStatus()
}

La salida del programa cuando se ejecuta es:

La luz se apagó.

Este artículo solo cubre los fundamentos de la programación orientada a objetos en Kotlin.