Una guida rapida alle lingue JVM

1. Introduzione

Oltre a Java, altri linguaggi possono essere eseguiti sulla Java Virtual Machine come Scala, Kotlin, Groovy, Clojure.

Nelle sezioni seguenti, daremo uno sguardo di alto livello ai linguaggi JVM più popolari.

Naturalmente, inizieremo con il precursore dei linguaggi JVM: Java.

2. Java

2.1. Panoramica

Java è un linguaggio di programmazione generico che abbraccia il paradigma orientato agli oggetti.

Una caratteristica fondamentale del linguaggio è la portabilità multipiattaforma , il che significa che i programmi scritti su una piattaforma sono eseguibili su qualsiasi combinazione di software e hardware con un adeguato supporto di runtime. Ciò si ottiene compilando prima il codice in bytecode, invece che direttamente nel codice macchina specifico della piattaforma.

Le istruzioni del bytecode Java sono analoghe al codice macchina, ma sono interpretate da una Java Virtual Machine (JVM) specifica per il sistema operativo host e la combinazione hardware.

Sebbene originariamente fosse un linguaggio orientato agli oggetti, Java ha iniziato ad adottare concetti da altri paradigmi di programmazione come la programmazione funzionale.

Diamo una rapida occhiata ad alcune delle caratteristiche principali di Java:

  • Orientato agli oggetti
  • Fortemente tipizzato staticamente
  • Piattaforma indipendente
  • Raccolta dei rifiuti
  • Multithread

2.2. Esempi

Vediamo come un semplice "Hello, World!" l'esempio è simile a:

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

In questo esempio, abbiamo creato una classe denominata HelloWorld e definito il metodo principale che stampa un messaggio sulla console.

Successivamente, useremo il comando javac per generare il bytecode che può essere eseguito su una JVM:

javac HelloWorld.java

Infine, il comando java esegue il bytecode generato su JVM:

java HelloWorld

Per altri esempi Java, controlla il nostro elenco di tutorial.

3. Scala

3.1. Panoramica

Scala sta per "linguaggio scalabile". Scala è un linguaggio tipizzato staticamente che combina due importanti paradigmi di programmazione, vale a dire la programmazione orientata agli oggetti e quella funzionale.

La lingua è nata nel 2004 ma è diventata più popolare negli ultimi anni.

Scala è un puro linguaggio orientato agli oggetti in quanto non supporta le primitive . Scala offre la capacità di definire classi, oggetti, metodi insieme a caratteristiche di programmazione funzionale come tratti, tipi di dati algebrici o classi di tipi.

Alcune caratteristiche importanti di Scala sono:

  • Funzionale, orientato agli oggetti
  • Fortemente tipizzato staticamente
  • Tipi di dati algebrici
  • Corrispondenza del modello
  • Supporto migliorato per l'immutabilità
  • Calcolo pigro
  • Multithread

3.2. Esempi

Per prima cosa, diamo un'occhiata allo stesso "Hello, World!" esempio come prima, questa volta in Scala:

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

In questo esempio, abbiamo creato un oggetto singleton denominato HelloWorld e il metodo principale .

Successivamente, per compilarlo, possiamo usare scalac :

scalac HelloWorld.scala

Il comando scala esegue il bytecode generato su JVM:

scala HelloWorld

4. Kotlin

4.1. Panoramica

Kotlin è un linguaggio open source di tipo statico, generico e sviluppato dal team JetBrains , che riunisce i paradigmi orientati agli oggetti e quelli funzionali.

L'obiettivo principale durante lo sviluppo di Kotlin era l'interoperabilità di Java, la sicurezza (gestione delle eccezioni), la concisione e un migliore supporto per gli strumenti.

Dal rilascio di Android Studio 3.0, Kotlin è un linguaggio di programmazione completamente supportato da Google sulla piattaforma Android. È anche incluso nel pacchetto IDE di Android Studio come alternativa al compilatore Java standard.

Alcune importanti caratteristiche di Kotlin:

  • Orientato agli oggetti + Funzionale
  • Fortemente tipizzato staticamente
  • Conciso
  • Interoperabile con Java

La nostra introduzione a Kotlin contiene anche maggiori dettagli sulle funzionalità.

4.2. Esempi

Vediamo "Hello, World!" esempio in Kotlin:

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

Possiamo scrivere il codice sopra in un nuovo file chiamato helloWorld.kt.

Quindi, useremo il comando kotlinc per compilarlo e generare bytecode che può essere eseguito su una JVM:

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

L' opzione -d viene utilizzata per indicare il file di output per i file di classe o un nome file .jar . L' opzione -include-runtime rende il file .jar risultante autonomo ed eseguibile includendo la libreria di runtime Kotlin in esso.

Quindi, il comando java esegue il bytecode generato su JVM:

java -jar helloWorld.jar

Vediamo anche un altro esempio di stampa di un elenco di elementi utilizzando un ciclo for :

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

