streamalism.org

1. Inleiding

Naast Java kunnen andere talen op de Java Virtual Machine worden uitgevoerd, zoals Scala, Kotlin, Groovy, Clojure.

In de volgende secties zullen we de meest populaire JVM-talen op hoog niveau bekijken.

Natuurlijk beginnen we met de voorloper van JVM-talen - Java.

2. Java

2.1. Overzicht

Java is een programmeertaal voor algemene doeleinden die het objectgeoriënteerde paradigma omarmt.

Een kernkenmerk van de taal is de portabiliteit op verschillende platforms, wat betekent dat programma's die op één platform zijn geschreven, uitvoerbaar zijn op elke combinatie van software en hardware met voldoende runtime-ondersteuning. Dit wordt bereikt door code eerst in bytecode te compileren, in plaats van rechtstreeks in platformspecifieke machinecode.

Java-bytecode-instructies zijn analoog aan de machinecode, maar ze worden geïnterpreteerd door een Java Virtual Machine (JVM) die specifiek is voor het hostbesturingssysteem en de hardware-combinatie.

Hoewel van oorsprong een objectgeoriënteerde taal, is Java begonnen met het overnemen van concepten uit andere programmeerparadigma's, zoals functioneel programmeren.

Laten we een korte blik werpen op enkele van de belangrijkste kenmerken van Java:

• Objectgeoriënteerd
• Sterk statisch getypeerd
• Platformonafhankelijk
• Vuilnis verzameld
• Meerdradig

2.2. Voorbeelden

Laten we eens kijken hoe een simpele "Hallo, wereld!" voorbeeld ziet eruit als:

openbare klasse HelloWorld {openbare statische leegte hoofd (String [] args) {System.out.println ("Hallo, wereld!"); }}

In dit voorbeeld hebben we een klasse gemaakt met de naam Hallo Wereld en definieerde de belangrijkste methode die een bericht op de console afdrukt.

De volgende, we zullen de Javac commando om de bytecode te genereren die kan worden uitgevoerd op een JVM:

javac HelloWorld.java

Tenslotte, de Java commando voert de gegenereerde bytecode uit op JVM:

java HelloWorld

Bekijk onze lijst met tutorials voor meer Java-voorbeelden.

3. Scala

3.1. Overzicht

Scala staat voor "schaalbare taal". Scala is een statisch getypeerde taal die twee belangrijke programmeerparadigma's combineert, namelijk objectgeoriënteerd en functioneel programmeren.

De taal is ontstaan ​​in 2004 maar is de laatste jaren populairder geworden.

Scala is een pure objectgeoriënteerde taal als het ondersteunt geen primitieven. Scala biedt de mogelijkheid om klassen, objecten en methoden te definiëren, samen met functionele programmeerfuncties zoals eigenschappen, algebraïsche gegevenstypen of typeklassen.

Enkele belangrijke kenmerken van Scala zijn:

• Functioneel, objectgericht
• Sterk statisch getypeerd
• Algebraïsche gegevenstypen
• Patroonaanpassing
• Verbeterde ondersteuning van onveranderlijkheid
• Luie berekening
• Meerdradig

3.2. Voorbeelden

Laten we eerst eens kijken naar hetzelfde "Hallo, wereld!" voorbeeld zoals eerder, dit keer in Scala:

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

In dit voorbeeld hebben we een singleton-object gemaakt met de naam Hallo Wereld en de hoofd methode.

Vervolgens kunnen we gebruiken om dit te compileren scalac:

scalac HelloWorld.scala

De scala commando voert de gegenereerde bytecode uit op JVM:

scala HelloWorld

4. Kotlin

4.1. Overzicht

Kotlin is een statisch getypeerde, open-source taal voor algemeen gebruik, ontwikkeld door het JetBrains-team, dat de objectgeoriënteerde en functionele paradigma's samenbrengt.

De belangrijkste focus bij het ontwikkelen van Kotlin was Java-interoperabiliteit, veiligheid (afhandeling van uitzonderingen), beknoptheid en betere toolingondersteuning.

Sinds de release van Android Studio 3.0 is Kotlin een volledig ondersteunde programmeertaal van Google op het Android Platform. Het is ook opgenomen in het Android Studio IDE-pakket als alternatief voor de standaard Java-compiler.

Enkele belangrijke kenmerken van Kotlin:

• Objectgericht + Functioneel
• Sterk statisch getypeerd
• Beknopt
• Interoperabel met Java

Onze inleiding tot Kotlin bevat ook meer details over de functies.

4.2. Voorbeelden

Laten we eens kijken naar de "Hallo, wereld!" voorbeeld in Kotlin:

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

We kunnen de bovenstaande code schrijven in een nieuw bestand met de naam helloWorld.kt.

Dan, we zullen de kotlinc commando om dit te compileren en genereert bytecode die kan worden uitgevoerd op een JVM:

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

De -d optie wordt gebruikt om het uitvoerbestand aan te geven voor klasse bestanden of een .pot bestandsnaam. De -include-runtime optie maakt het resulterende .pot bestand op zichzelf staand en uitvoerbaar door de Kotlin-runtimebibliotheek erin op te nemen.

Dan de Java commando voert de gegenereerde bytecode uit op JVM:

java -jar helloWorld.jar

Laten we ook een ander voorbeeld bekijken van het afdrukken van een lijst met items met een voor lus:

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

5. Groovy

5.1. Overzicht

