Kotlin : le classi

Una classe, nella programmazione orientata agli oggetti è un costrutto di un linguaggio di programmazione usato come modello per creare oggetti. Il modello comprende attributi (variabili) e metodi (funzioni membro) che saranno condivisi da tutti gli oggetti creati (istanze) a partire dalla classe. In particolare una classe può contenere:

• Costruttori e blocchi di inizializzazione
• Funzioni (metodi)
• Proprietà (attributi)
• Classi interne e incapsulate
• Dichiarazione di oggetti

In Kotlin, una classe è dichiarata utilizzando la keyword class seguita dall’header e dal corpo compreso tra parentesi graffe. Sia l’header che il corpo sono opzionali. Quindi la sintassi è data da:

class NomeClasse { /* … */ }

Costruttore

In Kotlin, ogni classe può avere un costruttore primario e uno o più costruttori secondari. Il costruttore primario è parte dell’header della classe ed è indicato con la keyword constructor che può anche essere omessa:

class NomeClasse constructor ( firstNameVar : String) { /* … */ }

class NomeClasse ( firstNameVar : String) { /* … */ }

Costruttore Primario

Il costruttore primario non può contenere codice. Il codice da eseguire in fase di inizializzazione della classe deve essere specificato successivamente in un blocco di codice identificato dalla keyword init che può essere ripetuta più volte nel corpo della classe e verrà eseguita nell’ordine indicato. Quindi ad esempio:

class MyClass ( name : String ) {
   val firstProperty = "pippo"
   init {
      println("First initializer block that prints ${name}")
   }
   val secondProperty = "Second property: ${name.length}"
   init {
      println("Second initializer block that prints ${name.length}")
   }
}

dove in fase di inizializzazione scriverà prima il nome passato all’istanza della classe e poi la sua lunghezza. Un parametro di una classe può essere utilizzato anche per inizializzare alcuni attributi della stessa, ad esempio:

class MyClass ( name : String ) {
   val customerKey = name.uppercase()
}

Si può anche dichiarare degli attributi all’interno dei parametri passati alla classe inserendo anche dei default, ad esempio:

class Person(val firstName: String, val lastName: String, var isEmployed: Boolean = true)

Se non specificati esplicitamente, i parametri in ingresso vengono salvate nelle variabili (attributi) costanti sotto forma di val. I parametri in ingresso devono sempre essere tipizzati.

Costruttori Secondari

E’ possibile dichiarare anche costruttori secondari che verranno dichiarati utilizzando la keyword constructor :

class NomeClasse { constructor ( constructorVariable : Int ) { /* … */ } }

Nel caso in cui invece sia presente un costruttore primario allora il secondario deve essere delegato al primo utilizzando la sintassi:

class NomeClasse ( val classVariable : String ) { constructor ( classVariable : String ) : this ( classVariable ) { /* … */ }

La definizione degli attributi via parametri passati alla classe così come l’esecuzione del blocco di inizializzazione della classe vengono eseguiti prima del costruttore secondario anche se il costruttore primario non è definito.  Nel caso in cui in una classe non sia definito ne il costruttore primario ne quello secondario, verrà costruito un costruttore pubblico vuoto senza parametri.

Classi Astratte

Una classe può essere definita come astratta insieme a parte o alla totalità dei suoi membri. Un membro astratto può non essere implementato ma solo dichiarato. Non è necessario annotare le classi ed i metodi astratti con la keyword open . Si può, dall’altro lato, fare l’override di metodi non astratti dichiarati come open anche con membri astratti, ad esempio:

open class Polygon {
    open fun draw() {}
}

abstract class Rectangle : Polygon() {
    abstract override fun draw()
}

Istanza di una classe

Per istanziare una classe si utilizza la seguente sintassi:

val istanzaClasse = MyClass ( parametri )

dove parametri sono i parametri di ingresso alla classe.

Esempio

Un esempio di utilizzo delle classi è riportato in seguito:

class Stats {

	var myName = "gatto"

	init {
	   println("welcome on Stats class first init $myName")
	}

	init {
	   myName = "pluto"
	   println("welcome on Stats class second init $myName")
	}

	constructor ( name : String ) {
	    myName = name
		println("welcome on Stats class constructor $myName")
	}

	constructor ( number : Int ) {
		println("welcome on Stats class constructor $number")
	}
	
}

class Math ( val myNumber : Int ) {

   constructor ( number : Int, bool : Boolean ) : this ( number ) {
		println("the boolean is : $bool")
		println("the number is : $myNumber")
   }
   
   constructor ( name : String ) : this (7) {
		println("the string is : $name")
		println("the number is : $myNumber")
   }
 }

fun main() {
  println("Hello Kotlin/Native!")
  val myStats = Stats(3)
  val myStats2 = Stats("cane")
  val myMath = Math(5, false)
  val myMath2 = Math("topo")
}