Este artículo explora cómo escirbir código Kotlin de manera eficiente y clara, contrastando con enfoques comunes en Java. Se presentan ejemplos que ilustran las ventajas de Kotlin en aspectos como seguridad nula, funciones de extensión y estructuras concisas.

1 Prefiera expresiones sobre bloques de funciones

En Java, a menudo se usan declarcaiones if-else para retornar valores. Kotlin ofrece alternativas más concisas mediante expresiones y la sentencia when.

Ejemplo en Java:

public static String clasificarEdad(int edad) {
    if (edad >= 0 && edad < 18) return "menor";
    else if (edad < 45) return "adulto_joven";
    else if (edad < 60) return "adulto";
    else return "senior";
}

En Kotlin, se puede mejorar usando una expresión con when:

fun clasificarEdad(edad: Int): String = when {
    edad in 0 until 18 -> "menor"
    edad < 45 -> "adulto_joven"
    edad < 60 -> "adulto"
    else -> "senior"
}

2 Use funciones de extensión para utilidades

Las clases de utilidad estáticas en Java pueden transformarse en funciones de extensión en Kotlin, mejorando la legibilidad.

Ejemplo Java:

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class FormateadorFechas {
    public static String formatearFecha(LocalDateTime fecha) {
        return fecha.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"));
    }
}

En Kotlin, se recomienda:

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

fun LocalDateTime.formatear(): String = this.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"))

fun main() {
    val ahora = LocalDateTime.now()
    println(ahora.formatear())
}

3 Utilice parámetros nombrados en lugar de setters

Kotlin simplifica la configuración de objetos con parámetros nombrados y valores predeterminados, evitando múltiples llamadas a setters.

Java:

class ConfiguracionServidor {
    private String direccionIp;
    private int puerto;
    private String protocolo = "TCP";

    // setters omitidos por brevedad
}

ConfiguracionServidor config = new ConfiguracionServidor();
config.setDireccionIp("192.168.1.1");
config.setPuerto(8080);

Kotlin:

data class ConfiguracionServidor(
    val direccionIp: String,
    val puerto: Int,
    val protocolo: String = "TCP"
)

val config = ConfiguracionServidor(
    direccionIp = "192.168.1.1",
    puerto = 8080
)

4 Aplique el bloque apply para inicialización de objetos

El bloque apply en Kotlin permite agrupar múltiples operaciones en un objeto sin repetir su nombre.

Java:

ArchivoTexto archivo = new ArchivoTexto("datos.txt");
archivo.setSoloLectura(true);
archivo.setPermisos(644);
archivo.setEncoding("UTF-8");

Kotlin con apply:

val archivo = ArchivoTexto("datos.txt").apply {
    soloLectura = true
    permisos = 644
    encoding = "UTF-8"
}

5 Evite la sobrecarga de métodos para valores predeterminados

Kotlin soporta valores predeterminados en funciones, eliminando la necesidad de sobrecargar métodos como en Java.

Java:

public void enviarMensaje(String texto, String destinatario) { ... }

public void enviarMensaje(String texto) {
    enviarMensaje(texto, "sistema");
}

Kotlin:

fun enviarMensaje(texto: String, destinatario: String = "sistema") {
    // implementación
}

// Uso
enviarMensaje("Hola")
enviarMensaje("Alerta", "admin")

6 Aproveche la seguridad nula de Kotlin

Kotlin maneja nulos de forma segura con operadores ? y ?:, evitando verificaciones manuales.

Java:

if (pedido != null && pedido.getCliente() != null) {
    String nombre = pedido.getCliente().getNombre();
}

Kotlin:

val nombre = pedido?.cliente?.nombre ?: "desconocido"

7 Use let para operaciones condicionales

El bloque let facilita la ejecución de código solo si una variable no es nula.

Java:

Usuario usuario = obtenerUsuario(id);
if (usuario != null) {
    procesarPerfil(usuario.getPerfil());
}

Kotlin:

val usuario = obtenerUsuario(id)
usuario?.let {
    procesarPerfil(it.perfil)
}

8 Emplee data classes para objetos inmutables

