Kotlin Programación Orientada a Objetos

Kotlin se ha consolidado como uno de los lenguajes de programación más relevantes en el ecosistema de desarrollo actual, especialmente desde que Google lo adoptó como lenguaje oficial para el desarrollo de aplicaciones Android. Su enfoque en la programación orientada a objetos (OOP) combina la robustez de Java con una sintaxis moderna y expresiva que permite escribir código más conciso, seguro y mantenible.

Fundamentos de la programación orientada a objetos en Kotlin

La programación orientada a objetos es un paradigma que organiza el diseño de software en torno a datos y objetos, en lugar de funciones y lógica. Kotlin implementa este paradigma de forma elegante, añadiendo características modernas que facilitan el desarrollo y reducen el código repetitivo.

En Kotlin, todo el código se estructura alrededor de clases que actúan como plantillas para crear objetos. Estos objetos encapsulan datos (propiedades) y comportamientos (funciones), permitiendo modelar entidades del mundo real de manera intuitiva y organizada.

// Definición básica de una clase en Kotlin
class Usuario(val nombre: String, var edad: Int) {
    fun saludar() {
        println("Hola, mi nombre es $nombre y tengo $edad años")
    }
}

// Creación de un objeto
val usuario = Usuario("Ana", 28)
usuario.saludar() // Imprime: Hola, mi nombre es Ana y tengo 28 años

A diferencia de Java, Kotlin elimina gran parte del código boilerplate tradicional, haciendo que la definición de clases sea más concisa y expresiva.

Herencia y polimorfismo: extendiendo funcionalidades

La herencia es un mecanismo fundamental en OOP que permite a una clase heredar propiedades y métodos de otra. En Kotlin, todas las clases son finales por defecto (no pueden ser heredadas), lo que promueve un diseño más consciente y seguro.

// Clase base (abierta para herencia)
open class Empleado(val nombre: String, val salarioBase: Double) {
    open fun calcularSalario(): Double = salarioBase
}

// Clase derivada
class Desarrollador(
    nombre: String,
    salarioBase: Double,
    val bonusProyecto: Double
) : Empleado(nombre, salarioBase) {
    override fun calcularSalario(): Double = salarioBase + bonusProyecto
}

El polimorfismo permite que objetos de diferentes clases respondan de manera distinta al mismo mensaje o método, facilitando la extensibilidad y flexibilidad del código.

Interfaces y clases abstractas: definiendo contratos

Las interfaces en Kotlin definen contratos que las clases pueden implementar, estableciendo qué métodos deben proporcionar sin especificar cómo deben implementarse. A diferencia de Java, las interfaces en Kotlin pueden contener implementaciones por defecto y propiedades abstractas.

interface Pagable {
    val monto: Double
    fun procesar()
    
    // Método con implementación por defecto
    fun generarRecibo() {
        println("Recibo por $monto generado")
    }
}

class Factura(override val monto: Double) : Pagable {
    override fun procesar() {
        println("Factura por $monto procesada")
    }
}

Las clases abstractas combinan características de interfaces y clases regulares, permitiendo definir tanto comportamientos abstractos como implementaciones concretas, y manteniendo estado a través de propiedades.

Data classes: simplificando el manejo de datos

Las data classes son una característica distintiva de Kotlin que simplifica enormemente la creación de clases cuyo propósito principal es almacenar datos.

data class Producto(
    val id: Int,
    val nombre: String,
    val precio: Double,
    val categoria: String
)

Con esta simple declaración, Kotlin genera automáticamente:

• Métodos equals() y hashCode()
• Método toString() con formato legible
• Funciones componentN() para destructuring
• Método copy() para crear copias modificadas

El destructuring permite descomponer un objeto en sus componentes individuales, facilitando la extracción de múltiples propiedades en una sola operación:

val producto = Producto(1, "Laptop", 999.99, "Electrónica")
val (id, nombre, precio, _) = producto  // Ignoramos la categoría

println("Producto #$id: $nombre - $precio€")

Enumeraciones y clases selladas

Las enum class permiten modelar conjuntos cerrados de constantes con tipo seguro y, si hace falta, asociar propiedades o comportamiento a cada variante. Las sealed class (y sealed interface) restringen la jerarquía de subtipos a un único archivo o módulo: el compilador conoce todas las alternativas y puede exigir un when exhaustivo, lo que encaja bien con estados, resultados y algebraic data types.

sealed class Resultado<out T> {
    data class Exito<T>(val valor: T) : Resultado<T>()
    data class Error(val mensaje: String) : Resultado<Nothing>()
}

fun describir(r: Resultado<Int>): String = when (r) {
    is Resultado.Exito -> "Valor: ${r.valor}"
    is Resultado.Error -> r.mensaje
}