Tabla de Contenidos

Programación Orientada a Objetos en Kotlin

Programación Orientada a Objetos en Kotlin

Clases

La Programación Orientada a Objetos (POO) es un paradigma de programación basado en la utilización de objetos.

Un objeto agrupa principalmente:

Datos, representados mediante propiedades.
Comportamiento, representado mediante funciones.

Por ejemplo, si queremos representar un coche podríamos tener:

Coche

Propiedades:
marca
modelo
velocidad

Funciones:
acelerar()
frenar()
mostrarInformacion()

Para definir este tipo de objetos utilizaremos clases.

Clases y objetos

Una clase es una plantilla que define las características y el comportamiento que tendrán los objetos creados a partir de ella.

Por ejemplo:

class Coche {
    var marca = ""
    var modelo = ""
    var velocidad = 0
}

Esta clase define cómo serán los objetos de tipo `Coche`.

Sin embargo, declarar una clase no crea ningún coche.

Para trabajar con ella debemos crear objetos o instancias de la clase.

Clase frente a objeto

Podemos entender una clase como un plano o plantilla y un objeto como una realización concreta de ese plano.

Una misma clase puede utilizarse para crear muchos objetos diferentes.

Declaración de una clase

Para declarar una clase utilizamos la palabra reservada `class` seguida del nombre de la clase:

class Persona {
 
}

Por convenio, los nombres de las clases comienzan con mayúscula:

class Persona
class Alumno
class Producto
class CuentaBancaria

Una clase puede estar formada por dos partes:

Cabecera de la clase.
Cuerpo de la clase.

Por ejemplo:

class Persona(val nombre: String) {
 
```
var edad = 0
 
fun saludar() {
    println("Hola, soy $nombre")
}
```
 
}

La cabecera es:

class Persona(val nombre: String)

El cuerpo es todo lo que aparece entre `{ }`:

{
    var edad = 0
 
```
fun saludar() {
    println("Hola, soy $nombre")
}
```
 
}

El cuerpo puede contener, entre otros elementos:

Propiedades.
Funciones.
Bloques de inicialización.
Constructores secundarios.
Otras clases u objetos.

Si una clase no necesita cuerpo podemos omitir las llaves:

class Persona(val nombre: String, var edad: Int)

Crear objetos

Para crear un objeto escribimos el nombre de la clase seguido de paréntesis:

val persona = Persona("Ana", 20)

A esta operación la denominamos instanciar una clase.

`persona` es ahora un objeto o instancia de `Persona`.

A diferencia de otros lenguajes orientados a objetos como Java, en Kotlin no se utiliza la palabra `new` para crear objetos.

Por ejemplo:

// Kotlin
val persona = Persona("Ana", 20)

No escribimos:

// Incorrecto en Kotlin
// val persona = new Persona("Ana", 20)

Podemos crear múltiples objetos de una misma clase:

val persona1 = Persona("Ana", 20)
val persona2 = Persona("Carlos", 25)
val persona3 = Persona("Marta", 19)

Todos son objetos diferentes, aunque hayan sido creados utilizando la misma clase.

Propiedades

Las variables que forman parte de una clase reciben normalmente el nombre de propiedades.

Por ejemplo:

class Coche {
    var marca = ""
    var modelo = ""
    var velocidad = 0
}

La clase `Coche` tiene tres propiedades:

marca
modelo
velocidad

Podemos acceder a ellas utilizando el operador `.`:

val coche = Coche()
 
coche.marca = "Toyota"
coche.modelo = "Corolla"
coche.velocidad = 50
 
println(coche.marca)
println(coche.modelo)
println(coche.velocidad)

Propiedades val y var

Al igual que las variables normales, las propiedades pueden declararse utilizando `val` o `var`.

Por ejemplo:

class Persona(
    val nombre: String,
    var edad: Int
)

En este caso:

`nombre` es una propiedad que no puede reasignarse.
`edad` es una propiedad que puede modificarse.

val persona = Persona("Ana", 20)
 
persona.edad = 21

Esto es correcto.

Sin embargo:

