Contenuto

• Kotlin vs Java, il successivo offre un codice più conciso, senza findViewByIds
• Kotlin è null sicuro per impostazione predefinita
• Funzioni di estensione
• Le coroutine sono cittadini di prima classe
• Non ci sono eccezioni verificate
• Supporto nativo per la delegazione
• Classi di dati
• Cast intelligenti
• Supporto per costruttori
• Nessun supporto per conversioni allargate implicite
• Librerie di elaborazione delle annotazioni con Kotlin
• Intercambiabilità con Java
• Avvolgendo

Java potrebbe essere ancora il primo linguaggio di programmazione che viene in mente quando pensi ad Android, ma non lo fai avere utilizzare Java per lo sviluppo Android. In effetti, Kotlin è ora di Googlepreferitolingua ufficiale per Android!

Per saperne di più su Java, scarica un corso introduttivo gratuito a Java su Make Android Apps.

Oggi Android Studio viene fornito con il supporto Kotlin integrato, quindi la creazione di un progetto Android che comprende il codice Kotlin è facile come selezionare una casella di controllo nella procedura guidata di creazione del progetto di Android Studio. Il supporto è cresciuto per l'opzione troppo nel tempo, al punto che questa decisione ora si riduce principalmente alle preferenze.

Ma se fai il passaggio da Java a Kotlin, che cosa stai guadagnando esattamente? Quali caratteristiche ha Kotlin, che Java non ha e viceversa?

In questo articolo, esamineremo tutte le principali differenze tra Kotlin e Java.

Kotlin vs Java, il successivo offre un codice più conciso, senza findViewByIds

Se confronti una classe Kotlin e una classe Java che stanno eseguendo lo stesso lavoro, la classe Kotlin sarà generalmente molto più concisa, ma c'è un'area in particolare in cui Kotlin può ridurre seriamente la quantità di codice del bollettino che devi scrivere: findViewByIds.

Le estensioni Android di Kotlin ti consentono di importare un riferimento a una vista nel tuo file di attività, a quel punto sarai in grado di lavorare con quella vista come se fosse parte dell'attività. Il risultato? Non dovrai mai più scrivere un altro metodo findViewById!

Prima di poter utilizzare queste estensioni, devi aggiungere un plug-in aggiuntivo al tuo file build.gradle a livello di modulo (applica il plug-in: 'kotlin-android-extensions') ma dopo sei pronto per iniziare a importare Views, per esempio se il tuo file activity_main.xml contenesse un oggetto TextView con l'ID textView, quindi aggiungi alla tua attività quanto segue:

import kotlinx.android.synthetic.main.activity_main.textView

È quindi possibile accedere a questo TextView usando solo il suo ID:

textView.setText ("Hello World")

Questo è tanto più conciso dell'equivalente Java:

TextView text = (TextView) findViewById (R.id.textView); text.setText ("Hello World");

Kotlin è null sicuro per impostazione predefinita

NullPointerExceptions è un'enorme fonte di frustrazione per gli sviluppatori Java. Java consente di assegnare null a qualsiasi variabile, ma se si tenta di utilizzare un riferimento a un oggetto con un valore null, prepararsi a incontrare una NullPointerException!

Leggi anche: Introduzione a Kotiln per Android

In Kotlin, tutti i tipi sono non annullabili (impossibile contenere un valore null) per impostazione predefinita. Se provi ad assegnare o restituire null nel tuo codice Kotlin, allora fallirà in fase di compilazione, quindi nessuna delle seguenti righe verrà compilata:

nome val: String = null

fun getName (): String = null

Se tu veramente vuoi assegnare un valore nullo a una variabile in Kotlin, quindi dovrai contrassegnare esplicitamente quella variabile come nullable, aggiungendo un punto interrogativo dopo il tipo:

numero val: Int? = null

Questo rende quasi impossibile incontrare NullPointerExceptions in Kotlin - in effetti, se incontri questa eccezione, allora è probabile che tu abbia chiesto esplicitamente a Kotlin di lanciarne una, oppure NullPointerException proviene da un codice Java esterno.

Funzioni di estensione

Kotlin offre agli sviluppatori la possibilità di estendere una classe con nuove funzionalità, il che è l'ideale se c'è una classe che hai sempre sentito mancare un metodo importante!

Queste "funzioni di estensione" non sono disponibili in Java, sebbene siano disponibili in altri linguaggi di programmazione che è possibile utilizzare per lo sviluppo Android, come C #.

Leggi il prossimo: Tutorial Java per principianti

