Scala, acrónimo de Scalable Language, es un lenguaje de programación multi-paradigma diseñado para integrar de manera fluida las características de la programación orientada a objetos y la programación funcional. Desarrollado por Martin Odersky en la EPFL, Scala se ejecuta sobre la Máquina Virtual de Java (JVM), lo que le permite aprovechar todo el ecosistema de librerías de Java mientras ofrece una sintaxis mucho más concisa y expresiva.

Fundamentos y Entorno de Ejecución

Al ser un lenguaje que compila a bytecode de Java, el primer requisito para trabajar con Scala es tener instalado un Kit de Desarrollo de Java (JDK) versión 1.8 o superior. La configuración del entorno implica definir la variable de sistema SCALA_HOME apuntando al directorio de instalación y añadir el subdirectorio bin a la variable PATH del sistema.

Para verificar la instalación, se puede utilizar el comando:

scala -version

Sintaxis Básica: Variables y Tipos

En Scala, la distinción entre mutabilidad e inmutabilidad es fundamental:

• val: Define una referencia inmutable (valor constante).
• var: Define una referencia mutable (variable).

// Definición de valores y variables
val constantePi: Double = 3.14159
var contadorEjecuciones: Int = 0

// Operaciones básicas
val sumaResultado = 10 + 5
val esMayor = 10 > 5

Estructuras de Control y Funciones

Scala trata las estructuras de control como expresiones que devuelven un valor. A continuación, se prseenta un ejemplo de una función para determinar si un año es bisiesto:

def verificarAnioBisiesto(anio: Int): Boolean = {
  if (anio % 400 == 0) {
    true
  } else if (anio % 4 == 0 && anio % 100 != 0) {
    true
  } else {
    false
  }
}

// Uso de la función en un punto de entrada
object ValidadorCalendario {
  def main(args: Array[String]): Unit = {
    val anioPrueba = 2024
    if (verificarAnioBisiesto(anioPrueba)) {
      println(s"$anioPrueba es un año bisiesto.")
    }
  }
}

Manipulación de Arreglos (Arrays)

Los arreglos en Scala son colecciones mutables de elementos del mismo tipo con un tamaño fijo.

object GestionArreglos {
  def main(args: Array[String]): Unit = {
    val datosNumericos = Array(12.5, 45.2, 33.8, 19.1)
    
    // Recorrido del arreglo
    for (valor <- datosNumericos) {
      println(s"Elemento: $valor")
    }

    // Cálculo del promedio
    var acumulado = 0.0
    for (i <- 0 until datosNumericos.length) {
      acumulado += datosNumericos(i)
    }
    println("Promedio: " + (acumulado / datosNumericos.length))
  }
}

Colecciones Inmutables: Listas y Conjuntos

Scala ofrece una potente jerarquía de colecciones. Las List representan secuencias enlazadas inmutables, mientras que los Set garantizan la unicidad de sus elementos.

// Trabajo con Listas
val frutas = List("Manzana", "Pera", "Naranja")
val masFrutas = "Uva" :: frutas // Añade elemento al inicio

// Operaciones con Sets
val numerosUnicos = Set(1, 2, 3, 3, 4) // El resultado será Set(1, 2, 3, 4)
val contieneDos = numerosUnicos.contains(2)

Mapas y Tuplas

Los mapas almacenan pares clave-valor, y las tuplas permiten agrupar una cantidad fija de elementos de diferentes tipos.

// Definición de un Mapa
val codigosPostales = Map("MAD" -> "Madrid", "BCN" -> "Barcelona")
val ciudad = codigosPostales.getOrElse("MAD", "Desconocido")

// Uso de Tuplas
val informacionUsuario = (101, "Admin", true)
println(s"ID: ${informacionUsuario._1}, Nombre: ${informacionUsuario._2}")

Programación Orientada a Objetos en Scala

Scala no posee miembros estáticos. En su lugar, utiliza el concepto de object para definir singletons. Las clases se definen con constructores primarios integrados en la firma de la clase.

class Coordenada(val ejeX: Int, val ejeY: Int) {
  def mostrarPosicion(): Unit = {
    println(s"Posición actual: [$ejeX, $ejeY]")
  }
}

// Herencia
class Coordenada3D(override val ejeX: Int, override val ejeY: Int, val ejeZ: Int) 
  extends Coordenada(ejeX, ejeY) {
  
  override def mostrarPosicion(): Unit = {
    println(s"Espacio 3D: [$ejeX, $ejeY, $ejeZ]")
  }
}

object PruebaEspacial {
  def main(args: Array[String]): Unit = {
    val punto = new Coordenada3D(10, 20, 30)
    punto.mostrarPosicion()
  }
}

Entrada y Salida de Archivos

Para operaciones de I/O, Scala puede utilizar directamente las clases de java.io o sus propios wrappers simplificados como scala.io.Source.

import java.io._
import scala.io.Source

object ManejoArchivos {
  def main(args: Array[String]): Unit = {
    val nombreArchivo = "datos.txt"

    // Escritura de archivo
    val escritor = new PrintWriter(new File(nombreArchivo))
    escritor.write("Línea de prueba en Scala\n")
    escritor.close()

    // Lectura de archivo
    Source.fromFile(nombreArchivo).getLines().foreach(println)
  }
}