C'è qualche differenza tra Kotlin e Java?

Ciao a tutti. Voglio dirti alcune cose basilari sulla lingua Kotlin, che saranno utili per i principianti. Si dà il caso che ora sarà difficile entrare nello sviluppo Android con un solo linguaggio: la maggior parte dei nuovi progetti inizia a essere scritta in Kotlin, la maggior parte dei progetti già pronti sono scritti in Java. Al momento ho 4 progetti al lavoro: due in Kotlin e due in Java (uno grande principale e tre piccoli per uso interno). Quando l'azienda ha deciso di scrivere nuovi progetti in Kotlin, questa decisione mi è sembrata strana. Perché mescolare lingue diverse? Lascia che qualcun altro scriva in Kotlin, perché ne abbiamo bisogno? Ma non c’era via d’uscita, quindi ho deciso di provare una nuova lingua e ho iniziato a studiarla. Il primo codice, ovviamente, era scritto interamente in stile Java, il che accrebbe ulteriormente l'equivoco: perché ho bisogno di un nuovo linguaggio? Ma man mano che l'ho usato ho trovato sempre più vantaggi e ora (scrivo su Kotlin da quasi 2 anni) posso dire che Kotlin è più conveniente nello sviluppo Android. Voglio mostrare alcune sfumature che non saranno ovvie per qualcuno che ha deciso di iniziare a imparare Kotlin dopo Java. Permettetemi anche di ricordarvi che Android utilizza Java 8, mentre la versione attuale è la 14. Quindi, prima - Variabili : Java:

        Int a = 1;	
	String s = "test";

Kotlin:

        val a = 1
        var b = 2
        val c: Int
        val d = "test"

Esistono due tipi di variabili in Kotlin: val (sola lettura) e var (lettura-scrittura). Si consiglia di utilizzare val quando possibile. Non è necessario dichiarare il tipo di una variabile se la variabile è già stata inizializzata. Secondo: if/else, cambia istruzioni : quanto spesso usi questa catena di istruzioni in Java:

if (вариант 1)
{...}
else if (вариант 2)
{...}
...
else
{...}

O così:

switch(выражениеДляВыбора) {
        case (meaning 1):
                Код1;
                break;
        case (meaning 2):
                Код2;
                break;
...
        case (meaning N):
                КодN;
                break;
        default:
                КодВыбораПоУмолчанию;
                break;
        }

In Kotlin, l'operatore quando viene utilizzato per tali espressioni (anche se può essere utilizzato anche if/else):

val x = 5
val result = when(x) {
        0, 1 -> "cool"
        2 -> "bad"
        5 -> "normal"
        else -> "error"
}
System.out.println(result)

Qui non solo abbiamo seguito la catena delle condizioni, ma abbiamo anche assegnato immediatamente l'intera espressione alla variabile risultato, risparmiando così parecchie righe di codice. Tuttavia, se hai solo due opzioni in un ramo, ti consiglio di utilizzare il solito if..else. Il momento della costruzione sarà più breve solo di tre opzioni. Andiamo avanti - Costruttori . È una favola qui. Basta confrontare il codice in Java e Kotlin. Giava:

public class Person {
    
    private String firstName;
    private String lastName;
    private int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Kotlin:

 class Person(private val firstName: String, 
             private val lastName: String, 
             private var age: Int) {
}

Può sembrare che qualcosa sia rimasto incompiuto nel codice Kotlin. Ma no, si tratta di due codici identici in lingue diverse. Scopriamolo un po'. In Kotlin il costruttore può essere scritto direttamente nel corpo del nome della classe (ma se vuoi puoi farlo alla vecchia maniera, come in Java). Quindi, abbiamo scritto tre variabili, in Java abbiamo creato un costruttore, getter e un setter per la variabile age. In Kotlin, come ricordiamo, la variabile val è di sola lettura e quindi il setter per queste variabili non è disponibile (Kotlin implementa i getter-setter dietro le quinte). La variabile var consente di utilizzare un setter. Di conseguenza, abbiamo scritto quasi in una riga la stessa cosa che in Java richiedeva più di una dozzina di righe. Qui consiglio di leggere di più sulle classi di dati in Kotlin. Ma non è tutto ciò in cui i costruttori di Kotlin sono bravi. Ma cosa succede se hai bisogno di due costruttori? E se fossero tre? In Java sarebbe simile a questo:

public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

public Person(String firstName) {
        this.firstName = firstName;
    }

Niente di complicato, solo tanti designer quanti ne servivano, ecco cosa hanno fatto. In Kotlin puoi cavartela con un solo costruttore. Come? È semplice: valori predefiniti.

class Person(private val firstName: String,
             private val lastName: String? = null,
             private var age: Int = 5) {
}

Abbiamo assegnato valori predefiniti nel costruttore e ora chiamarli sarà simile a questo:

Person(firstName = "Elon", lastName = "Mask", age = 45)
Person(firstName = "Elon", age = 45)
Person(firstName = "Elon", lastName = "Mask")

Potrebbe sorgere la domanda: cos'è questo:

private val lastName: String? = null

Quali sono questi altri punti interrogativi? Sì, se il valore può essere null, allora viene impostato ?C'è anche un'opzione come questa - !!(se la variabile non può accettare null). Leggilo tu stesso, è tutto semplice. E passiamo al punto successivo. Estensioni . Questo è uno strumento molto interessante in Kotlin che non è disponibile in Java. A volte in un progetto utilizziamo metodi template che si ripetono in molte classi. Ad esempio, in questo modo:

Toast.makeText(this, "hello world :)", Toast.LENGTH_SHORT).show();

In Kotlin possiamo estendere una classe:

fun Context.toast(message: CharSequence) = Toast.makeText(this, message, Toast.LENGTH_SHORT).show()

E poi usarlo in questo modo in tutto il progetto:

context?.toast("hello world")

Abbiamo creato un'estensione per la classe Context. E ora, ovunque sia disponibile il contesto, sarà disponibile il suo nuovo metodo di brindisi. Questo può essere fatto per qualsiasi classe: String, Fragment, le tue classi personalizzate, non ci sono restrizioni. E l'ultimo punto che esamineremo è Lavorare con le stringhe . Tutto è semplice qui. In Java è scritto così:

String s = "friends";
int a = 5;
System.out.println("I have" + a + s + "!");

È più facile in Kotlin:

val s = "friends"
val a = 5
println("I have $a $s!")

Queste sono le sfumature in cui mi sono imbattuto all'inizio dello studio di Kotlin, spero che questo ti possa aiutare.