Scala vs. Java: Warum sollte ich Scala lernen?

An der Aussage „Scala ist schwer“ ist zwar etwas Wahres dran, aber die Lernkurve lohnt sich. Einige der komplexeren Funktionen der Sprache (Tupel, Funktionen, Makros, um nur einige zu nennen) erleichtern es dem Entwickler letztendlich, besseren Code zu schreiben und die Leistung durch die Programmierung in Scala zu steigern. Ehrlich gesagt sind wir Programmierer, und wenn wir nicht schlau genug sind, eine Sprache zu lernen, die eine gewisse Komplexität hat, dann sind wir im falschen Geschäft.

Scala ist eine typsichere JVM-Sprache, die sowohl objektorientierte als auch funktionale Programmierung in einer äußerst prägnanten, logischen und außerordentlich leistungsfähigen Sprache vereint. Einige mögen überrascht sein zu wissen, dass Scala nicht ganz so neu ist, wie sie dachten, da es erstmals 2003 eingeführt wurde. Allerdings hat Scala vor allem in den letzten Jahren begonnen, eine bedeutende Anhängerschaft aufzubauen. Was die Frage „Warum Scala?“ aufwirft.

Dieser Artikel untersucht die Vorteile von Scala, insbesondere gegenüber Java (da Scala für die Ausführung in der JVM geschrieben wurde). Scala ist nicht der einzige Versuch, ein „besseres Java“ zu schaffen. Alternativen wie Kotlin und Ceylon sind ebenfalls diesen Weg gegangen, haben sich aber grundsätzlich entschieden, syntaktisch sehr nah an der Java-Sprache selbst zu bleiben, um die Lernkurve zu minimieren. Das mag wie eine großartige Idee erscheinen, aber es ist letztendlich etwas selbstzerstörerisch, da es Sie dazu zwingt, innerhalb einer Reihe genau derselben Java-Paradigmen zu bleiben, die der Grund dafür waren, überhaupt ein „besseres Java“ erstellen zu wollen.

Im Gegensatz dazu wurde Scala speziell mit dem Ziel entwickelt, eine bessere Sprache zu sein und jene Aspekte von Java loszuwerden, die es für den Entwickler als restriktiv, übermäßig langweilig oder frustrierend empfand. Infolgedessen gibt es zwar Codeunterscheidungen und Paradigmenwechsel, die das frühe Erlernen der Scala-Programmierung etwas erschweren können, aber das Ergebnis ist eine viel sauberere und gut organisierte Sprache, die letztendlich einfacher zu verwenden ist und die Produktivität erhöht.

Scala vs. Java: Was ist wirklich komplexer?

Während die Einfachheit der Java-Sprache Teil ihres Erfolgs war, hat sie ironischerweise auch zu ihrer Komplexität beigetragen. Sicher, Sie können fast alles in Java schreiben, aber die dafür erforderlichen Codezeilen können entmutigend sein. Die Programmierung in Scala hingegen ist etwas komplexer aufgebaut. Aber wenn Sie eine etwas komplexere einzelne Codezeile schreiben können, die 20 „einfachere“ Java-Zeilen ersetzt, welche ist wirklich komplexer?

Die Wahrheit ist, dass Java oft einfach viel zu ausführlich ist. In Scala ist der Compiler unglaublich intelligent, sodass der Entwickler die Dinge, auf die der Compiler schließen kann, nicht explizit angeben muss. Vergleichen Sie zum Beispiel dieses einfache „Hello World!“ Programm in Java vs. Scala:

Hallo Welt in Java:

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

Hallo Welt in Scala:

 object HelloScala { def main(args: Array[String]): Unit = { println("Hello World!") } }

Während es hier keinen großen Unterschied zwischen den beiden Sprachen gibt, ist Scala selbst in diesem einfachen Beispiel weniger ausführlich.

Für ein praktischeres Beispiel werfen wir einen Blick auf das Erstellen einer einfachen Liste von Strings:

Java:

 List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list.add("3");

Skala:

 val list = List("1", "2", "3")

Sicherlich gibt es in Java einige Tricks, um den Code etwas zu verkürzen, aber nicht im Standardgebrauch.

Stellen Sie sich nun einen Fall vor, in dem wir eine Liste von Zeichenfolgen haben, die Zahlen sind, aber wir möchten diese Liste in eine Liste von Ganzzahlen konvertieren:

Java:

 List<Integer> ints = new ArrayList<Integer>(); for (String s : list) { ints.add(Integer.parseInt(s)); }

Skala:

 val ints = list.map(s => s.toInt)

Dank der funktionellen Eigenschaften von Scala wird dieser Umbau denkbar einfach.

Ein Klassenbeispiel: Java vs. Scala

Lassen Sie uns noch einen Schritt weiter gehen und die Erstellung von Standard-Beans/Plain Old Java Objects (POJO) in Java und Scala vergleichen.

