Modificadores de visibilidad

Parte de la sección Programación orientada a objetos del Journey de Kotlin de Coddy. Lección 8 de 57.

La encapsulación significa que una clase controla cómo se utilizan sus datos. Los modificadores de visibilidad deciden quién puede ver un miembro. private lo oculta de todo lo que está fuera de la clase, por lo que los propios métodos de la clase son la única forma de acceder:

class Account {
    private var balance = 0

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

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

Dentro de main:

val a = Account()
a.deposit(50)
a.deposit(-999)
println(a.report())
// a.balance = 1_000_000    // error: no se puede acceder a 'balance': es privado

Salida:

balance: 50

Kotlin tiene cuatro modificadores. Sin uno, una declaración es public, visible en todas partes:

public      // por defecto: visible en todas partes
internal    // visible en el mismo módulo (app o library)
protected   // visible en la clase y sus subclases
private     // visible dentro de la clase (o archivo, para declaraciones de nivel superior)

Las funciones auxiliares privadas mantienen pequeña la interfaz pública. Quienes llaman ven lo que hace la clase, no cómo:

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

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

Dentro de main:

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

Salida:

true
false

Las propiedades del constructor también aceptan modificadores: private val almacena un valor que el código externo no puede leer. Ocultar los datos es lo que permite que una clase compruebe cada cambio y mantenga sus reglas:

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
    }
}

Desafío

Fácil

Completa la clase Locker(private val code: String). Su lista items es privada. store(item, code) agrega el elemento solo cuando el código coincide y devuelve si lo hizo; open(code) devuelve los elementos unidos con , (o empty) cuando el código coincide, y wrong code en caso contrario.

El código proporcionado lee el código del casillero y, después, los comandos put <code> <item> u open <code>. Imprime stored o denied para cada put y el resultado de cada open.

Tu código va en Locker.kt. Main.kt contiene el código de entrada/salida proporcionado y no se puede editar.

Pruébalo tú mismo

fun main() {
    // Código de entrada/salida suministrado: mantenlo tal como está
    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]))
    }
}