Modificadores de Visibilidade

Parte da seção Programação Orientada a Objetos do Journey de Kotlin da Coddy. Lição 8 de 57.

Encapsulamento significa que uma classe controla como seus dados são usados. Os modificadores de visibilidade decidem quem pode ver um membro. private o oculta de tudo que está fora da classe, então os próprios métodos da classe são a única forma de acessá-lo:

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    // erro: não é possível acessar 'balance': ele é privado

Saída:

balance: 50

Kotlin tem quatro modificadores. Sem um deles, uma declaração é public, visível em todos os lugares:

public      // padrão: visível em todos os lugares
internal    // visível no mesmo módulo (app ou biblioteca)
protected   // visível na classe e em suas subclasses
private     // visível dentro da classe (ou arquivo, para declarações de nível superior)

Funções auxiliares privadas mantêm a superfície pública pequena. Quem chama vê o que a classe faz, não como:

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)

Saída:

true
false

As propriedades do construtor também aceitam modificadores: private val armazena um valor que o código externo não pode ler. Ocultar dados é o que permite que uma classe verifique cada alteração e mantenha suas regras:

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

Desafio

Fácil

Complete a classe Locker(private val code: String). A lista items é privada. store(item, code) adiciona o item somente quando o código corresponde e retorna se isso aconteceu; open(code) retorna os itens unidos por , (ou empty) quando o código corresponde, e wrong code caso contrário.

O código fornecido lê o código do locker e, em seguida, os comandos put <code> <item> ou open <code>. Ele imprime stored ou denied para cada put e o resultado de cada open.

Seu código deve estar em Locker.kt. Main.kt contém o código fornecido de entrada/saída e não pode ser editado.

Experimente você mesmo

fun main() {
    // Código de entrada/saída fornecido: mantenha-o 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]))
    }
}