Zuerst die Java-Version:

 public class User { private String name; private List<Order> orders; public User() { orders = new ArrayList<Order>(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public List<Order> getOrders() { return orders; } public void setOrders(List<Order> orders) { this.orders = orders; } } public class Order { private int id; private List<Product> products; public Order() { products = new ArrayList<Product>(); } public int getId() { return id; } public void setId(int id) { this.id = id; } public List<Product> getProducts() { return products; } public void setProducts(List<Product> products) { this.products = products; } } public class Product { private int id; private String category; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getCategory() { return category; } public void setCategory(String category) { this.category = category; } }

Puh. Lotta-Code.

Jetzt die Scala-Version:

 class User { var name: String = _ var orders: List[Order] = Nil } class Order { var id: Int = _ var products: List[Product] = Nil } class Product { var id: Int = _ var category: String = _ }

Welche Sprache war komplizierter?!

Sind wir fair?

Wenn Sie es bis hierher geschafft haben und ein Java-Programmierer sind, denken Sie vielleicht an dieser Stelle, dass ich einen unfairen Codevergleich mache. Schließlich hält mich nichts davon ab, Variablen in Java öffentlich zu machen und dann die Getter und Setter loszuwerden.

Wenn Sie jedoch an die Gründe für Getter und Setter in Java zurückdenken, dient dies speziell der Zukunftssicherheit. Das heißt, wenn Sie später etwas Logik zum Abrufen oder Setzen von Variablen hinzufügen müssen, müssten Sie diese öffentlichen Variablen neu schreiben, um stattdessen Methoden zu verwenden (weshalb die Verwendung von Gettern und Settern von Anfang an in Java empfohlen wird ). Bei der Scala-Programmierung ist dies jedoch nicht der Fall. Aufgrund des Sprachdesigns bleibt die Abstraktion erhalten, ohne Getter und Setter zu benötigen. Betrachten Sie zum Beispiel diese modifizierte User in Scala, die eine NullPointerException , wenn Sie versuchen, den Namen auf null zu setzen:

 class User { private var _name: String = _ var orders: List[Order] = Nil def name = _name def name_=(name: String) = { if (name == null) { throw new NullPointerException("User.name cannot be null!") } _name = name }

Und Sie können den Namen immer noch so festlegen:

 user.name = "John Doe"

Beachten Sie, dass dadurch die Notwendigkeit entfällt, Methodenzugriffsmethoden vorzukonfigurieren.

Da Scala außerdem Unveränderlichkeit bevorzugt, kann ich dies in Scala noch prägnanter mit Fallklassen schreiben:

 case class User(name: String, orders: List[Order]) case class Order(id: Int, products: List[Product]) case class Product(id: Int, category: String)

Ziemlich verrückt, wie viel weniger Code ich schreiben muss.

Nehmen Sie das Beispiel ein bisschen weiter

Stellen Sie sich nun ein Szenario mit den obigen Klassen vor, in dem ich eine raffinierte kleine Methode in der User hinzufügen möchte, die eine Liste aller Products zurückgibt, die der User bestellt hat:

In der wortreichen Welt von Java:

 public List<Product> getProducts() { List<Product> products = new ArrayList<Product>(); for (Order order : orders) { products.addAll(order.getProducts()); } return products; }

Glücklicherweise hat java.util.List eine addAll -Methode, oder getProducts() wäre in Java eine noch längere gewesen.

In Scala hingegen brauchen wir nur:

 def products = orders.flatMap(o => o.products)

Sie können sehen, wie viel kleiner die Scala-Sprachimplementierung ist. Ja, es mag dem Scala-Neuling komplexer erscheinen, aber sobald Sie die Konzepte dahinter vollständig verstanden haben, wird der Scala-Code viel einfacher aussehen als der Java-Code.

Lassen Sie uns hier noch etwas komplizierter werden. Was ist, wenn wir nur die Products einer bestimmten Category erhalten möchten?

In diesem Fall können wir die Methode addAll in java.util.List nicht nutzen, sodass die Dinge in Java hässlicher werden:

 public List<Product> getProductsByCategory(String category) { List<Product> products = new ArrayList<Product>(); for (Order order : orders) { for (Product product : order.getProducts()) { if (category.equals(product.getCategory())) { products.add(product); } } } return products; }

In Scala bleibt der Code jedoch ziemlich einfach. Wir verwenden einfach flatMap , um die Produktlisten aus jeder Order in einer einzigen Liste zu kombinieren, dann filtern wir, um nur diejenigen einzubeziehen, die der Kategorie entsprechen:

 def productsByCategory(category: String) = orders.flatMap(o => o.products).filter(p => p.category == category)

Dynamisch vs. statisch

In den letzten Jahren hat es sicherlich keinen Mangel an neuen Sprachen gegeben, aber während fast alle anderen, die kürzlich erschienen sind, dynamisch sind, ist Scala statisch typisiert.

Als professioneller Entwickler – obwohl ich viele dynamische Sprachen kenne und verwende – bin ich der Meinung, dass Prüfungen zur Kompilierzeit unglaublich wichtig sind, um soliden Code zu schreiben. In einer dynamischen Sprache können Sie nie sicher sein, dass Ihr Code ausreichend fehlerfrei und robust ist, bis Sie ihn tatsächlich in einer Vielzahl von Szenarien ausführen. Dies kann zu potenziell schwerwiegenden Fehlern im Code führen, die erst erkannt werden, wenn der Code in Produktion ist.

Einpacken

Hoffentlich stapelt dieser Artikel Java vs. Scala genug, um Ihnen einen ersten Eindruck von der Leistungsfähigkeit und den Fähigkeiten von Scala zu vermitteln und Ihren Appetit auf das Erlernen der Sprache zu wecken. Es ist nicht nur eine großartige Sprache, die das Programmieren weniger langweilig und angenehmer machen kann, sondern wird auch von einigen der größten Unternehmen der Welt verwendet (LinkedIn, Twitter, FourSquare, The Guardian, um nur einige zu nennen).

Die Popularität und Nutzung von Scala nimmt rapide zu, wie die ständig steigende Zahl offener Stellen für Scala-Entwickler zeigt. Wenn Sie es noch nicht getan haben, wäre jetzt ein guter Zeitpunkt, um auf der Welle zu reiten und nicht mehr zu fragen: „Warum Scala lernen?“