Una guía rápida de los idiomas JVM

Programación

1. Introducción

Además de Java, otros lenguajes pueden ejecutarse en la máquina virtual Java como Scala, Kotlin, Groovy, Clojure.

En las siguientes secciones, analizaremos en detalle los lenguajes JVM más populares.

Por supuesto, comenzaremos con el precursor de los lenguajes JVM: Java.

2. Java

2.1. Visión general

Java es un lenguaje de programación de propósito general que adopta el paradigma orientado a objetos.

Una característica central del lenguaje es la portabilidad multiplataforma , lo que significa que los programas escritos en una plataforma se pueden ejecutar en cualquier combinación de software y hardware con un soporte de tiempo de ejecución adecuado. Esto se logra compilando el código en bytecode primero, en lugar de directamente en el código de máquina específico de la plataforma.

Las instrucciones de código de bytes de Java son análogas al código de máquina, pero son interpretadas por una máquina virtual de Java (JVM) específica para el sistema operativo host y la combinación de hardware.

Aunque originalmente era un lenguaje orientado a objetos, Java ha comenzado a adoptar conceptos de otros paradigmas de programación como la programación funcional.

Echemos un vistazo rápido a algunas de las características principales de Java:

  • Orientado a objetos
  • Fuertemente tipado estáticamente
  • Plataforma independiente
  • Recogida de basura
  • Multiproceso

2.2. Ejemplos

Veamos cómo un simple "¡Hola, mundo!" ejemplo se ve así:

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }

En este ejemplo, creamos una clase llamada HelloWorld y definimos el método principal que imprime un mensaje en la consola.

A continuación, usaremos el comando javac para generar el código de bytes que se puede ejecutar en una JVM:

javac HelloWorld.java

Finalmente, el comando java ejecuta el bytecode generado en JVM:

java HelloWorld

Para obtener más ejemplos de Java, consulte nuestra lista de tutoriales.

3. Scala

3.1. Visión general

Scala significa "lenguaje escalable". Scala es un lenguaje de tipo estático que combina dos importantes paradigmas de programación, a saber, la programación funcional y la orientada a objetos.

El idioma se originó en 2004 pero se hizo más popular en los últimos años.

Scala es un lenguaje puro orientado a objetos, ya que no admite primitivas . Scala proporciona la capacidad de definir clases, objetos, métodos junto con características de programación funcional como rasgos, tipos de datos algebraicos o clases de tipos.

Algunas características importantes de Scala son:

  • Funcional, orientado a objetos
  • Fuertemente tipado estáticamente
  • Tipos de datos algebraicos
  • La coincidencia de patrones
  • Soporte de inmutabilidad mejorado
  • Computación perezosa
  • Multiproceso

3.2. Ejemplos

Primero, echemos un vistazo al mismo "¡Hola, mundo!" ejemplo como antes, esta vez en Scala:

object HelloWorld { def main(args: Array[String]): Unit = println("Hello, world!") }

En este ejemplo, hemos creado un objeto singleton llamado HelloWorld y el método principal .

A continuación, para compilar esto, podemos usar scalac :

scalac HelloWorld.scala

El comando scala ejecuta el bytecode generado en JVM:

scala HelloWorld

4. Kotlin

4.1. Visión general

Kotlin es un lenguaje de código abierto, de propósito general y tipificado estáticamente desarrollado por el equipo de JetBrains , que reúne los paradigmas funcional y orientado a objetos.

El enfoque principal durante el desarrollo de Kotlin fue la interoperabilidad de Java, la seguridad (manejo de excepciones), la concisión y un mejor soporte de herramientas.

Desde el lanzamiento de Android Studio 3.0, Kotlin es un lenguaje de programación totalmente compatible con Google en la plataforma Android. También se incluye en el paquete IDE de Android Studio como alternativa al compilador estándar de Java.

Algunas características importantes de Kotlin:

  • Orientado a objetos + funcional
  • Fuertemente tipado estáticamente
  • Conciso
  • Interoperable con Java

Nuestra introducción a Kotlin también contiene más detalles sobre las características.

4.2. Ejemplos

Veamos el mensaje "¡Hola, mundo!" ejemplo en Kotlin:

fun main(args: Array) { println("Hello, World!") }

Podemos escribir el código anterior en un nuevo archivo llamado helloWorld.kt.

Luego, usaremos el comando kotlinc para compilar esto y generar un código de bytes que se puede ejecutar en una JVM:

kotlinc helloWorld.kt -include-runtime -d helloWorld.jar

La opción -d se usa para indicar el archivo de salida para archivos de clase o un nombre de archivo .jar . La opción -include-runtime hace que el archivo .jar resultante sea ​​autónomo y ejecutable al incluir la biblioteca de tiempo de ejecución de Kotlin en él.

Luego, el comando java ejecuta el bytecode generado en JVM:

java -jar helloWorld.jar

Veamos también otro ejemplo de impresión de una lista de elementos usando un bucle for :

fun main(args: Array) { val items = listOf(1, 2, 3, 4) for (i in items) println(i) }

5. Groovy

5.1. Visión general

Groovy es un lenguaje dinámico específico de dominio (DSL), opcionalmente escrito, orientado a objetos, con soporte para funciones de escritura estática y compilación estática. Su objetivo es mejorar la productividad del desarrollador, con una sintaxis fácil de aprender.