Groovy is een objectgeoriënteerde, optioneel getypeerde, dynamische domeinspecifieke taal (DSL), met ondersteuning voor statisch typen en statische compilatiemogelijkheden. Het is gericht op het verbeteren van de productiviteit van ontwikkelaars, met een gemakkelijk te leren syntaxis.

Groovy kan eenvoudig worden geïntegreerd met elk Java-programma en voegt onmiddellijk krachtige functies toe, zoals scriptmogelijkheden, runtime en compilatietijd meta-programmering en functionele programmeerfuncties.

Laten we een paar belangrijke kenmerken uitlichten:

• Objectgeoriënteerd met functionele kenmerken zoals functies van hogere orde, currying, sluitingen
• Typen - Dynamisch, statisch, sterk, eend
• Domeinspecifieke taal
• Interoperabiliteit met Java
• Productiviteit door beknoptheid
• Operator overbelast

5.2. Voorbeelden

Laten we eerst eens kijken naar onze "Hallo, wereld!" voorbeeld in Groovy:

println ("Hallo wereld")

We hebben de bovenstaande code geschreven in een nieuw bestand met de naam HelloWorld.groovy. Nu we kunnen deze code op twee manieren uitvoeren: door te compileren en vervolgens uit te voeren of door gewoon niet-gecompileerde code uit te voeren.

We kunnen een .groovy bestand met behulp van de groovyc commando als volgt:

groovyc HelloWorld.groovy

Vervolgens gebruiken we de Java commando voor het uitvoeren van de groovy code:

java -cp \ embeddable \ groovy-all-.jar ;. Hallo Wereld

De bovenstaande opdracht kan er bijvoorbeeld als volgt uitzien:

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

Laten we ook kijken hoe we de groovy commando om het .groovy bestand zonder te compileren:

groovy HelloWorld.groovy

Ten slotte is hier nog een voorbeeld van het afdrukken van een lijst met items met de index:

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

Bekijk meer Groovy-voorbeelden in ons introductieartikel.

6. Clojure

6.1. Overzicht

Clojure is een functionele programmeertaal voor algemene doeleinden. De taal werkt zowel op JVM als op Microsoft's Common Language Runtime. Clojure is nog steeds een gecompileerde taal, het blijft dynamisch, aangezien de functies tijdens runtime worden ondersteund.

De ontwerpers van Clojure wilden moderne Lisp ontwerpen die op JVM kan draaien. Daarom staat het ook bekend als een dialect van de programmeertaal Lisp. Net als Lisps behandelt Clojure code als gegevens en heeft het ook een macrosysteem.

Enkele belangrijke Clojure-kenmerken:

• Functioneel
• Typen - Dynamisch, sterk, is onlangs begonnen met het ondersteunen van geleidelijk typen
• Ontworpen voor gelijktijdigheid
• Runtime polymorfisme

6.2. Voorbeelden

In tegenstelling tot andere JVM-talen is het niet zo eenvoudig om het eenvoudige "Hallo, wereld!" programma in Clojure.

We zullen de Leiningen-tool gebruiken om ons voorbeeld uit te voeren.

Eerst maken we een eenvoudig project met een standaardsjabloon met behulp van de volgende opdracht:

lein nieuwe hallo-wereld

Het project wordt gemaakt met de volgende bestandsstructuur:

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

Nu moeten we het ./project.ctj bestand met de volgende inhoud om het hoofdbronbestand in te stellen:

(defproject hallo-wereld "0.1.0-SNAPSHOT": hoofd hallo-world.core: afhankelijkheden [[org.clojure / clojure "1.5.1"]])

Nu zijn we klaar om onze code bij te werken om "Hallo, wereld!" in de ./src/hello-world/core.clj-bestand:

(ns hallo-world.core) (defn -main [& args] (println "Hallo, wereld!"))

Ten slotte gebruiken we de lein commando om de bovenstaande code uit te voeren, na het verplaatsen naar de hoofdmap van het project:

cd hallo-wereld lein run

7. Andere JVM-talen

7.1. Jython

Jython is de Java-platformimplementatie van Python die draait op de JVM.

Deze taal was oorspronkelijk ontworpen om het schrijven van krachtige applicaties mogelijk te maken zonder in te boeten aan interactiviteit. Jython is objectgeoriënteerd, multi-threaded en gebruikt Java's garbage collector om het geheugen efficiënt op te schonen.

Jython bevat de meeste modules die deel uitmaken van de Python-taal. Het kan ook alle klassen uit de Java-bibliotheken importeren en gebruiken.

Laten we een korte "Hallo wereld!" voorbeeld:

print "Hallo wereld!"

7.2. JRuby

JRuby is een implementatie van de programmeertaal Ruby voor gebruik op de Java Virtual Machine.

De JRuby-taal is hoge prestaties en multi-threaded, met een grote verscheidenheid aan beschikbare bibliotheken van Java en Ruby. Het combineert ook functies uit beide talen, zoals objectgeoriënteerd programmeren en ducktyping.

Laten we "Hallo wereld!" in JRuby:

vereisen "java" stringHello = "Hallo wereld" zet "# {stringHello.to_s}"

8. Conclusie

In dit artikel hebben we veel populaire JVM-talen bestudeerd, samen met basiscodevoorbeelden. Deze talen implementeren verschillende programmeerparadigma's zoals objectgeoriënteerd, functioneel, statisch typen en dynamisch typen.

Tot nu toe laat het zien dat zelfs met de JVM die teruggaat tot 1995, het nog steeds een zeer relevant en aantrekkelijk platform is voor moderne programmeertalen.