Las data class en Kotlin son ideales para representar datos inmutables, similar a los records en Java.

Kotlin:

data class Mensaje(val emisor: String, val contenido: String, val marcaTiempo: Long)

interface ServicioMensajes {
    fun enviar(mensaje: Mensaje)
}

9 Use funciones de expresión única para mapeos

Las funciones de expresión única en Kotlin son útiles para transformaciones sencillas.

data class Coordenada(val latitud: Double, val longitud: Double)

fun parsearCoordenadas(mapa: Map<String, Any>) = Coordenada(
    latitud = mapa["lat"] as Double,
    longitud = mapa["lon"] as Double
)

10 Inicialice propiedades directamente en su definición

Evite usar bloques init para inicialización simple; use expresiones directas.

Java:

public class Conector {
    private String url;
    private HttpClient cliente;

    public Conector(String base) {
        this.url = base + "/api";
        HttpClientBuilder builder = HttpClientBuilder.create();
        builder.setConexionesMaximas(10);
        this.cliente = builder.build();
    }
}

Kotlin:

class Conector(base: String) {
    private val url = "$base/api"
    private val cliente = HttpClientBuilder.create().apply {
        conexionesMaximas = 10
    }.build()
}

11 Declare implementaciones sin estado como object

Use object para clases sin estado que implementan interfaces.

object ManejadorEventos : EventListener() {
    override fun onEvento(evento: Evento) {
        // lógica de manejo
    }
}

12 Aproveche la desestructuración en Kotlin

Kotlin permite desestructurar objetos, facilitando el acceso a múltiples valores.

data class Empleado(val nombre: String, val departamento: String, val antiguedad: Int)

fun obtenerEmpleados(): List<Empleado> = listOf(
    Empleado("Ana", "Ventas", 5),
    Empleado("Luis", "TI", 3)
)

fun main() {
    for ((nombre, depto, antig) in obtenerEmpleados()) {
        println("$nombre trabaja en $depto con $antig años")
    }
}

13 Use sealed classes para resultados contrloados

Las sealed class son útiles para modelar respuestas con múltiples estados, como alternativa a excepciones.

sealed class ResultadoCarga {
    data class Exito(val datos: List<String>) : ResultadoCarga()
    data class Error(val mensaje: String) : ResultadoCarga()
}

fun cargarDatos(ruta: String): ResultadoCarga {
    return try {
        val contenido = leerArchivo(ruta)
        ResultadoCarga.Exito(contenido)
    } catch (e: Exception) {
        ResultadoCarga.Error("Error al cargar: ${e.message}")
    }
}

fun main() {
    when (val resultado = cargarDatos("datos.txt")) {
        is ResultadoCarga.Exito -> println("Datos: ${resultado.datos}")
        is ResultadoCarga.Error -> println(resultado.mensaje)
    }
}

14 Minimice la anidación de condicionales

Evite anidamientos profundos en Kotlin usando cláusulas de guardia o lógica plana.

Ejemplo de código con anidamiento excesivo:

fun calcularDescuento(cliente: Cliente?, articulos: List<Articulo>): Double {
    if (cliente != null) {
        if (articulos.isNotEmpty()) {
            if (cliente.esVIP()) {
                return articulos.sumOf { it.precio * 0.1 }
            }
        }
    }
    return 0.0
}

Versión mejorada:

fun calcularDescuento(cliente: Cliente?, articulos: List<Articulo>): Double {
    val clienteValido = cliente ?: return 0.0
    if (articulos.isEmpty()) return 0.0
    return if (clienteValido.esVIP()) articulos.sumOf { it.precio * 0.1 } else 0.0
}

15 Use bibliotecas de logging en producción

En lugar de println, emplee bibliotecas como Log4j o SLF4j para registro de eventos.

Kotlin:

import org.slf4j.LoggerFactory

class GestorUsuarios {
    companion object {
        private val log = LoggerFactory.getLogger(GestorUsuarios::class.java)
    }

    fun crearUsuario(nombre: String) {
        try {
            // lógica de creación
            log.info("Usuario creado: $nombre")
        } catch (e: Exception) {
            log.error("Error al crear usuario", e)
        }
    }
}