Java y los lenguajes JVM: Scala en un vistazo

Scala es un lenguaje de programación orientado a objetos y funcional. Es además uno de los lenguajes dependientes de la JVM como lo son Clojure, Groovy y Kotlin.

Instalación con SDKMAN!

sdk install scala

Comprobamos la instalación:

scala --version
scalac --version

Holamundo.scala

object Holamundo{
    def main(args: Array[String]): Unit = {
        println("Hola, mundo en Scala !!")
   }
}

El clásico "Hola, mundo" en Scala. Como se puede ver la extensión del programa no puede ser más que *.scala

ACTUALIZACIÓN

Esto no podrá servir más que enversiones antiguas del lenguaje.

Compilar y ejecutar:

# Compilación
scalac HolaMundo.scala

# Ejecución
scala HolaMundo

Si solo quieres ejecutar, teclea solo la segunda instrucción.

# Ejecución
scala HolaMundo.scala

Nota: Esta es la nueva forma para ejecutar tus programas en Scala:

scala run HolaMundo.scala

Variables.scala

object Variables{
    def main(args: Array[String]): Unit = {
        variables()
    }
    def variables():Unit = {
        val nombre:String = "Fernando"
        var cierto:Boolean = 34 > 88
        val car: Char = '\u0021'
        val flotante: Float = 32.1f
        val numero: Short = 2
        val entero: Int = 321
        val largo: Long = 1202020L
        val real: Double = 30303.88
        val bigDecimal = BigDecimal("2")
        println("\t [Variables en Scala]")
        printf("Hola, %s\n",nombre)
        printf("Es cierto?: %b\n",cierto)
        printf("Caracter: %c\n",car)
        printf("Numero: %d\n",numero)
        printf("Entero: %d\n",entero)
        printf("Largo: %1d\n",largo)
        printf("Flotante: %.2f\n",flotante)
        printf("Real: %.2f\n",real)
        printf("BigDecimal: %.2f\n",bigDecimal)
    }
}

En este programa se puede ver la declaración de variables y tipo de datos. Se usa val para declarar constantes y var para las variables.

Tipos de datos en Scala

Tipo	Descripción	Como se imprime
Short	Número corto	%d
Byte	Byte	%d
Int	Entero	%d
Long	Número largo	%1d
Char	Caracter simple	%c
String	Cadena de caracteres	%s
Float	Flotante	%f
Double	Real	%.f
Boolean	Booleano	%b

Condicionales.scala

object Condicionales{
    def main(args: Array[String]): Unit = {
        selectivas()
    }
    def selectivas():Unit ={
        var cierto:Boolean = false
        val opcion = 1
        println("\t [ Sentencias selectivas ]")

        if (!cierto){
            println("A");
        }

        if (cierto){
            println("B")
        }else if( 32 > 43 && 90 == 32){
            println("C")
        }else{
            println("AA")
        }

        printf("Resultado: %s\n",matchOpcion(opcion))
        
       
        "Alef"match {
            case "Alef" => println("El inicio")
            case "Bet" => println("La sabiduría")
            case _ => println("undefined")
        }
    }

    def matchOpcion(x:Int): String = x match{
        case 0 => "Opcion 0"
        case 1 => "Opcion 1"
        case 2 => "Opcion 2"
        case _ => "Otra opcion"
    }
}

En este programa se pueden ver algunas sentencias selectivas. La que más llama la atención es la sentencia match, el cual es el switcth de este lenguaje

Repetitivas.scala

object Repetitivas{
    def main(args: Array[String]): Unit = {
        repetitivas()
    }
    def repetitivas(): Unit={
        val librosPrecio = Map(
            "El ser y la nada"  -> 300.0, 
            "La cuarta dama"  -> 245.0, 
            "Unicornios y dragones" -> 350.0)
        val numeros = Seq(1,2,3,4,5)
        val nombres = List("Bill", "Candy", "Karen", "Leo", "Regina")
        println("\t [ Sentencias repetitivas ]")

        for (n <- numeros) println(n)
        println()
        for(n <- nombres) println(n)
        println()
        nombres.foreach(println)

        // Usando el for
        for ((titulo,precio) <- librosPrecio) println(s"Libro: $titulo, Precio: $precio")
        println()
        // Usando for each
        librosPrecio.foreach {
            case(titulo,precio) => println(s"Libro: $titulo, Precio: $precio")
        }
    }
}

En este programa podemos ver como iterar una lista y mapa usando for y for each propios del lenguaje.

En próximos post se verán más ejemplos de este lenguaje.

Enlaces:

https://www.scala-lang.org/
http://scalatutorials.com/