Hola Mundo, Variables, tipos de datos, mutables e inmutables y Operadores en Kotlin

▶

Hablaremos sobre la variables y tipos de datos en Kotlin, ademas, de daremos un Hola Mundo en este lenguaje de programación; como ya sabemos Kotlin es un lenguaje de programación que nos sirve mucho más que para Android ya que emplea la máquina virtual de java JVM y podemos emplearlo en toda clase de desarrollos inclusive con otros desarrollos en Java al ser interoperable con este lenguaje.

Kotlin es conciso al reducir la cantidad de código a escribir, versátil y ligero, ya que puede ser empleado para Android y lenguaje del lado del cliente (navegador) son algunas de las características que lo describen; en esta entrada, hablaremos sobre los tipos de datos y su declaración.

Vamos a continuar y conocer los aspectos básicos de Kotlin, el lenguaje de programación que utilizaremos para desarrollar nuestras aplicaciones en Android.

Recordemos que nos quedamos en la instalación de Android Studio. De momento, podemos dejarlo así; no lo necesitaremos de inmediato, luego lo terminaremos de configurar. La idea ahora es enfocarnos en las bases de Kotlin, mientras puedes ir descargando los paquetes necesarios y practicar.

Para empezar, accedemos a la página oficial: kotlin.org. Damos clic en Get Started y comenzamos el tour. En esta página veremos clasificaciones y conceptos que seguiremos durante el curso, empezando por el clásico Hola Mundo y los tipos básicos.

El Famoso "Hola Mundo" y la Función main()

Al igual que ocurre con muchos lenguajes de programación (como Python, Java, Dart, y obviamente Kotlin), sobre todo aquellos destinados a aplicaciones de escritorio o móviles que necesitan un punto de arranque, tenemos una función main().

La función main() es la función de arranque. Es el primer código que se ejecuta y de ahí su nombre, principal. Es el punto donde inicia todo. Puedes tener la aplicación más sofisticada del mundo, pero si no tiene un punto de arranque, no funcionará.

En las aplicaciones web, esto cambia un poco ya que el acceso se da por rutas (aunque en lenguajes como PHP siempre tenemos un archivo de entrada como index.php). En Kotlin, en lugar de un archivo de entrada, es una función, tal como puedes ver.

• El main es la función principal desde la cual inicia todo.
• En aplicaciones web, como PHP, esto sería equivalente a index.php, pero en Kotlin se hace mediante una función.

Para ejecutar el código, simplemente damos clic en el icono de Run en la página de Kotlin. Esto nos permite probar nuestros programas sin necesidad de abrir Android Studio.

Declaración de funciones

En Kotlin, las funciones se definen usando fun, seguido del nombre de la función y paréntesis, y luego llaves para encapsular el código:

fun main() {
   println("Hola Kotlin")
}

• println() imprime texto en la consola, agregando un salto de línea.
• Puedes usar print() para imprimir en la misma línea.

Ejemplo de print():

fun main() {
   print("Hola Kotlin")
   print("¡Seguimos!")
}
// Salida: Hola Kotlin¡Seguimos! (Todo en una línea)
// Ejemplo de println():

fun main() {
   println("Hola Kotlin")
   println("¡Seguimos!")
}
// Salida:
// Hola Kotlin
// ¡Seguimos! (Cada uno en una línea aparte)

El punto y coma (;) es opcional en Kotlin, al igual que en Python y JavaScript.

Así, nuestro primer Hola Mundo es simple y funcional.

Tipos de datos básicos

Kotlin tiene varios tipos de datos:

• Enteros: Int, Long, Byte, etc.
• Flotantes: Float, Double
• Booleanos: Boolean (true o false)
• Caracteres: Char
• Cadenas de texto: String

También incluye enteros positivos, útiles para identificadores o edades. La sintaxis es clara y consistente, lo que evita errores comunes en otros lenguajes.

A continuación veamos los tipos de datos numéricos en Kotlin:

Para los demás tipos de datos que no son numéricos tenemos:

• Boolean
• Char
• String

En resumen:

• Enteros:
  • Byte, Short, Int, Long: Se usan para números enteros sin decimales, y cada uno define la longitud (el rango de números que puede almacenar). Por ejemplo, Int se puede usar para una edad o un tamaño. Long se usa cuando se necesita mucha longitud.
  • Unsigned Integers (Enteros sin signo): Son tipos enteros positivos (ej. UInt). Son extremadamente útiles en muchos casos, como identificadores de bases de datos o para la edad, donde no necesitamos valores negativos.
• Flotantes:
  • Float y Double: Se usan para números con decimales.
• Otros Tipos:
  • Boolean: Solo puede ser true o false. No puede faltar.
  • Char: Se usa para un solo carácter.
  • String: Se usa para cadenas de texto, como la que presentamos anteriormente en el "Hola Mundo".

Kotlin presenta un sistema de tipos muy estructurado, lo cual es muy beneficioso.

Variables y constantes: mutables (var) e inmutables (val)

Al igual que ocurre en Java, Kotlin permite definir variables de dos tipos, inmutables, que significa que no pueden ser modificadas (en Java la marcamos como final) mediante la palabra reservada val y mutables, que significa que pueden ser modificadas en cualquier momento, definidas mediante la palabra reservada var; veamos la siguiente serie de ejemplos.

