Guide rapide des langages JVM

1. Introduction

Outre Java, d'autres langages peuvent fonctionner sur la machine virtuelle Java comme Scala, Kotlin, Groovy, Clojure.

Dans les sections suivantes, nous examinerons de manière approfondie les langages JVM les plus populaires.

Bien sûr, nous allons commencer par le précurseur des langages JVM - Java.

2. Java

2.1. Aperçu

Java est un langage de programmation généraliste intégrant le paradigme orienté objet.

Une caractéristique essentielle du langage est la portabilité multiplateforme , ce qui signifie que les programmes écrits sur une seule plate-forme sont exécutables sur n'importe quelle combinaison de logiciel et de matériel avec un support d'exécution adéquat. Ceci est réalisé en compilant d'abord le code en bytecode, au lieu de directement en code machine spécifique à la plate-forme.

Les instructions de bytecode Java sont analogues au code machine, mais elles sont interprétées par une machine virtuelle Java (JVM) spécifique au système d'exploitation hôte et à la combinaison matérielle.

Bien qu'à l'origine un langage orienté objet, Java a commencé à adopter des concepts d'autres paradigmes de programmation comme la programmation fonctionnelle.

Jetons un coup d'œil à certaines des principales fonctionnalités de Java:

  • Orienté objet
  • Fortement typé statiquement
  • Indépendant de la plateforme
  • Collecte des ordures
  • Multithread

2.2. Exemples

Voyons comment un simple "Hello, World!" exemple ressemble à:

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

Dans cet exemple, nous avons créé une classe nommée HelloWorld et défini la méthode main qui imprime un message sur la console.

Ensuite, nous utiliserons la commande javac pour générer le bytecode qui peut être exécuté sur une JVM:

javac HelloWorld.java

Enfin, la commande java exécute le bytecode généré sur JVM:

java HelloWorld

Pour plus d'exemples Java, consultez notre liste de tutoriels.

3. Scala

3.1. Aperçu

Scala signifie «langage évolutif». Scala est un langage à typage statique qui combine deux paradigmes de programmation importants, à savoir la programmation orientée objet et fonctionnelle.

La langue est née en 2004 mais est devenue plus populaire ces dernières années.

Scala est un pur langage orienté objet car il ne prend pas en charge les primitives . Scala offre la possibilité de définir des classes, des objets, des méthodes ainsi que des fonctionnalités de programmation fonctionnelles telles que des traits, des types de données algébriques ou des classes de types.

Quelques caractéristiques importantes de Scala sont:

  • Fonctionnel, orienté objet
  • Fortement typé statiquement
  • Types de données algébriques
  • Correspondance de motif
  • Prise en charge améliorée de l'immuabilité
  • Calcul paresseux
  • Multithread

3.2. Exemples

Tout d'abord, jetons un œil au même "Hello, World!" exemple comme avant, cette fois dans Scala:

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

Dans cet exemple, nous avons créé un objet singleton nommé HelloWorld et la méthode main .

Ensuite, pour compiler ceci, nous pouvons utiliser scalac :

scalac HelloWorld.scala

La commande scala exécute le bytecode généré sur JVM:

scala HelloWorld

4. Kotlin

4.1. Aperçu

Kotlin est un langage open source à usage général, typé statiquement, développé par l'équipe JetBrains , qui réunit les paradigmes orientés objet et fonctionnels.

Lors du développement de Kotlin, l'objectif principal était l'interopérabilité Java, la sécurité (gestion des exceptions), la concision et une meilleure prise en charge des outils.

Depuis la sortie d'Android Studio 3.0, Kotlin est un langage de programmation entièrement pris en charge par Google sur la plate-forme Android. Il est également inclus dans le package IDE d'Android Studio en tant qu'alternative au compilateur Java standard.

Quelques caractéristiques importantes de Kotlin:

  • Orienté objet + fonctionnel
  • Fortement typé statiquement
  • Concis
  • Interopérable avec Java

Notre introduction à Kotlin contient également plus de détails sur les fonctionnalités.

4.2. Exemples

Voyons le "Hello, World!" exemple à Kotlin:

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

Nous pouvons écrire le code ci-dessus dans un nouveau fichier appelé helloWorld.kt.

Ensuite, nous utiliserons la commande kotlinc pour compiler ceci et générer un bytecode qui peut être exécuté sur une JVM:

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

L' option -d est utilisée pour indiquer le fichier de sortie des fichiers de classe ou un nom de fichier .jar . L' option -include-runtime rend le fichier .jar résultant autonome et exécutable en y incluant la bibliothèque d'exécution Kotlin.

Ensuite, la commande java exécute le bytecode généré sur JVM:

java -jar helloWorld.jar

Voyons également un autre exemple d'impression d'une liste d'éléments à l'aide d'une boucle for :

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

5. Groovy

5.1. Aperçu