5. Groovy

5.1. Panoramica

Groovy è un DSL (Dynamic Domain Specific Language) orientato agli oggetti, digitato facoltativamente , con supporto per la digitazione statica e funzionalità di compilazione statica. Ha lo scopo di migliorare la produttività degli sviluppatori, con una sintassi di facile apprendimento.

Groovy si integra facilmente con qualsiasi programma Java e aggiunge immediatamente potenti funzionalità, come capacità di scripting, meta-programmazione in fase di compilazione e runtime e funzionalità di programmazione funzionale.

Evidenziamo alcune caratteristiche importanti:

  • Orientato agli oggetti con caratteristiche funzionali come funzioni di ordine superiore, curry, chiusure
  • Digitazione: dinamica, statica, forte, anatra
  • Lingua specifica del dominio
  • Interoperabilità con Java
  • Produttività per concisione
  • Sovraccarico dell'operatore

5.2. Esempi

Per prima cosa, vediamo il nostro "Hello, World!" esempio in Groovy:

println("Hello world")

Abbiamo scritto il codice sopra in un nuovo file chiamato HelloWorld.groovy . Ora possiamo eseguire questo codice in due modi: compilando e quindi eseguendo o semplicemente eseguendo codice non compilato.

Possiamo compilare un file .groovy usando il comando groovyc come segue:

groovyc HelloWorld.groovy

Quindi, useremo il comando java per eseguire il codice groovy:

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

Ad esempio, il comando sopra potrebbe essere simile a:

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

Vediamo anche come possiamo usare il comando groovy per eseguire il file .groovy senza compilare:

groovy HelloWorld.groovy

Infine, ecco un altro esempio di stampa di un elenco di elementi con l'indice:

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

Dai un'occhiata ad altri esempi di Groovy nel nostro articolo introduttivo.

6. Clojure

6.1. Panoramica

Clojure è un linguaggio di programmazione funzionale generico. Il linguaggio funziona su JVM e Common Language Runtime di Microsoft. Clojure è ancora un linguaggio compilato, rimane dinamico, poiché le sue funzionalità sono supportate in fase di esecuzione.

I designer di Clojure volevano progettare un Lisp moderno che potesse essere eseguito su JVM. Ecco perché è anche noto come dialetto del linguaggio di programmazione Lisp. Simile a Lisps, Clojure tratta il codice come dati e ha anche un sistema macro.

Alcune importanti caratteristiche di Clojure:

  • Funzionale
  • Digitazione: dinamica, forte, ha iniziato di recente a supportare la digitazione graduale
  • Progettato per la concorrenza
  • Polimorfismo a runtime

6.2. Esempi

A differenza di altri linguaggi JVM, non è così semplice creare un semplice "Hello, World!" programma in Clojure.

Useremo lo strumento Leiningen per eseguire il nostro esempio.

Innanzitutto, creeremo un semplice progetto con modello predefinito utilizzando il seguente comando:

lein new hello-world

Il progetto verrà creato con la seguente struttura di file:

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

Ora dobbiamo aggiornare il file ./project.ctj con il seguente contenuto per impostare il file sorgente principale:

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

Ora siamo pronti per aggiornare il nostro codice per stampare "Hello, World!" in ./src/hello-world/core. file clj:

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

Infine, useremo il comando lein per eseguire il codice sopra, dopo esserci spostati nella directory principale del progetto:

cd hello-world lein run

7. Altre lingue JVM

7.1. Jython

Jython è l'implementazione della piattaforma Java di Python che viene eseguita sulla JVM.

Questo linguaggio è stato inizialmente progettato per consentire la scrittura di applicazioni ad alte prestazioni senza sacrificare l'interattività. Jython è orientato agli oggetti, multi-thread e utilizza il garbage collector di Java per ripulire in modo efficiente la memoria.

Jython include la maggior parte dei moduli che fanno parte del linguaggio Python. Può anche importare e utilizzare qualsiasi classe dalle librerie Java.

Vediamo un rapido "Hello, World!" esempio:

print "Hello, world!"

7.2. JRuby

JRuby è un'implementazione del linguaggio di programmazione Ruby da eseguire su Java Virtual Machine.

Il linguaggio JRuby è ad alte prestazioni e multi-thread, con un'ampia varietà di librerie disponibili da Java e Ruby. Inoltre, combina funzionalità di entrambi i linguaggi come la programmazione orientata agli oggetti e la digitazione a papera.

Stampiamo "Hello, World!" in JRuby:

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

8. Conclusione

In questo articolo, abbiamo studiato molti linguaggi JVM popolari insieme a esempi di codice di base. Questi linguaggi implementano vari paradigmi di programmazione come la tipizzazione orientata agli oggetti, funzionale, statica e dinamica.

Finora mostra che anche con la JVM risalente al 1995, rappresenta ancora una piattaforma molto rilevante e avvincente per i linguaggi di programmazione moderni.