Costruttori di Kotlin

1. Panoramica

In questo tutorial, daremo uno sguardo approfondito ai costruttori in Kotlin.

Cominciamo con un rapido riepilogo del concetto: utilizziamo i costruttori per creare oggetti. Sembrano dichiarazioni di metodo, ma hanno sempre lo stesso nome della classe e non restituiscono nulla.

Per la configurazione di un progetto Kotlin, dai un'occhiata al nostro tutorial introduttivo.

In Kotlin, una classe può avere un costruttore primario e uno o più costruttori secondari aggiuntivi.

Nelle prossime sezioni, esamineremo ogni tipo e concetti associati.

2. Costruttore primario

Il primo modo per creare un oggetto in Kotlin è utilizzare un costruttore principale.

Questa è una parte dell'intestazione della classe. I parametri potrebbero anche essere campi di classe, che inseriamo dopo la dichiarazione di classe.

Diamo un'occhiata a una dichiarazione di classe di base, con due proprietà e un costruttore principale:

class Person constructor(val name: String, val age: Int? = null)

In questo esempio, abbiamo dichiarato le proprietà tramite la parola chiave val . Questo si comporta allo stesso modo delle variabili regolari, con la menzione che le proprietà val sono di sola lettura ( controparte della parola chiave finale Java ).

Se vogliamo modificare il riferimento in un secondo momento, dovremmo invece utilizzare la parola chiave var . Tuttavia, non possiamo omettere il tipo di campo nel costruttore principale, poiché deve essere esplicito.

In alcuni casi, possiamo omettere la parola chiave del costruttore . Questo è obbligatorio solo in due casi: quando usiamo annotazioni, come @Autowired o modificatori di accesso, come private o protected .

Inoltre, possiamo usare i parametri predefiniti di Kotlin nei costruttori.

Successivamente, vediamo come possiamo utilizzare il nostro costruttore principale:

val person = Person("John") val personWithAge = Person("Mark", 22)

Possiamo vedere che il nome di una classe è una chiamata di un costruttore. Non è necessario utilizzare la nuova parola chiave.

Per riferimento, diamo anche un'occhiata all'equivalente Java di una dichiarazione del costruttore:

class PersonJava { final String name; final Integer age; public PersonJava(String name) { this.name = name; this.age = null; } public PersonJava(String name, Integer age) { this.name = name; this.age = age; } }

Come puoi vedere, Java avrebbe bisogno di molto più codice per ottenere lo stesso risultato.

2.1. Costruttori primari sulla JVM

Si noti che il compilatore genererà un costruttore aggiuntivo senza parametri sulla JVM. A questo scopo, creerà un'istanza di un oggetto con valori predefiniti.

In questo modo, Kotlin può funzionare bene con librerie come Jackson o JPA, che utilizzano il costruttore no-args per creare istanze di classe:

class Person(val name: String = "")

3. Inizializzazione delle proprietà dai parametri del costruttore

Gli inizializzatori di proprietà dal corpo della classe possono utilizzare i parametri del costruttore primario.

Trasformiamo il nome nella proprietà upperCaseName :

class Person(val name: String, val age: Int? = null) { val upperCaseName: String = name.toUpperCase() }

Possiamo vedere l'output nella console aggiungendo il secondo blocco di inizializzazione :

init { println("Upper case name is $upperCaseName") }

4. Blocchi inizializzatore

Non possiamo inserire alcun codice nel costruttore principale.

Tuttavia, a volte dobbiamo eseguire del codice di inizializzazione. Un buon posto per questo è un blocco inizializzatore, che è preceduto dalla parola chiave init .

Il blocco inizializzatore viene chiamato dopo il costruttore principale . Possiamo anche accedere ai campi di classe in questo posto.

Una classe può avere uno o più blocchi di inizializzazione .

Aggiungiamo il blocco inizializzatore alla nostra classe Person :

init { println("Hello, I'm $name") if (surname.isEmpty()) { throw IllegalArgumentException("Surname cannot be empty!") } }

Successivamente, quando creiamo un oggetto della classe Person , vedremo nella console:

Hello, I'm John

Vorremmo lanciare IllegalArgumentException per il vuoto cognome.

Quando abbiamo molti blocchi di inizializzazione , verranno eseguiti nello stesso ordine in cui appaiono nel corpo della classe.

5. Costruttore secondario

In una classe Kotlin, possiamo anche dichiarare uno o più costruttori secondari . I costruttori secondari sono preceduti dalla parola chiave del costruttore :

class Car { val id: String val type: String constructor(id: String, type: String) { this.id = id this.type = type } }

E l'utilizzo di base:

fun main(args: Array) { val car = Car("1", "sport") val suvCar = Car("2", "suvCar") } 

Ogni costruttore secondario deve delegare al costruttore primario . Lo faremo con questa parola chiave.

Spostiamo le nostre proprietà nel costruttore principale e modifichiamo il costruttore secondario:

class Car(val id: String, val type: String) { constructor(id: String): this(id, "unknown") }

6. Costruttori ed eredità

Possiamo usare un costruttore principale della superclasse.

Nota che tutte le classi in Kotlin sono definitive per impostazione predefinita. Ciò significa che dovremo aggiungere la parola chiave open in modo da poter ereditare dalla nostra classe Person .

Aggiungiamo una classe Employee che eredita dalla classe Person . Entrambi utilizzano costruttori primari:

class Employee(name: String, val salary: Int): Person(name) 

In questo modo, passiamo un nome al costruttore principale della classe Person . Inoltre, aggiungiamo un nuovo campo chiamato stipendio nella classe Employee .

7. Conclusione

In questo rapido articolo, abbiamo discusso vari modi di creare costruttori nel linguaggio Kotlin. Possiamo istanziare i nostri campi in molti modi diversi, secondo i nostri desideri.

L'implementazione di tutti i nostri esempi può essere trovata nel progetto Github.

Per ulteriori informazioni sulle funzionalità di Kotlin, dai un'occhiata alla nostra introduzione a Kotlin.