Groovy est un langage dynamique spécifique au domaine (DSL) orienté objet, typé facultativement , avec prise en charge des capacités de typage statique et de compilation statique. Il vise à améliorer la productivité des développeurs, avec une syntaxe facile à apprendre.

Groovy s'intègre facilement à n'importe quel programme Java et ajoute immédiatement des fonctionnalités puissantes, telles que des capacités de script, une méta-programmation d'exécution et de compilation et des fonctionnalités de programmation fonctionnelle.

Soulignons quelques fonctionnalités importantes:

  • Orienté objet avec des fonctionnalités telles que les fonctions d'ordre supérieur, le curry, les fermetures
  • Dactylographie - Dynamique, statique, fort, canard
  • Langue spécifique au domaine
  • Interopérabilité avec Java
  • Productivité par concision
  • Surcharge de l'opérateur

5.2. Exemples

Tout d'abord, voyons notre "Hello, World!" exemple dans Groovy:

println("Hello world")

Nous avons écrit le code ci-dessus dans un nouveau fichier appelé HelloWorld.groovy . Maintenant, nous pouvons exécuter ce code de deux manières: en compilant puis en exécutant ou en exécutant simplement du code non compilé.

Nous pouvons compiler un fichier .groovy en utilisant la commande groovyc comme suit:

groovyc HelloWorld.groovy

Ensuite, nous utiliserons la commande java pour exécuter le code groovy:

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

Par exemple, la commande ci-dessus pourrait ressembler à:

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

Voyons également comment nous pouvons utiliser la commande groovy pour exécuter le fichier .groovy sans compiler:

groovy HelloWorld.groovy

Enfin, voici un autre exemple d'impression d'une liste d'éléments avec l'index:

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

Jetez un œil à d'autres exemples Groovy dans notre article d'introduction.

6. Clojure

6.1. Aperçu

Clojure est un langage de programmation fonctionnel à usage général. Le langage fonctionne sur JVM ainsi que sur le Common Language Runtime de Microsoft. Clojure est encore un langage compilé, il reste dynamique, car ses fonctionnalités sont supportées à l'exécution.

Les concepteurs de Clojure voulaient concevoir un Lisp moderne qui peut fonctionner sur JVM. C'est pourquoi il est également connu comme un dialecte du langage de programmation Lisp. Semblable à Lisps, Clojure traite le code comme des données et dispose également d'un système de macros.

Quelques caractéristiques importantes de Clojure:

  • Fonctionnel
  • Saisie - Dynamique, Forte, a récemment commencé à prendre en charge la saisie progressive
  • Conçu pour la concurrence
  • Polymorphisme d'exécution

6.2. Exemples

Contrairement à d'autres langages JVM, il n'est pas si simple de créer un simple "Hello, World!" programme dans Clojure.

Nous utiliserons l'outil Leiningen pour exécuter notre exemple.

Tout d'abord, nous allons créer un projet simple avec un modèle par défaut à l'aide de la commande suivante:

lein new hello-world

Le projet sera créé avec la structure de fichiers suivante:

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

Nous devons maintenant mettre à jour le fichier ./project.ctj avec le contenu suivant pour définir le fichier source principal:

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

Nous sommes maintenant prêts à mettre à jour notre code pour imprimer "Hello, World!" dans le ./src/hello-world/core. fichier clj:

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

Enfin, nous utiliserons la commande lein pour exécuter le code ci-dessus, après avoir déplacé vers le répertoire racine du projet:

cd hello-world lein run

7. Autres langages JVM

7.1. Jython

Jython est l'implémentation de la plate-forme Java de Python qui s'exécute sur la JVM.

Ce langage a été initialement conçu pour permettre l'écriture d'applications hautes performances sans sacrifier l'interactivité. Jython est orienté objet, multi-thread et utilise le garbage collector de Java pour nettoyer efficacement la mémoire.

Jython inclut la plupart des modules qui font partie du langage Python. Il peut également importer et utiliser toutes les classes des bibliothèques Java.

Voyons un rapide "Hello, World!" exemple:

print "Hello, world!"

7.2. JRuby

JRuby est une implémentation du langage de programmation Ruby à exécuter sur la machine virtuelle Java.

Le langage JRuby est haute performance et multi-thread, avec une grande variété de bibliothèques disponibles de Java et Ruby. En outre, il combine des fonctionnalités des deux langages comme la programmation orientée objet et le typage canard.

Imprimons "Hello, World!" à JRuby:

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

8. Conclusion

Dans cet article, nous avons étudié de nombreux langages JVM populaires ainsi que des exemples de code de base. Ces langages implémentent divers paradigmes de programmation tels que le typage orienté objet, fonctionnel, statique, le typage dynamique.

Jusqu'à présent, cela montre que même avec la JVM datant de 1995, elle reste une plate-forme très pertinente et convaincante pour les langages de programmation modernes.