Variables, tipos y operaciones

Al terminar esta lección sabrás guardar datos en variables, qué tipos de dato hay, cómo hacer cuentas con ellos y cómo meter los resultados dentro de un texto. Tu Main.kt presentará el torneo con variables y verás sus tres líneas por consola.

Importa porque todo programa trabaja con datos: nombres, marcadores, jornadas. Antes de escribir reglas del torneo hay que saber guardarlos y operar con ellos.

Temas: val y var; tipos (Int, Double, String, Boolean); operadores y expresiones; inferencia y plantillas de texto.

val y var: dos formas de guardar un valor

Una variable es una caja con nombre donde guardas un dato para usarlo después. Kotlin te obliga a decidir, en cada una, si el valor puede cambiar: val es una caja precintada (se llena una vez y ya), y var es una pizarra (se puede borrar y reescribir).

En cristiano: «variable local» es la que creas dentro de una función; «inmutable» quiere decir que no cambia; «inicialización» es darle su primer valor; y «reasignar» es guardar otro valor en la misma caja.

La regla práctica: escribe val siempre, y cambia a var solo cuando necesites reasignar. Hay un matiz con los val que guardan valores más complejos (listas, objetos), que aún no conoces; lo verás en Inmutabilidad y referencias. Con números y textos, un val no cambia nunca.

El signo = guarda un valor en una variable (se llama asignación): val equipos = 4 dice «guarda un 4 con el nombre equipos». No compara dos cosas; para comparar hay otro operador, que verás en Condiciones: if y when.

Tipos: qué clase de dato es

Cada valor es de una categoría, que Kotlin llama tipo: un número entero, un número con decimales, un texto, un sí o no. El tipo decide qué puedes hacer con el valor: puedes multiplicar dos números, pero no dos textos.

Hay más: Long es un entero para números enormes (se escribe 4L) y Char es una sola letra entre comillas simples ('A'). Con los cuatro de la tabla vas a tener de sobra.

Operaciones: hacer cuentas

Un operador es un símbolo que combina valores. Los aritméticos son + (suma), - (resta), * (multiplica), / (divide) y % (el resto de una división). Una expresión es un trozo de código que da un valor, como paginas - 100. Se evalúa primero *, / y %, y después + y -, como en matemáticas; los paréntesis cambian el orden. Entre dos textos, + los une.

Al declarar una variable puedes escribir su tipo con dos puntos: val paginas: Int = 600 se lee «paginas es un Int y vale 600». Y verás un punto entre un valor y un nombre, como a.toLong(): el punto le pide algo a un valor (aquí, que se convierta en otro tipo). Se explica en Nulabilidad.

fun main() {
    val titulo: String = "Rayuela"     // String: texto, siempre entre comillas dobles
    val paginas: Int = 600             // Int: número entero, sin decimales
    val precio: Double = 12.5          // Double: número con decimales (punto, no coma)
    val prestado: Boolean = false      // Boolean: solo puede valer true o false
    println(titulo)
    println(paginas + 10)              // + suma dos números: 610
    println(paginas - 100)             // - resta: 500
    println(paginas * 2)               // * multiplica: 1200
    println(paginas / 7)               // / entre dos Int descarta los decimales: 85
    println(paginas % 7)               // % da el resto de esa división: 5
    println(precio * 2)                // con un Double, los decimales se conservan: 25.0
    println(2 + 3 * 4)                 // primero * y /, después + y -: 14
    println((2 + 3) * 4)               // los paréntesis cambian el orden: 20
    println("Libro: " + titulo)        // + entre textos los une: Libro: Rayuela
    println(prestado)                  // false
}

Al ejecutarlo en el Playground sale:

Rayuela
610
500
1200
85
5
25.0
14
20
Libro: Rayuela
false

Fíjate en paginas / 7: 600 entre 7 son 85,7…, pero entre dos Int el resultado es otro Int, así que los decimales se descartan. Si uno de los dos es Double, se conservan.

Inferencia y plantillas de texto

No siempre hace falta escribir el tipo: Kotlin lo deduce del valor, y eso se llama inferencia. val socios = 10 es un Int aunque no lo digas. El tipo explícito (val socios: Int = 10) se escribe para dejarlo claro o cuando no hay valor inicial.

Una plantilla de texto mete variables dentro de un texto: $nombre inserta el valor de una variable y ${...} inserta el resultado de una expresión.

fun main() {
    val biblioteca = "Biblioteca del barrio"   // String, deducido del valor: inferencia
    var prestados = 3                          // Int; var, porque va a cambiar
    val socios: Int = 10                       // tipo explícito, aunque no hace falta
    prestados += 1                             // += suma y guarda: lo mismo que prestados = prestados + 1. Con un val no compilaría
    // $biblioteca inserta una variable; ${socios - prestados} inserta el resultado de una expresión
    println("$biblioteca: $prestados libros prestados, ${socios - prestados} socios sin libro")
    println("Cuota: \$5")                      // \$ escribe un signo de dólar literal
    println(7 / 2)                             // 3: entre dos Int, la división descarta los decimales
    println(7 / 2.0)                           // 3.5: con un Double se conservan
}

Biblioteca del barrio: 4 libros prestados, 6 socios sin libro
Cuota: $5
3
3.5

Tienda: Deportes Sur
Gastado: 54
Petos de regalo: 2

fun main() {
    val tienda = "Deportes Sur"       // no cambia: val
    val precioBalon = 12
    val precioPeto = 3
    var gastado = 0                   // va a cambiar: var
    gastado += 2 * precioBalon        // 2 balones: 24
    gastado += 10 * precioPeto        // 10 petos: 30, y en total 54
    val regalo = 10 / 4               // entre dos Int se descartan los decimales: 2
    println("Tienda: $tienda")
    println("Gastado: $gastado")
    println("Petos de regalo: $regalo")
}

Paso · Amplía Main.kt con val y var

Objetivo: que Main.kt presente el torneo con variables y plantillas, y ejecutarlo de nuevo.

Intenta escribirlo tú. Reescribe el main(): guarda el nombre del torneo (Copa Barrio), la jornada actual (la 1) y el número de equipos (4); calcula cuántos partidos hay por jornada, que es la mitad de los equipos, y cuántas jornadas tiene el torneo, que son los equipos menos uno. Muestra el torneo y la jornada, pasa a la jornada siguiente y anúnciala. Pista: el nombre y el número de equipos no cambian, la jornada sí; y dividir un entero entre otro da un entero. Al ejecutarlo debe verse:

Torneo: Copa Barrio
Jornada 1 de 3: 2 partidos
La siguiente jornada será la 2

El título del bloque de abajo es la ruta del fichero en tu proyecto: torneo/src/main/java/.... En la vista Android es el nodo kotlin+java.

package com.sebastiannarvaez.marcador.torneo
 
// Punto de entrada de consola: ./gradlew :torneo:run
fun main() {
    val nombreDelTorneo = "Copa Barrio"
    var jornada = 1
    val equipos = 4
    val partidosPorJornada = equipos / 2
    println("Torneo: $nombreDelTorneo")
    println("Jornada $jornada de ${equipos - 1}: $partidosPorJornada partidos")
    jornada += 1
    println("La siguiente jornada será la $jornada")
}

Abre la Terminal de Android Studio (View → Tool Windows → Terminal) y vuelve a ejecutar ./gradlew :torneo:run. Ahora salen tres líneas:

> Task :torneo:compileKotlin
> Task :torneo:run
Torneo: Copa Barrio
Jornada 1 de 3: 2 partidos
La siguiente jornada será la 2
 
BUILD SUCCESSFUL in 3s