Puoi creare una funzione di estensione aggiungendo il prefisso del nome della classe che desideri estendere (come "String") al nome della funzione che stai creando ("styleString"), ad esempio:

fun String.styleString (): String {// Disegna la stringa e poi restituiscila //}

È quindi possibile chiamare questa funzione su istanze della classe estesa, tramite. notazione, come se facesse parte di quella classe:

myString.styleString ()

Le coroutine sono cittadini di prima classe

Ogni volta che si avvia un'operazione a esecuzione prolungata, ad esempio I / O di rete o lavoro intensivo della CPU, il thread chiamante viene bloccato fino al completamento dell'operazione. Poiché Android è a thread singolo per impostazione predefinita, non appena si blocca il thread principale l'interfaccia utente dell'app si bloccherà e rimarrà senza risposta fino al completamento dell'operazione.

In Java, la soluzione è stata tradizionalmente quella di creare un thread in background in cui è possibile eseguire questo lavoro intenso o di lunga durata, ma la gestione di più thread può portare a codice complesso e soggetto a errori e la creazione di un nuovo thread è un'operazione costosa.

Mentre puoi creare thread aggiuntivi in ​​Kotlin, puoi anche usare le coroutine. Le coroutine eseguono attività intense e di lunga durata sospendendo l'esecuzione in un determinato punto senza bloccare il thread e quindi riprendendo questa funzione in un momento successivo, possibilmente su un altro thread. Ciò consente di creare codice asincrono non bloccante sembra sincrono, ed è quindi più chiaro, conciso e leggibile dall'uomo. Le coroutine sono anche impilabili, quindi hanno un utilizzo della memoria inferiore rispetto ai thread e aprono la porta a stili aggiuntivi di programmazione asincrona non bloccante, come async / waitit.

Non ci sono eccezioni verificate

Kotlin non ha verificato le eccezioni, quindi non è necessario catturare o dichiarare alcuna eccezione.

Se questo è qualcosa che ti attira a Kotlin o ti fa venire voglia di rimanere con Java dipenderà dalla tua opinione sulle eccezioni verificate, poiché questa è una caratteristica che divide la comunità di sviluppatori. Se sei stanco di provare / catturare blocchi che ingombrano il tuo codice Java, sarai soddisfatto di questa omissione, tuttavia se scopri che le eccezioni controllate ti incoraggiano a pensare al recupero degli errori e alla fine ti spingono a creare più robusti codice, quindi è più probabile che tu lo veda come un'area in cui Java ha il vantaggio su Kotlin.

Supporto nativo per la delegazione

Kotlin, a differenza di Java, supporta il modello di progettazione "composizione su ereditarietà", tramite una delega di prima classe (a volte nota come delega implicita). La delega è dove un oggetto ricevente delega le operazioni a un secondo oggetto delegato, che è un oggetto helper con il contesto originale.

La delega di classe di Kotlin è un'alternativa all'eredità che consente di utilizzare l'ereditarietà multipla. Nel frattempo, le proprietà delegate di Kotlin aiutano a prevenire la duplicazione del codice, ad esempio se è necessario riutilizzare lo stesso codice per getter e setter di più proprietà, quindi è possibile estrarre questo codice in una proprietà delegata. Il delegato della proprietà deve definire la funzione dell'operatore getValue e, facoltativamente, l'operatore setValue:

delegato di classe {operator fun getValue (...) ... ... ...} operator fun setValue (...) ... ... ...}}

Quindi, quando crei una proprietà, puoi dichiarare che le funzioni getter e setter per questa particolare proprietà sono gestite da un'altra classe:

class MyClass {var proprietà: String di Delegate ()}

Classi di dati

Non è insolito che un progetto abbia più classi che non fanno altro che conservare i dati. In Java, ti ritroverai a scrivere un sacco di codice boilerplate per queste classi, anche se le classi stesse hanno pochissime funzionalità. In genere, è necessario definire un costruttore, campi per memorizzare i dati, le funzioni getter e setter per ciascun campo, oltre alle funzioni hashCode (), equals () e toString ().

In Kotlin, se includi la parola chiave "dati" nella definizione della tua classe, il compilatore eseguirà tutto questo lavoro per te, inclusa la generazione di tutti i getter e setter necessari:

data class Date (var month: String, var day: Int)

Cast intelligenti

In Java, devi spesso controllare il tipo e quindi lanciare un oggetto in situazioni in cui è già chiaro che l'oggetto può essere lanciato.