// ERROR
// persona.nombre = "Marta"

no está permitido porque `nombre` fue declarado mediante `val`.

Al igual que con las variables normales, es recomendable utilizar `val` cuando una propiedad no necesite ser reasignada.

Funciones de una clase

Las clases también pueden contener funciones.

Estas funciones representan el comportamiento de los objetos.

Por ejemplo:

class Coche(
    val marca: String,
    val modelo: String,
    var velocidad: Int
) {
 
```
fun acelerar() {
    velocidad += 10
}
 
fun frenar() {
    velocidad -= 10
}
 
fun mostrarInformacion() {
    println("$marca $modelo - $velocidad km/h")
}
```
 
}

Podemos utilizar estas funciones mediante el operador `.`:

fun main() {
 
```
val coche = Coche(
    "Toyota",
    "Corolla",
    0
)
 
coche.acelerar()
coche.acelerar()
 
coche.mostrarInformacion()
```
 
}

Resultado:

Toyota Corolla - 20 km/h

Las funciones pueden acceder directamente a las propiedades de su objeto:

fun acelerar() {
    velocidad += 10
}

No necesitamos pasar `velocidad` como parámetro porque pertenece al propio objeto.

Constructor primario

Cuando creamos un objeto normalmente queremos proporcionar sus datos iniciales.

Para ello utilizamos un constructor.

La forma más habitual en Kotlin es utilizar un constructor primario, que se declara directamente en la cabecera de la clase:

class Persona(val nombre: String, var edad: Int) {
 
}

Ahora debemos proporcionar esos valores al crear el objeto:

val persona = Persona("Ana", 20)

Podemos acceder posteriormente a ellos:

println(persona.nombre)
println(persona.edad)

Resultado:

Ana
20

La sintaxis completa del constructor podría escribirse utilizando la palabra `constructor`:

class Persona constructor(val nombre: String, var edad: Int) {
 
}

Sin embargo, normalmente podemos omitirla:

class Persona(val nombre: String, var edad: Int) {
 
}

Esta es la forma que utilizaremos habitualmente.

Parámetros y propiedades del constructor

Existe una diferencia importante entre escribir:

class Persona(nombre: String)

class Persona(val nombre: String)

En el segundo caso `nombre` se convierte en una propiedad del objeto.

Por ello podemos hacer:

val persona = Persona("Ana")
 
println(persona.nombre)

Sin `val` o `var`, el parámetro del constructor no se convierte automáticamente en una propiedad accesible del objeto.

Por tanto:

class Persona(
    val nombre: String,
    var edad: Int
)

es una forma muy habitual de declarar simultáneamente:

Los parámetros necesarios para crear el objeto.
Las propiedades que almacenará.

Valores por defecto

Los parámetros del constructor pueden tener valores por defecto:

class Persona(
    val nombre: String = "Desconocido",
    var edad: Int = 0
)

Ahora podemos crear objetos de diferentes maneras:

val persona1 = Persona()
 
val persona2 = Persona("Ana")
 
val persona3 = Persona("Carlos", 25)

Los valores serán:

persona1 -> nombre = "Desconocido", edad = 0

persona2 -> nombre = "Ana", edad = 0

persona3 -> nombre = "Carlos", edad = 25

También podemos utilizar argumentos con nombre:

val persona = Persona(
    edad = 25,
    nombre = "Carlos"
)

Propiedades adicionales

No todas las propiedades tienen que declararse en el constructor.

Podemos declarar otras propiedades dentro del cuerpo de la clase:

class Persona(
    val nombre: String,
    val anioNacimiento: Int
) {
 
```
val mayoriaEdad = 18
 
var activo = true
```
 
}

También podemos calcular una propiedad utilizando los datos recibidos por el constructor:

class Rectangulo(
    val base: Double,
    val altura: Double
) {
 
```
val area = base * altura
```
 
}

Uso:

val rectangulo = Rectangulo(10.0, 5.0)
 
println(rectangulo.area)

Resultado:

50.0

Bloque init

En ocasiones necesitamos ejecutar instrucciones cuando se crea un objeto.