Valores inferidos por el compilador de Kotlin

Podemos definir variables ya sean de tipo mutables e inmutables de la siguiente manera:

var age = 27 // valor mutable

Como podemos apreciar, en la línea de código anterior indicamos que creamos una variable mutable llamada age con el valor numérico entero de 27, pero no indicamos explícitamente infiere que es de tipo entero (int) en base al valor establecido en la variable, ya sea de tipo inmutable:

val age = 27

O mutable, como indicamos en el ejemplo anterior (var age = 27).

En resumen:

Kotlin distingue entre variables mutables e inmutables:

• val: constante, no puede cambiar su valor una vez asignado.
• var: variable mutable, se puede actualizar varias veces.

Ejemplo:

val constante = 5
var variable = 3
variable = 7

• Usar val siempre que sea posible mejora la eficiencia y seguridad del código.
• Las variables no inicializadas generan errores, gracias al sistema de protección contra nulos de Kotlin.

Esto evita problemas comunes de otros lenguajes como JavaScript o Java, donde el código puede ejecutar variables sin inicializar.

En Kotlin, se introducen conceptos interesantes como la protección contra nulos y la distinción entre tipos mutables e inmutables, que son equivalentes a variables y constantes, pero implementados directamente en el lenguaje.

val (Valor Inmutable / Constante)

Se declara con la palabra clave val. El valor de val no se puede reasignar o cambiar después de su inicialización. Se comporta como una constante.

val a: Int = 3 // Inicializada y declarada
val b = 5      // Inicializada e infiere el tipo (Int)
// a = 4 // Esto daría un error

var (Variable Mutable)

Se declara con la palabra clave var. El valor de var sí se puede actualizar en cualquier momento. Se comporta como una variable de toda la vida.

var d: Int = 3 // Declarada y inicializada
d = 5

También puedes declarar explícitamente el tipo de la variable para mayor claridad. Se hace colocando dos puntos : seguidos del tipo (por ejemplo, var d: Int).

Indicar explícitamente el tipo de dato

También podemos indicar explícitamente el tipo de dato:

var age:Int

Y especificar explícitamente el tipo de dato y definir el tipo de dato:

var age:Int = 27

Como podemos ver, las opciones sobran y se adaptan según las necesidades.

Por supuesto, podemos declarar otros tipos de datos como Char, Booleanos, String etc:

var name:String = "Andrés"

Por supuesto que se mantienen toda la lógica explicada hasta el momento; es decir si es mutables (var) e inmutables (val), si el valor es explicito o implícito etc.

Como podrás darte cuenta, las anteriores definiciones ya sea infiriendo el tipo o no pueden ser empleadas con val.

Mutables/var vs Inmutables/val

Aunque var permite mayor flexibilidad, la recomendación en Kotlin (y otros lenguajes modernos) es usar val (inmutable) siempre que sea posible. Esto se debe a varias ventajas:

• Eficiencia (Optimización): Los valores inmutables son más eficientes porque el compilador sabe que no van a cambiar.
• Menos Propenso a Errores (Bugs): Si un valor no debe cambiar, declararlo como val garantiza que si intentas cambiarlo por error, la aplicación reventará inmediatamente, indicando el problema. Si usas var y lo actualizas accidentalmente, podría causar un error sutil y difícil de detectar más adelante.
• Facilidad de Razonamiento: Al ver un val, cualquier persona (incluyéndote a ti mismo dentro de un mes) sabe que ese valor permanece fijo durante el flujo del programa, facilitando la comprensión del código.
• Seguridad (Thread-Safe): Los valores inmutables son seguros en entornos de concurrencia (multi-hilo), lo cual contribuye a la eficiencia y optimización del programa.

Usa val por defecto, y solo usa var si el valor realmente necesita ser mutable. Esta es una de las bases de Kotlin como lenguaje moderno.

Operadores y comentarios

Kotlin soporta los operadores típicos:

• Suma: +
• Resta: -
• Multiplicación: *
• División: /
• Módulo (Resto): %

Ejemplo:

var a = 5
var b = 3
println(a + b) // Imprime 8

Suma	d = d + 1	d += 1
Resta	d = d - 1	d -= 1
Multiplicación	d = d * 5	d *= 5
División	d = d / 2	d /= 2

Agregar comentarios

Los comentarios se definen con la doble barra inclinada //. El texto que sigue a esto en esa línea no será ejecutado por el compilador.

Kotlin

// Esto es un comentario

O múltilinea:

/*
* Comentario
* */

Conclusión

En resumen:

• Conocimos cómo ejecutar Kotlin sin Android Studio.
• Creamos nuestro primer Hola Mundo.
• Vimos los tipos de datos, variables mutables (var) e inmutables (val).
• Aprendimos a imprimir datos en la consola y usar operadores básicos.

Kotlin es moderno, seguro y expresivo, incorporando buenas prácticas desde su diseño. Esto hace que el código sea más eficiente y menos propenso a errores.

En la siguiente entrada que tratemos Seguridad contra nulos: Tipos no nulos y nulabilidad en Kotlin