Groovy se integra fácilmente con cualquier programa Java e inmediatamente agrega características poderosas, como capacidades de scripting, tiempo de ejecución y metaprogramación en tiempo de compilación y características de programación funcional.

Destaquemos algunas características importantes:

  • Orientado a objetos con características funcionales como funciones de orden superior, curado, cierres
  • Escritura: dinámica, estática, fuerte, pato
  • Lenguaje específico del dominio
  • Interoperabilidad con Java
  • Productividad por concisión
  • Sobrecarga del operador

5.2. Ejemplos

Primero, veamos nuestro "¡Hola, mundo!" ejemplo en Groovy:

println("Hello world")

Escribimos el código anterior en un nuevo archivo llamado HelloWorld.groovy . Ahora podemos ejecutar este código de dos maneras: compilando y luego ejecutándolo o simplemente ejecutando código no compilado.

Podemos compilar un archivo .groovy usando el comando groovyc de la siguiente manera:

groovyc HelloWorld.groovy

Luego, usaremos el comando java para ejecutar el código maravilloso:

java -cp \embeddable\groovy-all-.jar;. HelloWorld

Por ejemplo, el comando anterior podría verse así:

java -cp C:\utils\groovy-1.8.1\embeddable\groovy-all-1.8.1.jar;. HelloWorld

Veamos también cómo podemos usar el comando groovy para ejecutar el archivo .groovy sin compilar:

groovy HelloWorld.groovy

Finalmente, aquí hay otro ejemplo de impresión de una lista de elementos con el índice:

list = [1, 2, 3, 4, 5, 6, 7, 8, 9] list.eachWithIndex { it, i -> println "$i: $it"}

Eche un vistazo a más ejemplos de Groovy en nuestro artículo de introducción.

6. Clojure

6.1. Visión general

Clojure es un lenguaje de programación funcional de propósito general. El lenguaje se ejecuta en JVM y en Common Language Runtime de Microsoft. Clojure es un lenguaje compilado aún, permanece dinámico, ya que sus características son compatibles en tiempo de ejecución.

Los diseñadores de Clojure querían diseñar Lisp moderno que se pudiera ejecutar en JVM. Es por eso que también se lo conoce como un dialecto del lenguaje de programación Lisp. Al igual que Lisps, Clojure trata el código como datos y también tiene un sistema de macros.

Algunas características importantes de Clojure:

  • Funcional
  • Escritura: dinámica, fuerte, recientemente comenzó a admitir la escritura gradual.
  • Diseñado para simultaneidad
  • Polimorfismo en tiempo de ejecución

6.2. Ejemplos

A diferencia de otros lenguajes de JVM, no es tan sencillo crear un simple "¡Hola, mundo!" programa en Clojure.

Usaremos la herramienta Leiningen para ejecutar nuestro ejemplo.

Primero, crearemos un proyecto simple con una plantilla predeterminada usando el siguiente comando:

lein new hello-world

El proyecto se creará con la siguiente estructura de archivos:

./project.clj ./src ./src/hello-world ./src/hello-world/core.clj

Ahora necesitamos actualizar el archivo ./project.ctj con el siguiente contenido para configurar el archivo fuente principal:

(defproject hello-world "0.1.0-SNAPSHOT" :main hello-world.core :dependencies [[org.clojure/clojure "1.5.1"]])

Ahora estamos listos para actualizar nuestro código para imprimir "¡Hola, mundo!" en el ./src/hello-world/core. archivo clj:

(ns hello-world.core) (defn -main [& args] (println "Hello, World!"))

Finalmente, usaremos el comando lein para ejecutar el código anterior, después de movernos al directorio raíz del proyecto:

cd hello-world lein run

7. Otros idiomas de JVM

7.1. Jython

Jython es la implementación de la plataforma Java de Python que se ejecuta en la JVM.

Este lenguaje se diseñó inicialmente para permitir la escritura de aplicaciones de alto rendimiento sin sacrificar la interactividad. Jython está orientado a objetos, tiene múltiples subprocesos y utiliza el recolector de basura de Java para limpiar la memoria de manera eficiente.

Jython incluye la mayoría de los módulos que forman parte del lenguaje Python. También puede importar y utilizar cualquier clase de las bibliotecas de Java.

Veamos un rápido "¡Hola, mundo!" ejemplo:

print "Hello, world!"

7.2. JRuby

JRuby es una implementación del lenguaje de programación Ruby para ejecutarse en la máquina virtual Java.

El lenguaje JRuby es de alto rendimiento y multiproceso, con una amplia variedad de bibliotecas disponibles de Java y Ruby. Además, combina características de ambos lenguajes, como la programación orientada a objetos y la escritura de pato.

Imprimamos "¡Hola, mundo!" en JRuby:

require "java" stringHello= "Hello World" puts "#{stringHello.to_s}"

8. Conclusión

En este artículo, hemos estudiado muchos lenguajes JVM populares junto con ejemplos de código básico. Estos lenguajes implementan varios paradigmas de programación, como escritura orientada a objetos, funcional, estática, dinámica.

Hasta ahora, muestra que incluso con la JVM que se remonta a 1995, sigue siendo una plataforma muy relevante y convincente para los lenguajes de programación de hoy en día.