Para ello podemos utilizar un bloque `init`.

class Persona(
    val nombre: String,
    var edad: Int
) {
 
```
init {
    println("Creando una nueva persona")
}
```
 
}

Cuando hacemos:

val persona = Persona("Ana", 20)

se ejecutará automáticamente el bloque `init`.

Podemos acceder desde él a los parámetros y propiedades:

class Persona(
    val nombre: String,
    var edad: Int
) {
 
```
init {
    println("Creando a $nombre")
    println("Edad inicial: $edad")
}
```
 
}

Validación durante la inicialización

Uno de los usos del bloque `init` es comprobar que los datos utilizados para crear un objeto sean correctos.

Por ejemplo:

class Persona(
    val nombre: String,
    var edad: Int
) {
 
```
init {
    require(edad >= 0) {
        "La edad no puede ser negativa"
    }
}
```
 
}

Esto sería válido:

val persona = Persona("Ana", 20)

Pero:

val persona = Persona("Ana", -5)

provocaría un error porque no se cumple la condición establecida mediante `require()`.

Otro ejemplo:

class Producto(
    val nombre: String,
    val precio: Double
) {
 
```
init {
    require(nombre.isNotBlank()) {
        "El nombre no puede estar vacío"
    }
 
    require(precio >= 0) {
        "El precio no puede ser negativo"
    }
}
```
 
}

`require()` permite indicar una condición que debe cumplirse.

Si la condición es falsa, Kotlin lanza una excepción indicando que el argumento proporcionado no es válido.

No es necesario profundizar todavía en las excepciones para poder utilizar esta validación básica.

Constructores secundarios

Una clase puede tener además constructores secundarios.

Se declaran mediante `constructor` dentro del cuerpo de la clase.

Por ejemplo:

class Persona(
    val nombre: String,
    var edad: Int
) {
 
```
constructor(nombre: String) : this(nombre, 0)
```
 
}

Ahora podemos crear:

val persona1 = Persona("Ana", 20)
 
val persona2 = Persona("Carlos")

En el segundo caso se utiliza el constructor secundario:

constructor(nombre: String) : this(nombre, 0)

que llama al constructor primario proporcionando:

nombre -> valor recibido
edad   -> 0

Si existe un constructor primario, los constructores secundarios deben terminar delegando en él mediante `this(…)`.

No obstante, Kotlin permite solucionar muchas situaciones mediante valores por defecto, por lo que no necesitaremos constructores secundarios con tanta frecuencia como en otros lenguajes.

Por ejemplo, en el caso anterior probablemente sea más sencillo escribir:

class Persona(
    val nombre: String,
    var edad: Int = 0
)

Ejemplo completo: clase Producto

Vamos a representar un producto de una tienda.

Cada producto tendrá:

Nombre.
Precio.
Stock.

Además podrá:

Mostrar su información.
Vender unidades.
Reponer unidades.
Calcular el valor total del stock.

class Producto(
    val nombre: String,
    val precio: Double,
    var stock: Int = 0
) {
 
```
init {
    require(nombre.isNotBlank()) {
        "El nombre no puede estar vacío"
    }
 
    require(precio >= 0) {
        "El precio no puede ser negativo"
    }
 
    require(stock >= 0) {
        "El stock no puede ser negativo"
    }
}
 
fun vender(cantidad: Int) {
 
    if (cantidad <= 0) {
        println("La cantidad debe ser positiva")
    } else if (cantidad > stock) {
        println("No existe stock suficiente")
    } else {
        stock -= cantidad
        println("Venta realizada")
    }
}
 
fun reponer(cantidad: Int) {
 
    if (cantidad > 0) {
        stock += cantidad
    }
}
 
fun calcularValorStock(): Double {
    return precio * stock
}
 
fun mostrarInformacion() {
    println("Producto: $nombre")
    println("Precio: $precio €")
    println("Stock: $stock")
    println("Valor del stock: ${calcularValorStock()} €")
}
```
 
}

Podemos utilizarla:

