Eine Kurzanleitung zu den JVM-Sprachen

1. Einleitung

Neben Java können auf der Java Virtual Machine auch andere Sprachen wie Scala, Kotlin, Groovy und Clojure ausgeführt werden.

In den folgenden Abschnitten werden die beliebtesten JVM-Sprachen auf hoher Ebene vorgestellt.

Natürlich beginnen wir mit dem Vorläufer der JVM-Sprachen - Java.

2. Java

2.1. Überblick

Java ist eine universelle Programmiersprache, die das objektorientierte Paradigma umfasst.

Ein Kernmerkmal der Sprache ist die plattformübergreifende Portabilität. Dies bedeutet, dass auf einer Plattform geschriebene Programme auf jeder Kombination von Software und Hardware mit angemessener Laufzeitunterstützung ausführbar sind. Dies wird erreicht, indem Code zuerst in Bytecode kompiliert wird, anstatt direkt in plattformspezifischen Maschinencode.

Java-Bytecode-Anweisungen sind analog zum Maschinencode, werden jedoch von einer Java Virtual Machine (JVM) interpretiert, die für die Kombination aus Host-Betriebssystem und Hardware spezifisch ist.

Obwohl Java ursprünglich eine objektorientierte Sprache war, hat es begonnen, Konzepte aus anderen Programmierparadigmen wie der funktionalen Programmierung zu übernehmen.

Lassen Sie uns einen kurzen Blick auf einige der Hauptfunktionen von Java werfen:

  • Objektorientierter
  • Stark statisch typisiert
  • Plattformunabhängig
  • Müll gesammelt
  • Multithreaded

2.2. Beispiele

Mal sehen, wie ein einfaches "Hallo Welt!" Beispiel sieht aus wie:

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

In diesem Beispiel haben wir eine Klasse mit dem Namen HelloWorld erstellt und die Hauptmethode definiert, mit der eine Nachricht auf der Konsole gedruckt wird.

Als nächstes verwenden wir den Befehl javac , um den Bytecode zu generieren, der auf einer JVM ausgeführt werden kann:

javac HelloWorld.java

Schließlich führt der Java- Befehl den generierten Bytecode in JVM aus:

java HelloWorld

Weitere Java-Beispiele finden Sie in unserer Liste der Tutorials.

3. Scala

3.1. Überblick

Scala steht für "skalierbare Sprache". Scala ist eine statisch typisierte Sprache, die zwei wichtige Programmierparadigmen kombiniert, nämlich objektorientierte und funktionale Programmierung.

Die Sprache entstand im Jahr 2004, wurde aber in den letzten Jahren immer beliebter.

Scala ist eine reine objektorientierte Sprache, da sie keine Grundelemente unterstützt . Scala bietet die Möglichkeit, Klassen, Objekte, Methoden sowie funktionale Programmierfunktionen wie Merkmale, algebraische Datentypen oder Typklassen zu definieren.

Einige wichtige Merkmale von Scala sind:

  • Funktional, objektorientiert
  • Stark statisch typisiert
  • Algebraische Datentypen
  • Mustervergleich
  • Verbesserte Unveränderlichkeitsunterstützung
  • Faule Berechnung
  • Multithreaded

3.2. Beispiele

Schauen wir uns zunächst dasselbe „Hallo Welt!“ An. Beispiel wie zuvor, diesmal in Scala:

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

In diesem Beispiel haben wir ein Singleton - Objekt mit dem Namen erstellt Hello World und das Hauptverfahren.

Als nächstes können wir zum Kompilieren Scalac verwenden :

scalac HelloWorld.scala

Der Befehl scala führt den generierten Bytecode in JVM aus:

scala HelloWorld

4. Kotlin

4.1. Überblick

Kotlin ist eine statisch typisierte Open-Source-Allzwecksprache, die vom JetBrains-Team entwickelt wurde und die objektorientierten und funktionalen Paradigmen zusammenführt.

Das Hauptaugenmerk bei der Entwicklung von Kotlin lag auf Java-Interoperabilität, Sicherheit (Ausnahmebehandlung), Prägnanz und besserer Werkzeugunterstützung.

Seit der Veröffentlichung von Android Studio 3.0 ist Kotlin eine vollständig unterstützte Programmiersprache von Google auf der Android-Plattform. Es ist auch im Android Studio IDE-Paket als Alternative zum Standard-Java-Compiler enthalten.

Einige wichtige Kotlin-Funktionen:

  • Objektorientiert + funktional
  • Stark statisch typisiert
  • Prägnant
  • Interoperabel mit Java

Unsere Einführung in Kotlin enthält auch weitere Einzelheiten zu den Funktionen.

4.2. Beispiele

Mal sehen, die "Hallo, Welt!" Beispiel in Kotlin:

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

Wir können den obigen Code in eine neue Datei namens helloWorld.kt schreiben.

Dann verwenden wir den Befehl kotlinc , um dies zu kompilieren und einen Bytecode zu generieren, der auf einer JVM ausgeführt werden kann:

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

Die Option -d wird verwendet, um die Ausgabedatei für Klassendateien oder einen .jar- Dateinamen anzugeben . Die -include-Runtime - Option macht die resultierende .jar - Datei in sich geschlossene und runnable durch die Kotlin Laufzeitbibliothek in es enthält.

Anschließend führt der Java- Befehl den generierten Bytecode in JVM aus:

java -jar helloWorld.jar

Sehen wir uns auch ein weiteres Beispiel für das Drucken einer Liste von Elementen mit einer for- Schleife an:

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

5. Groovy

5.1. Überblick

