KotlinRush: ha senso continuare a scrivere in Java?

Ciao studente JavaRush, prima che tu sia completamente assorbito da Java, vorrei espandere i tuoi orizzonti e attirare l'attenzione sul sempre più popolare linguaggio Kotlin ! Kotlin è un linguaggio abbastanza giovane sviluppato da JetBrains . Sì, sì, la stessa azienda che ha sviluppato il nostro IDE preferito: IntelliJ IDEA. Kotlin è un linguaggio JVM ed è completamente compatibile con Java , ovvero dal codice Kotlin puoi accedere facilmente alle librerie Java familiari. E per quanto riguarda le librerie: le classi Kotlin e Java possono coesistere in un unico pacchetto! Kotlin era così popolare tra la comunità dei programmatori che Google lo riconobbe come linguaggio di sviluppo ufficiale per Android e recentemente Kotlin ha iniziato a guadagnare popolarità nei progetti aziendali. In questo articolo vorrei fornire diversi esempi comparativi di codice scritto in Kotlin e Java e trarre alcune conclusioni. Andare! Iniziamo, come al solito, con "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!")
}

Osservando l'esempio di Kotlin, possiamo subito notare quanto segue:

• non è necessario scrivere un punto e virgola alla fine della riga;
• tutti i metodi sono descritti dalla parola chiave fun ;
• Per stampare una riga è sufficiente una sola parola: println() !

Creazione di un'istanza

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

// Kotlin
val application = Application()

Differenze di Kotlin:

• non è necessario dichiarare il tipo di una variabile se è chiaro dall'istanza;
• invece del tipo di variabile - val (immutabile) o var (modificabile);
• Non è necessario scrivere la nuova parola chiave per creare un'istanza !

Descrizione dei metodi

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

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

Differenze di Kotlin:

• se qualcosa deve essere restituito da un metodo, alla firma viene aggiunto “ : Int ”, dove Int è il tipo restituito;
• descrizione dei parametri del metodo: prima il nome della variabile, poi il tipo;
• poiché il corpo del metodo è costituito da una sola riga, puoi omettere il ritorno :
  

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

Output di stringa formattata

// 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 supporta l'interpolazione delle stringhe, basta usare il simbolo "$" all'inizio della variabile. Questa notazione migliora notevolmente la pulizia e la leggibilità del codice. Confronto di istanze

// Java
object1.equals(object2)

// Kotlin
object1 == object2

In Kotlin, il confronto " ==" per i tipi di oggetto viene tradotto in equals! E per confrontare i collegamenti, ===viene utilizzato " ". Eccezioni

// 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)
}

Non ci sono eccezioni controllate in Kotlin ; ora non è necessario lanciare un'eccezione all'infinito attraverso l'intera applicazione o creare eccezioni multi-livello try-catch. Sicurezza nulla

// 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 si è occupato del problema NPE e ha introdotto una serie di requisiti:

• tutti i campi e le variabili della classe devono essere inizializzati;
• Puoi scrivere “null” in un campo o in una variabile, ma poi devi dire esplicitamente che la tua variabile è Nullable (scrivi il segno “?”);
• L'operatore Elvis "?:" funziona così: se c'è Null a sinistra, prendi quello che c'è a destra. Nel caso del nostro esempio, quando la variabile valore non è inizializzata, verrà preso il valore “ undefinito ”.

Campi della classe e accesso ad essi

// 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 è sufficiente descrivere semplicemente un campo e il gioco è fatto: ha già getter e setter impliciti (ciao lombok ), che possono essere sovrascritti in qualsiasi momento se lo si desidera. Allo stesso tempo, leggiamo e modifichiamo il valore del campo semplicemente accedendovi direttamente, e di nascosto si chiama get()|set(). Cicli

// 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 ha fornito una sintassi comoda e uniforme per attraversare le sequenze: basta utilizzare una variabile a sinistra , una sequenza a destra e la parola chiave " in " nel mezzo, il tipo viene determinato automaticamente dal contenuto. 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
    }
}

Il familiare pattern " singler " viene utilizzato abbastanza spesso nella pratica, quindi Kotlin ha deciso di creare una parola chiave separata " object ", che viene scritta al posto di " class " e significa che la classe è un singleton; quando viene utilizzata, non devi nemmeno è necessario chiamare il costruttore o qualsiasi altro metodo! Parametri del metodo denominato e valori predefiniti

// 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")
}

Succede che non tutti i parametri in un metodo o costruttore devono essere richiesti, e in Java siamo abituati a creare un insieme di metodi o costruttori per ogni possibile combinazione di parametri. In Kotlin sono stati introdotti parametri predefiniti, che consentono di dichiarare 1 metodo e passargli il set di parametri richiesto a seconda della situazione. Flussi

// 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) }
}

L'introduzione dello stream in Java 8 è diventata una funzionalità integrale quando si lavora con le raccolte. In Kotlin, i flussi sono stati resi ancora più comodi e funzionali: ogni raccolta dispone già di una serie di metodi convenienti e utilizzati di frequente per lavorare con i dati. Inoltre, nota l'espressione lambda all'interno del primo metodo: se una funzione letterale ha esattamente un parametro, la sua dichiarazione può essere rimossa (insieme a ->) e  denominata . È ora di concludere... ho dimostrato solo una piccola parte basilare delle funzionalità, ma sono sicuro che vorrai già provare Kotlin! Dalla mia esperienza posso trarre le seguenti conclusioni:

• È molto semplice per uno sviluppatore Java padroneggiare la sintassi di Kotlin e iniziare a scrivere codice;
• Kotlin è completamente compatibile con Java e puoi già provarlo nei tuoi progetti esistenti, ad esempio nei test;
• Il codice Kotlin è più pulito e leggibile, non è necessario scrivere un mucchio di boilerplate ;
• IDEA ha un convertitore automatico da Java a Kotlin, puoi prendere il codice Java già pronto e convertirlo automaticamente in Kotlin;
• è necessario scrivere un nuovo progetto in Kotlin, perché dal punto di vista infrastrutturale è uguale a Java, ma in termini di utilizzo è migliore e più conveniente!

Se l'articolo ti è piaciuto e sei interessato in generale a una risorsa su Java, posso continuare a scrivere dell'esperienza di utilizzo di Kotlin in un progetto aziendale reale. Link utili:

• Prova a scrivere qualcosa in Kotlin online
• Imparare Kotlin: una serie e una descrizione di vari esempi interattivi
• Plugin per IDEA per formazione con validazione (tipo mini-JavaRush)
• Sito ufficiale di Kotlin
• Sito russo di Kotlin