fun main() {
 
```
val teclado = Producto(
    nombre = "Teclado mecánico",
    precio = 59.95,
    stock = 10
)
 
teclado.mostrarInformacion()
 
teclado.vender(3)
 
teclado.reponer(5)
 
teclado.mostrarInformacion()
```
 
}

En este ejemplo podemos identificar claramente los dos elementos principales de un objeto.

Estado del objeto:

nombre
precio
stock

Comportamiento del objeto:

vender()
reponer()
calcularValorStock()
mostrarInformacion()

Referencias entre objetos

Una variable que contiene un objeto contiene una referencia a ese objeto.

Por ejemplo:

val producto1 = Producto(
    "Teclado",
    50.0,
    10
)
 
val producto2 = producto1

En este caso no hemos creado dos productos independientes.

`producto1` y `producto2` hacen referencia al mismo objeto.

Por tanto:

producto2.stock = 5
 
println(producto1.stock)

mostrará:

Esto es diferente de lo que ocurre con tipos sencillos como `Int`:

var numero1 = 10
var numero2 = numero1
 
numero2 = 20
 
println(numero1)

El resultado continúa siendo:

Comprender que los objetos se manejan mediante referencias será importante posteriormente cuando trabajemos con objetos, colecciones y aplicaciones Android.

Ejercicio — Gestión de vehículos

Crea una clase denominada:

Vehiculo

Cada vehículo debe almacenar:

Matrícula.
Marca.
Modelo.
Kilómetros.
Nivel de combustible.
Capacidad máxima del depósito.

Por ejemplo:

val coche = Vehiculo(
    matricula = "1234 ABC",
    marca = "Toyota",
    modelo = "Corolla",
    kilometros = 50000,
    combustible = 30.0,
    capacidadDeposito = 50.0
)

La clase debe proporcionar las siguientes funciones:

mostrarInformacion()
 
repostar(litros)
 
realizarViaje(kilometros, consumo)

La función `repostar()` debe comprobar:

Que la cantidad sea positiva.
Que el depósito no supere su capacidad máxima.

Por ejemplo, si quedan 40 litros en un depósito de 50 y hacemos:

coche.repostar(20.0)

el depósito deberá quedar en:

50 litros

La función:

realizarViaje(kilometros, consumo)

recibirá:

Distancia que se quiere recorrer.
Consumo del vehículo en litros cada 100 km.

Por ejemplo:

coche.realizarViaje(
    kilometros = 200,
    consumo = 6.5
)

El programa deberá calcular el combustible necesario:

combustibleNecesario = kilometros * consumo / 100

Si existe combustible suficiente:

Restar el combustible consumido.
Aumentar el kilometraje del vehículo.
Mostrar un mensaje indicando que el viaje se ha realizado.

Si no existe combustible suficiente:

No modificar el kilometraje.
No modificar el combustible.
Mostrar un mensaje indicando que no existe combustible suficiente.

Además, utiliza un bloque `init` para comprobar que:

Los kilómetros iniciales no sean negativos.
El combustible no sea negativo.
La capacidad del depósito sea mayor que cero.

Finalmente, crea al menos tres vehículos diferentes y realiza distintas operaciones sobre ellos.

Ejercicio de ampliación

Crea una clase `Alumno` que almacene:

nombre
apellidos
edad
notas

Las notas pueden almacenarse en:

val notas = mutableListOf<Double>()

La clase deberá proporcionar las funciones:

agregarNota(nota)
 
calcularMedia()
 
estaAprobado()
 
mostrarInformacion()

`agregarNota()` solamente deberá aceptar valores entre `0` y `10`.

`calcularMedia()` devolverá la media de las notas del alumno.

`estaAprobado()` devolverá un `Boolean` indicando si la media es igual o superior a `5`.

`mostrarInformacion()` deberá producir una salida similar a:

Alumno: Ana García
Edad: 20
Notas: 7.5, 8.0, 6.5, 9.0
Media: 7.75
Resultado: APROBADO

Crea posteriormente varios objetos `Alumno`, añade diferentes notas y muestra sus resultados.