Groovy ist eine objektorientierte, optional typisierte, dynamische domänenspezifische Sprache (DSL) mit Unterstützung für statische Typisierung und statische Kompilierungsfunktionen. Es zielt darauf ab, die Entwicklerproduktivität mit leicht zu erlernender Syntax zu verbessern.

Groovy lässt sich problemlos in jedes Java-Programm integrieren und fügt sofort leistungsstarke Funktionen wie Skriptfunktionen, Metaprogrammierung zur Laufzeit und zur Kompilierungszeit sowie Funktionen zur funktionalen Programmierung hinzu.

Lassen Sie uns einige wichtige Merkmale hervorheben:

  • Objektorientiert mit Funktionsmerkmalen wie Funktionen höherer Ordnung, Currying, Verschlüssen
  • Tippen - Dynamisch, Statisch, Stark, Ente
  • Domänenspezifische Sprache
  • Interoperabilität mit Java
  • Produktivität durch Prägnanz
  • Überlastung des Bedieners

5.2. Beispiele

Schauen wir uns zuerst unser "Hallo Welt!" Beispiel in Groovy:

println("Hello world")

Wir haben den obigen Code in eine neue Datei namens HelloWorld.groovy geschrieben . Jetzt können wir diesen Code auf zwei Arten ausführen: durch Kompilieren und Ausführen oder durch einfaches Ausführen von nicht kompiliertem Code.

Mit dem Befehl groovyc können wir eine .groovy- Datei wie folgt kompilieren :

groovyc HelloWorld.groovy

Dann verwenden wir den Java- Befehl zum Ausführen des groovigen Codes:

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

Der obige Befehl könnte beispielsweise folgendermaßen aussehen:

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

Lassen Sie uns auch sehen, wie wir den Befehl groovy verwenden können , um die .groovy- Datei auszuführen, ohne sie zu kompilieren:

groovy HelloWorld.groovy

Zum Schluss noch ein Beispiel zum Drucken einer Liste von Elementen mit dem Index:

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

Weitere Groovy-Beispiele finden Sie in unserem Einführungsartikel.

6. Clojure

6.1. Überblick

Clojure ist eine universelle funktionale Programmiersprache. Die Sprache läuft sowohl auf JVM als auch auf der Common Language Runtime von Microsoft. Clojure ist immer noch eine kompilierte Sprache, sie bleibt dynamisch, da ihre Funktionen zur Laufzeit unterstützt werden.

Die Clojure-Designer wollten modernes Lisp entwerfen, das auf JVM ausgeführt werden kann. Deshalb wird es auch als Dialekt der Programmiersprache Lisp bezeichnet. Ähnlich wie Lisps behandelt Clojure Code als Daten und verfügt auch über ein Makrosystem.

Einige wichtige Clojure-Funktionen:

  • Funktionell
  • Tippen - Dynamisch, stark, unterstützt seit kurzem das schrittweise Tippen
  • Entwickelt für Parallelität
  • Laufzeitpolymorphismus

6.2. Beispiele

Im Gegensatz zu anderen JVM-Sprachen ist es nicht so einfach, ein einfaches „Hallo Welt!“ Zu erstellen. Programm in Clojure.

Wir werden das Leiningen-Tool verwenden, um unser Beispiel auszuführen.

Zuerst erstellen wir ein einfaches Projekt mit einer Standardvorlage mit dem folgenden Befehl:

lein new hello-world

Das Projekt wird mit folgender Dateistruktur erstellt:

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

Jetzt müssen wir die Datei ./project.ctj mit dem folgenden Inhalt aktualisieren, um die Hauptquelldatei festzulegen :

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

Jetzt werden wir unseren Code aktualisieren, um "Hallo Welt!" Zu drucken. in der ./src/hello-world/core. CLJ-Datei:

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

Schließlich verwenden wir den Befehl lein , um den obigen Code auszuführen, nachdem wir in das Stammverzeichnis des Projekts verschoben haben :

cd hello-world lein run

7. Andere JVM-Sprachen

7.1. Jython

Jython ist die Java-Plattform-Implementierung von Python, die auf der JVM ausgeführt wird.

Diese Sprache wurde ursprünglich entwickelt, um das Schreiben von Hochleistungsanwendungen zu ermöglichen, ohne die Interaktivität zu beeinträchtigen. Jython ist objektorientiert, multithreaded und verwendet den Garbage Collector von Java, um den Speicher effizient zu bereinigen.

Jython enthält die meisten Module, die Teil der Python-Sprache sind. Es kann auch beliebige Klassen aus den Java-Bibliotheken importieren und verwenden.

Mal sehen, ein kurzes "Hallo, Welt!" Beispiel:

print "Hello, world!"

7.2. JRuby

JRuby ist eine Implementierung der Programmiersprache Ruby, die auf der Java Virtual Machine ausgeführt werden soll.

Die JRuby-Sprache ist leistungsstark und multithreaded mit einer Vielzahl verfügbarer Bibliotheken von Java und Ruby. Außerdem werden Funktionen aus beiden Sprachen wie objektorientierte Programmierung und Ententypisierung kombiniert.

Drucken wir "Hallo Welt!" in JRuby:

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

8. Fazit

In diesem Artikel haben wir viele gängige JVM-Sprachen sowie grundlegende Codebeispiele untersucht. Diese Sprachen implementieren verschiedene Programmierparadigmen wie objektorientierte, funktionale, statische und dynamische Typisierung.

Bisher zeigt sich, dass die JVM auch aus dem Jahr 1995 eine hochrelevante und überzeugende Plattform für moderne Programmiersprachen darstellt.