KotlinRush: Ist es sinnvoll, weiterhin in Java zu schreiben?

Hallo, JavaRush-Student, bevor Sie ganz in Java versunken sind, möchte ich Ihren Horizont erweitern und die Aufmerksamkeit auf die immer beliebter werdende Kotlin- Sprache lenken ! Kotlin ist eine relativ junge Sprache, die von JetBrains entwickelt wurde . Ja, ja, genau das gleiche Unternehmen, das unsere Lieblings-IDE entwickelt hat: IntelliJ IDEA. Kotlin ist eine JVM-Sprache und vollständig mit Java kompatibel , d. h. Sie können über Kotlin-Code problemlos auf bekannte Java-Bibliotheken zugreifen. Was ist mit Bibliotheken: Kotlin- und Java-Klassen können in einem Paket koexistieren! Kotlin erfreute sich in der Programmiergemeinschaft so großer Beliebtheit, dass Google es als offizielle Entwicklungssprache für Android anerkannte, und in letzter Zeit erfreut sich Kotlin zunehmender Beliebtheit in Unternehmensprojekten. In diesem Artikel möchte ich mehrere Vergleichsbeispiele für in Kotlin und Java geschriebenen Code geben und einige Schlussfolgerungen ziehen. Gehen! Beginnen wir wie immer mit „Hello World“

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

// Kotlin
class Application
fun main(vararg args: String) {
    println("Hello World!")
}

Wenn wir uns das Kotlin-Beispiel ansehen, können wir sofort Folgendes feststellen:

• Es ist nicht erforderlich, am Ende der Zeile ein Semikolon zu schreiben.
• alle Methoden werden durch das Schlüsselwort fun beschrieben ;
• Um eine Zeile zu drucken, reicht nur ein Wort – println() !

Erstellen einer Instanz

// Java (до 10)
final Application application = new Application();

// Kotlin
val application = Application()

Kotlin-Unterschiede:

• Es ist nicht erforderlich, den Typ einer Variablen zu deklarieren, wenn er aus der Instanz klar hervorgeht.
• anstelle des Variablentyps - val (unveränderlich) oder var (veränderbar);
• Sie müssen das neue Schlüsselwort nicht schreiben, um eine Instanz zu erstellen !

Beschreibung der Methoden

// Java
public int sum(int a, int b) {
    return (a + b);
}

// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}

Kotlin-Unterschiede:

• Wenn von einer Methode etwas zurückgegeben werden muss, wird „ :Int “ zur Signatur hinzugefügt, wobei Int der Rückgabetyp ist;
• Beschreibung der Methodenparameter: zuerst der Variablenname, dann der Typ;
• Da der Methodenkörper nur aus einer Zeile besteht, können Sie die Rückgabe weglassen :
  

  fun sum(a: Int, b: Int): Int = (a+b)

Formatierte String-Ausgabe

// Java
public int sum(int a, int b) {
    int result = (a + b);
    System.out.printf("Сумма %d и %d равна %d\n", a, b, result);
    return result;
}

// Kotlin
fun sum(a: Int, b: Int): Int {
    val result = (a + b)
    println("Сумма $a и $b равна $result")
    return result
}

Kotlin unterstützt die String-Interpolation. Verwenden Sie einfach das Symbol „$“ am Anfang der Variablen. Diese Notation verbessert die Sauberkeit und Lesbarkeit des Codes erheblich. Instanzvergleich

// Java
object1.equals(object2)

// Kotlin
object1 == object2

In Kotlin ==wird der Vergleich „ “ für Objekttypen übersetzt in equals! Und um Links zu vergleichen, ===wird „ “ verwendet. Ausnahmen

// Java
public List<String> getFileContent(String file) throws IOException {
    Path path = Paths.get(file);
    return Files.readAllLines(path);
}

// Kotlin
fun getFileContent(file: String): List<String> {
    val path = Paths.get(file)
    return Files.readAllLines(path)
}

In Kotlin gibt es keine geprüften Ausnahmen ; jetzt müssen Sie nicht endlos eine Ausnahme durch die gesamte Anwendung werfen oder mehrstufige Ausnahmen erstellen try-catch. Null Sicherheit

// Java
public class Data {
    String value;

    String render() {
        if (value == null) {
            return "Value: undefined";
        } else {
            return "Value:" + value.toUpperCase();
        }
    }
}

// Kotlin
class Data {
    var value: String? = null
    fun render(): String =
            "Value: ${value?.toUpperCase() ?: "undefined"}"
}

Kotlin hat sich des NPE-Problems angenommen und eine Reihe von Anforderungen eingeführt:

• alle Klassenfelder und Variablen müssen initialisiert werden;
• Sie können „null“ in ein Feld oder eine Variable schreiben, müssen dann aber explizit angeben, dass Ihre Variable Nullable ist (schreiben Sie das „?“-Zeichen);
• Der Elvis-Operator „?:“ funktioniert folgendermaßen: Wenn links Null ist, nehmen Sie, was rechts steht. Wenn in unserem Beispiel die Wertvariable nicht initialisiert ist, wird der Wert „ undefiniert “ angenommen.

Klassenfelder und Zugriff darauf

