Nel tutorial odierno, discuteremo i concetti di Programmazione Orientata agli Oggetti in Kotlin. Approfondiremo la classe Kotlin nei dettagli, esaminando anche costruttori, modificatori di accesso e classi astratte di Kotlin.
Classe Kotlin
Una classe è una definizione che raggruppa funzioni e proprietà. Le classi in Kotlin vengono definite utilizzando la parola chiave class seguita dal nome della classe. Il corpo va all’interno delle parentesi graffe.
class FirstClass {
}
Un’istanza della classe viene istanziata nel modo seguente:
val firstClass = FirstClass()
var new = FirstClass() //here new is the name of the var.
Contrariamente a Java, new non è una parola chiave in Kotlin. Le classi per impostazione predefinita sono finali in Kotlin. Quindi, l’equivalente delle definizioni di cui sopra in Java sarebbe qualcosa del genere:
public final class FirstClass {
}
Pertanto, per impostazione predefinita le classi in Kotlin non sono ereditabili. Per rendere una classe non finale, è necessario aggiungere la parola chiave open.
open class Me{
}
La notazione open consente ad altri di ereditare da questa classe.
Esempio di Classe Kotlin
Creiamo una classe con alcune funzioni e una proprietà. Vedremo come accedere alle funzioni e alle proprietà di quella classe. Inoltre, vedremo come impostare le proprietà dei membri.
class User {
var loggedIn: Boolean = false
val cantChangeValue = "Hi"
fun logOn() {
loggedIn = true
}
fun logOff() {
loggedIn = false
}
}
fun main(args: Array<String>) {
val user = User()
println(user.loggedIn) //false
user.logOn()
println(user.loggedIn) //true
user.logOff()
println(user.loggedIn) //false
user.cantChangeValue = "Hey" //won't compile. Can't modify a final variable.
}
La funzione main appartiene alla classe Test.kt. Per accedere ai membri e alle funzioni, dobbiamo utilizzare l’operatore punto. Una proprietà val non può essere impostata di nuovo utilizzando un operatore punto.
Inizializzazione Kotlin
Il blocco di inizializzazione di Kotlin è definito come mostrato di seguito.
class User {
init{
print("Class instance is initialised.")
}
var loggedIn: Boolean = false
val cantChangeValue = "Hi"
fun logOn() {
loggedIn = true
}
fun logOff() {
loggedIn = false
}
}
Il codice all’interno del blocco init è il primo ad essere eseguito quando la classe viene istanziata. Il blocco init viene eseguito ogni volta che la classe viene istanziata, con qualsiasi tipo di costruttore come vedremo dopo. Nella classe possono essere scritti più blocchi di inizializzazione. Verranno eseguiti sequenzialmente come mostrato di seguito.
class MultiInit(name: String) {
init {
println("First initializer block that prints ${name}")
}
init {
println("Second initializer block that prints ${name.length}")
}
}
fun main(args: Array) {
var multiInit = MultiInit("Kotlin")
}
//Segue è stampato nella console di log.
//Primo blocco di inizializzazione che stampa Kotlin
//Secondo blocco di inizializzazione che stampa 6
Le classi Kotlin permettono di stampare le proprietà nella dichiarazione stessa utilizzando la funzione also come mostrato di seguito.
class MultiInit(name: String) {
val firstProperty = "First property: $name".also(::println)
init {
println("First initializer block that prints ${name}")
}
val secondProperty = "Second property: ${name.length}".also(::println)
init {
println("Second initializer block that prints ${name.length}")
}
}
fun main(args: Array) {
var multiInit = MultiInit("Kotlin")
}
//Segue viene stampato.
//Prima proprietà: Kotlin
//Primo blocco di inizializzazione che stampa Kotlin
//Seconda proprietà: 6
//Secondo blocco di inizializzazione che stampa 6
Costruttore Kotlin
I costruttori Kotlin sono funzioni speciali dei membri utilizzate per inizializzare le proprietà. I costruttori in Kotlin sono scritti e strutturati in modo diverso rispetto a Java. Per impostazione predefinita, una classe ha un costruttore vuoto come mostrato di seguito:
class Student {
var name: String
val age : Int
init {
name = "Anupam"
age = 24
}
init {
name = "Anupam Chugh"
//età = 26
}
}
fun main(args: Array) {
val student = Student()
println("${student.name} age is ${student.age}")
student.name = "Your"
//studente.età = 26 //non compila. L'età è val
println("${student.name} age is ${student.age}")
}
//Il seguente viene stampato sulla console:
//Anupam Chugh età è 24
//La tua età è 24
Costruttori primari
I costruttori primari in Kotlin sono definiti nell’intestazione della classe stessa come mostrato di seguito.
class User(var name: String, var isAdmin: Boolean) {
init {
name = name + " @ JournalDev.com"
println("Author Name is $name. Is Admin? $isAdmin")
}
}
La definizione dei costruttori primari va all’interno dell’intestazione della classe. Abbiamo definito i tipi di proprietà (val/var) nel costruttore stesso. Nota: A meno che non sia indicato come var, per impostazione predefinita, gli argomenti del costruttore sono val.
class User(name: String, isAdmin: Boolean)
Nel codice sopra, sia il nome che isAdmin non possono essere riassegnati. In alternativa, possiamo anche assegnare gli argomenti del costruttore alle proprietà dei membri nella classe come mostrato di seguito.
class User(name: String, val isAdmin: Boolean) {
var username = name
val _isAdmin = isAdmin
init {
username= username + " @ JournalDev.com"
println("Author Name is $name. Is Admin? $_isAdmin")
}
}
fun main(args: Array) {
var user = User("Anupam",false)
user.isAdmin = true //won't compile since isAdmin is val
user._isAdmin = true //won't compile. Same reason.
user = User("Pankaj",true)
}
//Il seguente viene stampato nella console di log.
//Nome autore è Anupam. È amministratore? falso
//Nome autore è Pankaj. È amministratore? vero
Valori Predefiniti del Costruttore Kotlin
Kotlin ci consente di specificare valori predefiniti direttamente nel costruttore, come mostrato di seguito.
class User(name: String, var website: String = "JournalDev") {
init {
println("Author $name writes at $website")
}
init {
website = website + ".com"
println("Author $name writes at $website")
}
}
fun main(args: Array) {
var user = User("Anupam","JournalDev")
user = User("Pankaj","JournalDev")
}
//Quanto segue viene stampato sulla console:
//L'autore Anupam scrive su JournalDev
//L'autore Anupam scrive su JournalDev.com
//L'autore Pankaj scrive su JournalDev
//L'autore Pankaj scrive su JournalDev.com
Costruttori Secondari
I costruttori secondari sono scritti all’interno del corpo della classe, preceduti dalla parola chiave constructor. L’esempio seguente ne dimostra l’utilizzo.
class Student {
var name: String
val age : Int
constructor(name: String, age: Int)
{
this.name = name
this.age = age
}
fun printDetails()
{
println("Name is $name and Age is $age")
}
}
fun main(args: Array) {
var student = Student("Anupam", 24)
student.printDetails()
}
//Quanto segue viene stampato sulla console:
//Il nome è Anupam e l'età è 24
L’uso più comune dei costruttori secondari avviene nelle sottoclassi quando è necessario inizializzare la classe in modi diversi. Se la classe contiene un costruttore primario, il costruttore secondario deve fare riferimento ad esso nella sua dichiarazione. La dichiarazione avviene utilizzando la parola chiave this.
class Student(var name: String, val age: Int) {
var skill: String
init {
skill = "NA"
}
constructor(name: String, age: Int, skill: String) : this(name, age) {
this.skill = skill
}
fun printDetails() {
if (skill.equals("NA"))
println("Name is $name and Age is $age")
else
println("Name is $name and Age is $age Skill is $skill")
}
}
//Quanto segue viene stampato nella console di log:
//Il nome è Anupam e l'età è 24
//Il nome è Anupam e l'età è 24 Skill is Kotlin
Il blocco init viene utilizzato per inizializzare la proprietà membro skill. Il costruttore secondario delega al costruttore primario utilizzando : this.
Getter e Setter personalizzati
Fino ad ora abbiamo accesso e modificato le proprietà in una classe usando l’operatore punto sull’istanza della classe. Utilizziamo la sintassi set e get per vedere come possiamo personalizzare l’accesso.
class Name{
var post: String = "default"
set(value) {if(!post.isNotEmpty()) {
throw IllegalArgumentException(" Enter a valid name")
}
field = value
print(value)
}
}
fun main(args: Array<String>) {
var name = Name()
name.post = "Kotlin Classes"
name.post = ""
name.post = "Kotlin Data Classes Our Next Tutorial"
}
Di seguito viene stampato nella console di log:
Kotlin Classes
Exception in thread "main" java.lang.IllegalArgumentException: Enter a valid name
at Name.setPost(Test.kt:16)
at TestKt.main(Test.kt:78)
La variabile field nel setter salva il valore precedente. Aggiungiamo un getter.
class Name{
var post: String = "default"
set(value) {if(!post.isNotEmpty()) {
throw IllegalArgumentException(" Enter a valid name")
}
field = value
}
get() {
return field.capitalize()
}
}
fun main(args: Array) {
var name = Name()
name.post = "kotlin classes"
println(name.post)
name.post = "kotlin data Classes our next Tutorial"
println(name.post)
}
// Di seguito viene stampato:
// Classi Kotlin
// Classi di dati Kotlin il nostro prossimo Tutorial
capitalize() rende maiuscola la prima lettera della stringa. Nota: se la proprietà è un val, il metodo set non verrà compilato.
Modificatore di visibilità Kotlin
- Pubblico : Qualsiasi classe, funzione, proprietà, interfaccia o oggetto che ha questo modificatore è visibile e può essere accesso da qualsiasi punto.
- Privato: Una classe/funzione definita con questo modificatore può essere accessibile solo all’interno dello stesso file. Un membro/proprietà in una classe/funzione con questo modificatore può essere accessibile solo all’interno di quel blocco.
- Protetto: Questo modificatore è lo stesso del privato, tranne che permette la visibilità e l’accesso all’interno delle sottoclassi.
- Interno: Una classe/interfaccia/funzione con questo modificatore è accessibile solo all’interno dello stesso modulo.
I modificatori di visibilità sono applicabili anche ai costruttori. Assegnare un modificatore a un costruttore primario richiede di specificare la parola chiave constructor insieme al costruttore nell’intestazione della classe.
class Student private constructor (var name: String, val age: Int) {
var skill: String
init {
skill = "NA"
}
constructor(name: String, age: Int, skill: String) : this(name, age) {
this.skill = skill
}
fun printDetails() {
if (skill.equals("NA"))
println("Name is $name and Age is $age")
else
println("Name is $name and Age is $age Skill is $skill")
}
}
fun main(args: Array) {
var student = Student("Anupam",24,"Kotlin")
student.printDetails()
}
//prints
//Il nome è Anupam e l'età è 24. Le capacità sono in Kotlin
I costruttori privati non possono essere chiamati al di fuori della classe. Nel codice sopra, possiamo istanziare la classe in una funzione diversa solo utilizzando il costruttore secondario.
Classe Astratta Kotlin
Come in Java, la parola chiave abstract è utilizzata per dichiarare classi astratte in Kotlin. Una classe astratta non può essere istanziata. Tuttavia, può essere ereditata dalle sottoclassi. Per default, i membri di una classe astratta sono non astratti a meno che non sia specificato diversamente.
abstract class Person(name: String) {
init {
println("Abstract Class. init block. Person name is $name")
}
abstract fun displayAge()
}
class Teacher(name: String): Person(name) {
var age : Int
init {
age = 24
}
override fun displayAge() {
println("Non-abstract class displayAge function overridden. Age is $age")
}
}
fun main(args: Array) {
val person = Teacher("Anupam")
person.displayAge()
}
//Il seguente è stampato nella console.
//Classe astratta. Blocco init. Il nome della persona è Anupam
//Classe non astratta. L'età è 24
Nota: Le classi astratte sono per default open. Quindi aggiungere un modificatore open per consentire la sottoclassificazione non è necessario. La parola chiave override viene utilizzata per sovrascrivere un metodo nella sottoclasse. Abbiamo coperto le basi delle classi Kotlin in questo tutorial. C’è ancora molto altro come Classi Dati, Classi Sigillate, Ereditarietà, ecc. Li affronteremo nei prossimi tutorial. Riferimenti: Documentazione Kotlin
Source:
https://www.digitalocean.com/community/tutorials/kotlin-class-constructor