I cast intelligenti di Kotlin sono in grado di gestire questi cast ridondanti per te, quindi non è necessario trasmettere una dichiarazione se l'hai già verificata con l'operatore "is" di Kotlin. Ad esempio, il compilatore sa che il cast seguente è sicuro:

if (hello is String) {printString (hello)}

Supporto per costruttori

A differenza di Java, una classe Kotlin può avere un costruttore principale e uno o più costruttori secondari, che vengono creati includendoli nella dichiarazione della classe:

costruttore di classe MainActivity (firstName: String) {}

Nessun supporto per conversioni allargate implicite

Kotlin non supporta conversioni allargate implicite per i numeri, quindi i tipi più piccoli non vengono convertiti implicitamente in tipi più grandi. In Kotlin, se si desidera assegnare un valore di tipo Byte a una variabile Int, è necessario eseguire una conversione esplicita, mentre Java supporta le conversioni implicite.

Librerie di elaborazione delle annotazioni con Kotlin

Kotlin supporta tutti i framework e le librerie Java esistenti, inclusi i framework avanzati che si basano sull'elaborazione delle annotazioni, sebbene alcune librerie Java stiano già fornendo estensioni Kotlin, come RxKotlin.

Se vuoi usare una libreria Java che si basa sull'elaborazione delle annotazioni, aggiungerla al tuo progetto Kotlin è leggermente diversa in quanto dovrai specificare la dipendenza usando il Kotlin-Kapt plug-in, quindi utilizzare lo strumento di elaborazione delle annotazioni di Kotlin (kapt) invece di annotationProcessor. Per esempio:

// Applica il plug-in // Applica plug-in: kotlin-kapt // Aggiungi le rispettive dipendenze usando la configurazione di kapt // dipendenze {kapt "com.google.dagger: pugnale-compilatore: $ pugnale-versione" ... ... ...}

Intercambiabilità con Java

Quando si discute se utilizzare Kotlin o Java per lo sviluppo di Android, è necessario tenere presente che esiste una terza opzione: utilizza entrambi. Nonostante tutte le differenze tra le due lingue, Java e Kotlin sono interoperabili al 100%. Puoi chiamare il codice Kotlin da Java e puoi chiamare il codice Java da Kotlin, quindi è possibile avere le classi Kotlin e Java fianco a fianco all'interno dello stesso progetto e tutto sarà comunque compilato.

Questa flessibilità di spostamento tra le due lingue è utile quando inizi a utilizzare Kotlin in quanto ti consente di introdurre Kotlin in un progetto esistente in modo incrementale, ma potresti anche preferire utilizzare entrambe le lingue su base permanente. Ad esempio, potrebbero esserci alcune funzionalità che preferisci scrivere in Kotlin e alcune funzionalità che ritieni più facili da scrivere in Java. Poiché Kotlin e Java si compilano entrambi in bytecode, i tuoi utenti finali non saranno in grado di dire dove finisce il tuo codice Java e inizia il codice Kotlin, quindi non c'è motivo per cui non puoi rilasciare un'app che consiste in Java e Codice Kotlin.

Se vuoi provare Kotlin da solo, finché hai installato Android Studio 3.0 o versione successiva, ci sono alcuni modi per iniziare:

• Crea un nuovo progetto Android Studio. Il metodo più semplice è creare un nuovo progetto e selezionare la casella di controllo "Includi supporto Kotlin" dalla procedura guidata di creazione del progetto.

• Aggiungi una classe Kotlin a una directory esistente. Fai clic tenendo premuto il tasto Ctrl sulla directory in questione, quindi seleziona "File> Nuovo> File / classe Kotlin". Android Studio mostrerà un banner che ti chiede di configurare il tuo progetto per supportare Kotlin; fai clic sul link "Configura" e segui le istruzioni su schermo.

• Converti i file Java esistenti in Kotlin. Puoi eseguire qualsiasi file Java tramite un convertitore Kotlin, facendo clic tenendo premuto il tasto Ctrl sul file e selezionando "Codice> Converti file Java in file Kotlin".

Avvolgendo

Come puoi vedere ci sono molti buoni motivi per preferire Kotlin a Java, tuttavia ci sono un paio di aree in cui Java ha il sopravvento. Forse in particolare: molti sviluppatori Android hanno semplicemente più familiarità con Java a questo punto. Probabilmente il dibattito tra Kotlin e Java non si risolverà presto, con entrambi i loro meriti. Quindi, passerai a Kotlin o ritieni che Java sia ancora l'opzione migliore per lo sviluppo di Android?

Leggi il prossimo: Un'introduzione alla sintassi Java per lo sviluppo Android