// Java
public class Data {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
class App {
    void execute() {
           Data data = new Data()
           data.setValue("Foo")
     }
}

// Kotlin
class Data {
    var value: String = ""
}
class App {
    fun execute() {
          val data = Data()
          data.value = "Foo" // Под капотом выполнится data.set("Foo")
     }
}

In Kotlin reicht es aus, einfach ein Feld zu beschreiben und das war’s: Es verfügt bereits über implizite Getter und Setter (Hallo Lombok ), die bei Bedarf jederzeit überschrieben werden können. Gleichzeitig lesen und ändern wir den Wert des Felds, indem wir einfach direkt darauf zugreifen, und unter der Haube heißt es get()|set(). Fahrräder

// Java
void example() {
    for(int i = 1; i <= 10; i++) {
        System.out.println(i);
    }

    for(String line : "a,b,c".split(",")) {
        System.out.println(line);
    }
}

// Kotlin
fun example() {
    for(i in 1..10) {
        println(i)
    }

    for(line in "a,b,c".split(",")) {
        println(line)
    }
}

Kotlin hat eine praktische und einheitliche Syntax zum Durchlaufen von Sequenzen bereitgestellt: Sie verwenden einfach links eine Variable , rechts eine Sequenz und dazwischen das Schlüsselwort „ in “, der Typ wird automatisch durch den Inhalt bestimmt. Singleton

// Java
public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        return ourInstance;
    }

    private Singleton() {
    }
}
class App {
    void execute() {
         Singleton singleton = Singleton.getInstance()
    }
}

// Kotlin
object Singleton {}

class App {
    fun execute() {
          val singleton = Singleton
    }
}

Das bekannte „ Singler “-Muster wird in der Praxis recht häufig verwendet, daher hat Kotlin beschlossen, ein separates Schlüsselwort „ object “ zu erstellen , das anstelle von „ class “ geschrieben wird und bedeutet, dass die Klasse ein Singleton ist; bei Verwendung ist dies nicht einmal der Fall Sie müssen den Konstruktor oder andere Methoden aufrufen! Benannte Methodenparameter und Standardwerte

// Java
void setStatus(String code) {
    setStatus(code, "");
}

void setStatus(String code, String desc) {
    this.code = code;
    this.desc = desc;
}

// Kotlin
fun setStatus(code: String, desc: String = "") {
    this.code = code;
    this.desc = desc;
}

fun execute() {
    setStatus("200")
    setStatus(code = "200", desc = "Ok")
}

Es kommt vor, dass nicht alle Parameter in einer Methode oder einem Konstruktor erforderlich sein müssen, und in Java sind wir es gewohnt, für jede mögliche Kombination von Parametern eine Reihe von Methoden oder Konstruktoren zu erstellen. In Kotlin wurden Standardparameter eingeführt, die es Ihnen ermöglichen, eine Methode zu deklarieren und ihr je nach Situation den erforderlichen Parametersatz zu übergeben. Streams

// Java
String getFirst(List<String> strings, String alpha) {
    return strings.stream()
            .filter(x -> x.startsWith(alpha))
            .findFirst()
            .orElse("");
}

// Kotlin
fun getFirst(strings: List<String>, alpha: String): String {
    return strings.first { it.startsWith(alpha) }
}

Die Einführung von Stream in Java 8 ist zu einer integralen Funktionalität bei der Arbeit mit Sammlungen geworden. In Kotlin wurden Streams noch komfortabler und funktionaler gestaltet: Jede Sammlung verfügt bereits über eine Reihe praktischer, häufig verwendeter Methoden zum Arbeiten mit Daten. Beachten Sie auch den Lambda-Ausdruck in der ersten Methode: Wenn ein Funktionsliteral genau einen Parameter hat, kann seine Deklaration (zusammen mit dem ->) entfernt und als  it bezeichnet werden . Es ist Zeit zum Abschluss ... Ich habe nur einen kleinen, grundlegenden Teil der Funktionalität demonstriert, aber ich bin sicher, dass Sie Kotlin bereits ausprobieren möchten! Aus meiner Erfahrung kann ich folgende Schlussfolgerungen ziehen:

• Für einen Java-Entwickler ist es sehr einfach, die Kotlin-Syntax zu beherrschen und mit dem Schreiben von Code zu beginnen.
• Kotlin ist vollständig mit Java kompatibel und Sie können es bereits in Ihren bestehenden Projekten ausprobieren, beispielsweise in Tests;
• Kotlin-Code ist sauberer und besser lesbar, Sie müssen nicht viele Textbausteine ​​schreiben ;
• IDEA verfügt über einen automatischen Java-zu-Kotlin-Konverter. Sie können vorgefertigten Java-Code nehmen und ihn automatisch in Kotlin konvertieren.
• Ein neues Projekt muss in Kotlin geschrieben werden, da es aus infrastruktureller Sicht dasselbe wie Java ist, aber in Bezug auf die Verwendung besser und bequemer ist!

Wenn Ihnen der Artikel gefallen hat und Sie sich allgemein für eine Ressource zu Java interessieren, kann ich weiter über die Erfahrungen mit der Verwendung von Kotlin in einem echten Unternehmensprojekt schreiben. Nützliche Links:

• Versuchen Sie, online etwas in Kotlin zu schreiben
• Kotlin lernen – eine Reihe und Beschreibung verschiedener interaktiver Beispiele
• Plugin für IDEA für Training mit Validierung (z. B. Mini-JavaRush)
• Offizielle Kotlin-Website
• Russische Kotlin-Site