Modificatori di visibilità

Fa parte della sezione Programmazione orientata agli oggetti del percorso Kotlin di Coddy. Lezione 8 di 57.

L'incapsulamento significa che una classe controlla come vengono usati i suoi dati. I modificatori di visibilità decidono chi può vedere un membro. private lo nasconde a tutto ciò che si trova al di fuori della classe, quindi l'unico modo per accedervi è tramite i metodi della classe:

class Account {
    private var balance = 0

    fun deposit(amount: Int) {
        if (amount > 0) balance += amount
    }

    fun report() = "balance: $balance"
}

All'interno di main:

val a = Account()
a.deposit(50)
a.deposit(-999)
println(a.report())
// a.balance = 1_000_000    // errore: impossibile accedere a 'balance': è privato

Output:

balance: 50

Kotlin ha quattro modificatori. Senza uno di essi, una dichiarazione è public, visibile ovunque:

public      // predefinito: visibile ovunque
internal    // visibile nello stesso modulo (app o libreria)
protected   // visibile nella classe e nelle sue sottoclassi
private     // visibile all'interno della classe (o del file, per le dichiarazioni di livello superiore)

Le funzioni helper private mantengono ridotta la superficie pubblica. Chi le chiama vede cosa fa la classe, non come:

class Password(private val text: String) {
    val isStrong: Boolean
        get() = hasDigit() && text.length >= 8

    private fun hasDigit() = text.any { it.isDigit() }
}

All'interno di main:

println(Password("secret123").isStrong)
println(Password("short1").isStrong)

Output:

true
false

Anche le proprietà del costruttore possono avere modificatori: private val memorizza un valore che il codice esterno non può leggere. Nascondere i dati permette a una classe di controllare ogni modifica e di mantenere le proprie regole:

class Locker(private val code: String) {
    private val items = mutableListOf<String>()
    fun store(item: String, code: String): Boolean {
        if (code != this.code) return false
        items.add(item)
        return true
    }
}

Sfida

Facile

Completa la classe Locker(private val code: String). La sua lista items è privata. store(item, code) aggiunge l'elemento solo quando il codice corrisponde e restituisce se l'ha fatto; open(code) restituisce gli elementi uniti con , (oppure empty) quando il codice corrisponde, e wrong code altrimenti.

Il codice fornito legge il codice dell'armadietto e poi i comandi put <code> <item> oppure open <code>. Stampa stored oppure denied per ogni put e il risultato di ogni open.

Il tuo codice va inserito in Locker.kt. Main.kt contiene il codice fornito per l'input/output e non può essere modificato.

Provalo tu

fun main() {
    // Codice di input/output fornito: lascialo così com'è
    val input = generateSequence(::readLine).toList()
    val locker = Locker(input[0])
    for (cmd in input.drop(1)) {
        val p = cmd.split(" ")
        if (p[0] == "put") println(if (locker.store(p[2], p[1])) "stored" else "denied")
        else println(locker.open(p[1]))
    }
}