Skip to content

4. Classes, interfaces, data classes

4.1. Objetos por meio de exemplos

4.1.1. Visão geral

Vamos agora explorar a programação orientada a objetos por meio de exemplos. Um objeto é uma entidade que contém dados que definem seu estado (chamados de campos, atributos, propriedades etc.) e funções (chamadas de métodos). Um objeto é criado com base em um modelo chamado classe. Por exemplo, uma classe chamada [C1] declara duas propriedades — [var p1: Type1] e [var p2: Type2] — e dois métodos — [fun m3(...): Type3 { ... }] e [fun m4(...): Type4 { ... }], todos delimitados pelas chaves da declaração [class C1 { ... }].

A partir da classe [C1], podemos criar muitos objetos, como [o1], [o2], … Todos terão as propriedades [p1], [p2], … e os métodos [m3], [m4], … No entanto, terão valores diferentes para suas propriedades [pi], cada um tendo, assim, seu próprio estado. Se [o1] é um objeto do tipo [C1], [o1.p1] refere-se à propriedade [p1] de [o1], e [o1.m3(...)] refere-se à chamada do método [m3] de [o1].

Vamos considerar um primeiro modelo de objetos: a classe [Person].

4.1.2. Um programa composto de vários arquivos

Nos exemplos do capítulo anterior, um programa cabia em um único arquivo-fonte. A partir de agora, um programa pode consistir em vários arquivos-fonte: por exemplo, uma classe por arquivo, mais o programa principal. Diferentemente do Java, o Kotlin não exige nenhuma relação entre o nome de um arquivo e as classes que ele contém: um arquivo pode conter várias classes e funções de alto nível. A convenção — que seguiremos — é, no entanto, colocar uma classe importante em um arquivo que leve seu nome: a classe *[Person] está no arquivo *[Person.kt].

Os programas deste capítulo estão reunidos no projeto Gradle [04-classes], estruturado como o do capítulo anterior ([03-basics]): cada programa é um pacote dentro do diretório [src/main/kotlin]. O programa de vários arquivos que vamos estudar é o pacote [persons]:

1
2
3
4
04-classes/src/main/kotlin/
  persons/
    Person.kt       the Person class
    Main.kt         the main program

Os dois arquivos começam com a linha [package persons]: pertencem ao mesmo pacote e podem ser vistos um pelo outro sem uma instrução de importação. O arquivo [Main.kt] contém a função de nível superior [main]; o compilador a coloca em uma classe JVM com o nome do arquivo, [MainKt], cujo nome completo é [persons.MainKt]. Esse é o nome fornecido ao Gradle para executar o programa:

> gradlew -q run -Pmain=persons.MainKt
[Jean, Dupont, 30]

O Gradle compila todos os arquivos do projeto e, em seguida, executa o método [main] da classe especificada. No IntelliJ IDEA, basta clicar no triângulo verde exibido na margem, ao lado da função [main]. O compilador grava um arquivo [.class] (contendo o código intermediário, o “bytecode” da JVM) para cada classe: neste caso, [persons/Person.class] e [persons/MainKt.class], na pasta [build] do projeto.

4.1.3. Definição da classe Person

A definição da classe [Person] no arquivo-fonte [Person.kt] será a seguinte:

package persons

class Person {
    // propriedades privadas
    private var firstName = ""
    private var lastName = ""
    private var age = 0

    // método
    fun initialize(p: String, n: String, age: Int) {
        this.firstName = p
        this.lastName = n
        this.age = age
    }

    // método
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • linha 1: a classe pertence ao pacote [persons]. Os pacotes serão discutidos mais adiante neste capítulo;
  • linha 3: a classe não é precedida por nenhuma palavra-chave de visibilidade; ela é pública e pode ser usada por todas as outras classes. Em Kotlin, [public] é a visibilidade padrão;
  • Linhas 5–7: as três propriedades da classe. A palavra-chave [var] indica que elas são mutáveis (a palavra-chave [val] as tornaria somente leitura). Kotlin exige que uma propriedade seja inicializada (aqui com a string vazia e 0): diferentemente do Java, não há valores padrão implícitos ([null], 0, [false]). Os tipos das propriedades, [String] e [Int], são inferidos a partir desses valores iniciais, assim como ocorre com uma variável local;
  • linhas 10–13: um método que define o estado do objeto;
  • linhas 17–18: um método que exibe o estado do objeto.

Aqui temos a definição de uma classe e, portanto, de um tipo de dados. Quando criamos variáveis desse tipo, nos referimos a elas como objetos ou instâncias da classe. Uma classe é, portanto, um template a partir do qual objetos são construídos. Por convenção, o nome de uma classe começa com letra maiúscula ([Person]), enquanto o nome de uma propriedade ou de um método começa com letra minúscula ([firstName], [initialize]).

Kotlin usa o termo “propriedades” em vez de “campos”: veremos um pouco adiante que uma propriedade é um campo acompanhado de seus métodos getter e setter, de forma semelhante às propriedades do C#. Uma propriedade privada, como a mostrada aqui, é simplesmente um campo. Os membros de uma classe podem ser dados (propriedades) ou métodos (funções). Esses membros podem ser acompanhados por uma das seguintes palavras-chave:

Palavra-chave
Acesso
[private]
Um membro privado é acessível apenas pelos métodos da própria classe
[protected]
Um membro protegido é acessível pelos métodos da classe e pelos de suas classes derivadas (veja o conceito de herança adiante). Diferentemente do Java, ele não é acessível a partir de outras classes do pacote
[internal]
Um membro internal é acessível por qualquer método do mesmo módulo, isto é, o conjunto de arquivos compilados juntos (um projeto ou subprojeto Gradle, um módulo do IntelliJ IDEA)
[public]
Um membro público é acessível por qualquer método, esteja ele definido ou não dentro da classe. Esse é o nível de acesso padrão quando nenhuma palavra-chave é especificada

Em geral, os dados de uma classe são declarados privados, enquanto seus métodos são públicos. Isso significa que o usuário de um objeto (o programador):

  • não terá acesso direto aos dados privados do objeto;
  • poderá chamar os métodos públicos do objeto, inclusive aqueles que dão acesso a seus dados privados.

A ordem em que os membros são declarados é arbitrária. Observe que o nível de acesso padrão é público, diferentemente do Java, em que o padrão é package-private: em Kotlin, é preciso escrever explicitamente [private] para tornar um membro privado. Kotlin não tem acesso de “pacote”; o acesso [internal], no nível do módulo, cumpre essa função.

As palavras-chave [private], [internal] e [public] também se aplicam a declarações de nível superior (classes, funções e propriedades definidas fora de qualquer classe). Uma declaração de nível superior [private] é visível apenas dentro de seu próprio arquivo.

4.1.4. O método initialize

Qual é o papel do método [initialize]? Como [lastName], [firstName] e [age] são membros privados da classe [Person], uma instrução como [p1.firstName = "Jean"], escrita no programa principal, é inválida. O compilador a rejeita:

1
2
3
Main.kt:5:8: error: cannot access 'var firstName: String': it is private in 'persons.Person'.
    p1.firstName = "Jean"
       ^^^^^^^^^

A mensagem indica o arquivo, a linha e a coluna do erro ([5:8]) e, em seguida, o destaca com acentos circunflexos. No IntelliJ IDEA, o erro é sublinhado em vermelho assim que é digitado, e o Gradle exibe a mesma mensagem, precedida por [e:] e pelo caminho completo do arquivo. A mensagem está em inglês: o compilador Kotlin não fornece traduções para o francês de suas mensagens. Precisamos inicializar um objeto do tipo [Person] por meio de um método público. Essa é a finalidade do método [initialize]. Escreveremos [p1.initialize("Jean", "Dupont", 30)]. Essa sintaxe é válida porque [initialize] é publicamente acessível.

4.1.5. Criação de um objeto: sem o operador new

No entanto, ainda falta algo. O objeto precisa ser criado. No programa [Main.kt], a expressão [Person()] cria um objeto do tipo [Person]: a classe é “chamada” como uma função. Kotlin não tem um operador new , ao contrário de Java e C#. O objeto criado ainda não está inicializado: suas propriedades têm seus valores padrão, que são a string vazia para [lastName] e [firstName], e 0 para [age].

A declaração [val p1 = Person()] declara [p1] como uma referência a esse objeto. Se declararmos a variável sem inicializá-la, [val p1: Person], e depois escrevermos[p1.initialize("Jean", "Dupont", 30)]`, estaremos chamando o método [initialize] em um objeto que não existe, e o compilador relata o erro: a variável [p1] não recebeu nenhum valor.

1
2
3
Main.kt:5:5: error: variable 'p1' must be initialized.
    p1.initialize("Jean", "Dupont", 30)
    ^^

Em Java, você pode escrever [Person p1 = null;] para indicar que a variável ainda não referencia nenhum objeto; a chamada [p1.initialize(...)] é aceita pelo compilador e causa uma exceção [NullPointerException] em tempo de execução. Como vimos no capítulo anterior, Kotlin distingue entre tipos que permitem o valor [null] e tipos que não o permitem. O tipo [Person] não o permite:

1
2
3
Main.kt:4:22: error: null cannot be a value of a non-null type 'Person'.
    val p1: Person = null
                     ^^^^

O tipo *[Person?]* o aceita, mas o compilador rejeita então uma chamada direta de método:

1
2
3
Main.kt:5:7: error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'Person?'.
    p1.initialize("Jean", "Dupont", 30)
      ^

É preciso escrever [p1?.initialize(...)], que chama o método somente se [p1] não for [null], ou [p1!!.initialize(...)], que informa ao compilador que [p1] não é [null]. Neste último caso, se a asserção for falsa, a exceção Java é lançada em tempo de execução:

1
2
3
4
> gradlew -q run -Pmain=persons.MainKt
Exception in thread "main" java.lang.NullPointerException
    at persons.MainKt.main(Main.kt:5)
    at persons.MainKt.main(Main.kt)

A maioria dos erros que o Java detecta em tempo de execução é, portanto, detectada pelo compilador Kotlin. Para fazer [p1] referenciar um objeto, escrevemos [val p1 = Person()]. Agora que [p1] se refere a um objeto, a instrução de inicialização desse objeto, [p1.initialize("Jean", "Dupont", 30)], é válida.

4.1.6. A palavra-chave this

Vejamos o código do método [initialize]:

1
2
3
4
5
    fun initialize(p: String, n: String, age: Int) {
        this.firstName = p
        this.lastName = n
        this.age = age
    }

A instrução [this.firstName = p] significa que a propriedade [firstName] do objeto atual ([this]) recebe o valor [p]. A palavra-chave [this] refere-se ao objeto atual: aquele sobre o qual o método é executado. Como sabemos disso? Vejamos como o objeto referenciado por [p1] é inicializado no programa chamador: [p1.initialize("Jean", "Dupont", 30)]. É o método [initialize] do objeto [p1] que é chamado. Quando, dentro desse método, o objeto [this] é referenciado, ele na verdade se refere ao objeto [p1].

Quando um método de um objeto referencia uma propriedade [a] desse objeto, a notação [this.a] fica implícita: o método [initialize] poderia ter escrito [firstName = p] e [lastName = n]. É preciso usar [this] explicitamente quando há conflito de identificadores. É o caso da instrução [this.age = age] (linha 4), em que [age] se refere tanto a uma propriedade do objeto atual quanto ao parâmetro [age] recebido pelo método. Dentro do método, o nome [age] sozinho se refere ao parâmetro; a propriedade deve ser referenciada como [this.age]. Observe que um parâmetro de função é somente leitura: a instrução [age = 0] escrita dentro do método seria rejeitada pelo compilador.

4.1.7. Um programa de teste

Eis um breve programa de teste. Ele é escrito no arquivo-fonte [Main.kt]:

1
2
3
4
5
6
7
8
9
package persons

// o programa principal
fun main() {
    // um objeto Person
    val p1 = Person()
    p1.initialize("Jean", "Dupont", 30)
    p1.identify()
}
  • linha 4: a função [main] é o ponto de entrada do programa. Como no capítulo anterior, é uma função de nível superior, escrita fora de qualquer classe;
  • linha 6: criação de um objeto [Person] referenciado por [p1]. Como a classe [Person] pertence ao mesmo pacote, ela é reconhecida sem precisar ser importada. O tipo de [p1], [Person], é inferido pelo compilador;
  • linha 7: inicialização do objeto;
  • linha 8: exibição de seu estado.

Resultados:

> gradlew -q run -Pmain=persons.MainKt
[Jean, Dupont, 30]

4.1.8. Várias classes em um único arquivo

Para um exemplo curto, um pacote contendo vários arquivos é desnecessariamente grande. Como no capítulo anterior, escreveremos portanto um único arquivo — [Classes01.kt], por exemplo — que contém a função [main], eventualmente outras funções e as classes de que o programa precisa. Cada arquivo é colocado em um pacote com o nome dele ([classes01]), o que permite que cada programa do projeto tenha sua própria classe [Person]: a classe [Person] do arquivo [Classes01.kt] tem o nome completo [classes01.Person]; a classe do arquivo [Classes02.kt] tem o nome completo [classes02.Person], e assim por diante. Ele é executado com o comando [gradlew -q run -Pmain=classes01.Classes01Kt].

É importante entender como o compilador processa um arquivo desse tipo. As classes do arquivo são classes comuns de nível superior, exatamente como se estivessem escritas em seu próprio arquivo; as funções de nível superior, incluindo [main], são agrupadas em uma classe com o nome do arquivo, [Classes01Kt]. A compilação do arquivo demonstra isso:

1
2
3
4
> kotlinc src/main/kotlin/classes01/Classes01.kt -d classes
> ls classes/classes01
Classes01Kt.class
Person.class

Isso tem uma consequência que distingue Kotlin de Java. Em Java, as classes de um arquivo-fonte compacto são aninhadas em uma classe implícita e compartilham seus membros privados com o método [main] do arquivo. Em Kotlin, não existe classe envolvente: um membro [private] de uma classe continua inacessível à função [main], mesmo que esteja escrita no mesmo arquivo. Os exemplos curtos deste capítulo mostrarão, portanto, os mesmos erros de compilação do programa [persons].

4.1.9. Outra forma de inicializar: a sobrecarga

Vamos continuar com a classe [Person] e acrescentar a ela um segundo método, [initialize]. O programa [Classes01.kt] é o seguinte:

// sobrecarga do método initialize
package classes01

fun main() {
    val p1 = Person()
    p1.initialize("Jean", "Dupont", 30)
    p1.identify()
    val p2 = Person()
    p2.initialize(p1)
    p2.identify()
}

// a classe Person é declarada depois da função main
class Person {
    // propriedades privadas
    private var firstName = ""
    private var lastName = ""
    private var age = 0

    // inicialização a partir de três valores
    fun initialize(p: String, n: String, age: Int) {
        firstName = p
        lastName = n
        this.age = age
    }

    // inicialização a partir de outra pessoa
    fun initialize(p: Person) {
        firstName = p.firstName
        lastName = p.lastName
        age = p.age
    }

    // identidade da pessoa
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • linha 2: o pacote do programa;
  • linhas 4–10: o programa principal;
  • linha 14: a classe [Person] é declarada depois da função [main]. Em Kotlin, a ordem das declarações em um arquivo não importa;
  • linhas 21–24: o método [initialize] do parágrafo anterior;
  • linhas 28–31: um segundo método [initialize].

Agora temos dois métodos chamados [initialize]: isso é válido desde que eles aceitem parâmetros diferentes (em número ou tipo). Diz-se que o método [initialize] está sobrecarregado. O compilador escolhe qual método chamar com base nos parâmetros reais: [p1.initialize("Jean", "Dupont", 30)] (linha 6) chama o primeiro, e [p2.initialize(p1)] (linha 9) chama o segundo. O tipo de retorno sozinho não basta para distinguir dois métodos: dois métodos com o mesmo nome e os mesmos parâmetros, que diferem apenas no tipo de retorno, seriam rejeitados. Veremos que, em Kotlin, os valores padrão de parâmetros muitas vezes eliminam a necessidade de escrever várias versões do mesmo método.

O parâmetro do segundo método é uma referência ([p]) a uma pessoa. As propriedades da pessoa ([p]) são então atribuídas ao objeto atual ([this]). Observe que o método [initialize] tem acesso direto às propriedades do objeto [p] mesmo que elas sejam privadas (linhas 29–31). Isso vale sempre: um método de uma classe [C] tem acesso aos membros privados de todos os objetos da mesma classe [C].

Resultados:

1
2
3
> gradlew -q run -Pmain=classes01.Classes01Kt
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Construtores da classe Person

Um construtor é uma função chamada quando um objeto é criado. Geralmente é usado para inicializar o objeto. Ele pode receber parâmetros, mas não retorna um valor. Se uma classe [C] tem um construtor que aceita n parâmetros, a criação de um objeto dessa classe é escrita como [val obj = C(arg1, arg2, ... argn)].

Quando uma classe [C] tem um ou mais construtores, um deles deve ser usado para criar um objeto dessa classe. Se uma classe [C] não declara nenhum construtor, ela tem um construtor padrão sem parâmetros que não faz nada. As propriedades do objeto mantêm então seus valores iniciais. Foi o que aconteceu nos programas anteriores, em que escrevemos [Person()].

Kotlin distingue dois tipos de construtores:

  • o construtor primário, no máximo um por classe, declarado no cabeçalho da classe imediatamente após o nome dela: [class Person(firstName: String, lastName: String, age: Int)];
  • construtores secundários, declarados no corpo da classe com a palavra-chave [constructor]. Quando uma classe tem um construtor primário, todo construtor secundário deve chamá-lo, direta ou indiretamente por meio de outro construtor secundário.

O programa [Classes02.kt] fornece três construtores para a classe [Person]:

// construtores da classe Person
package classes02

fun main() {
    val p1 = Person("Jean", "Dupont", 30)
    p1.identify()
    val p2 = Person(p1)
    p2.identify()
    val p3 = Person()
    p3.identify()
}

// o construtor primário é declarado no cabeçalho da classe:
// seus parâmetros precedidos por val (ou var) também são propriedades da classe
class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // construtor secundário de cópia: ele chama o construtor primário
    constructor(p: Person) : this(p.firstName, p.lastName, p.age)

    // construtor secundário sem parâmetros: ele também chama o construtor primário
    constructor() : this("?", "?", 0)

    // identidade da pessoa
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • Linha 15: o construtor primário. Seus três parâmetros são precedidos por [private val]: essa é uma notação abreviada que declara ao mesmo tempo um parâmetro de construtor e uma propriedade privada somente leitura com o mesmo nome, inicializada com o valor do parâmetro. A classe não tem outras propriedades: elas são declaradas no cabeçalho;
  • Linha 17: o construtor secundário de cópia. A notação [: this(p.firstName, p.lastName, p.age)] chama o construtor da mesma classe que aceita três parâmetros: [String], [String] e [Int] — neste caso, o construtor primário. Isso é chamado de construtores encadeados. Assim, o código de inicialização é escrito apenas uma vez. Esse construtor não tem corpo: não há mais nada a fazer;
  • linha 20: o construtor secundário sem parâmetros, também encadeado ao construtor primário. Como a classe declarou um construtor primário com parâmetros, ela deixa de ter um construtor padrão: se quisermos poder escrever [Person()], precisamos declará-lo;
  • Linhas 4–10: os três construtores são usados.

A notação abreviada da linha 15 equivale à seguinte notação, mais longa, em que os parâmetros do construtor primário — sem o *[val]* — são simplesmente parâmetros usados para inicializar propriedades declaradas no corpo da classe:

1
2
3
4
5
6
7
class Person(firstName: String, lastName: String, age: Int) {
    // propriedades inicializadas com os parâmetros do construtor primário
    private val firstName: String = firstName
    private val lastName: String = lastName
    private val age: Int = age
    ...
}

Isso é muito mais curto que a versão Java, em que é preciso declarar os campos e depois inicializá-los um a um no construtor ([this.firstName = firstName;]…). O construtor primário não tem corpo: as instruções a serem executadas quando o objeto é construído são colocadas em blocos [init], que veremos um pouco mais adiante. Veremos também que, graças aos valores padrão de parâmetros, Kotlin muitas vezes dispensa construtores secundários: [class Person(..., private val age: Int = 0)] permite escrever tanto [Person("Jean", "Dupont", 30)] quanto [Person("Jean", "Dupont")].

Resultados:

1
2
3
4
> gradlew -q run -Pmain=classes02.Classes02Kt
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. Referências de objetos

Usamos a classe [Person] do programa anterior, omitindo seu construtor sem parâmetros, mas incluindo o método [initialize(String, String, Int)] do início do capítulo. Suas propriedades são, portanto, declaradas com [var] em vez de [val]. O programa de teste passa a ser o seguinte [Classes03.kt]:

// referências de objetos
package classes03

fun main() {
    // p1
    val p1 = Person("Jean", "Dupont", 30)
    print("p1="); p1.identify()
    // p2 referencia o mesmo objeto que p1
    val p2 = p1
    print("p2="); p2.identify()
    // p3 referencia um objeto que é uma cópia do objeto referenciado por p1
    val p3 = Person(p1)
    print("p3="); p3.identify()
    // mudamos o estado do objeto referenciado por p1
    p1.initialize("Micheline", "Benoît", 67)
    print("p1="); p1.identify()
    // como p2 = p1, o objeto referenciado por p2 mudou de estado
    print("p2="); p2.identify()
    // p3 não referencia o mesmo objeto que p1: o objeto referenciado por p3 não mudou
    print("p3="); p3.identify()
    // p1 e p2 são a mesma referência? e p1 e p3?
    println("p1 === p2 : ${p1 === p2}, p1 === p3 : ${p1 === p3}")
}

class Person(private var firstName: String, private var lastName: String, private var age: Int) {
    // construtor secundário de cópia
    constructor(p: Person) : this(p.firstName, p.lastName, p.age)

    // inicialização
    fun initialize(p: String, n: String, age: Int) {
        firstName = p
        lastName = n
        this.age = age
    }

    // identidade da pessoa
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}

A função [print] (linhas 7, 10, …) escreve seu parâmetro sem iniciar uma nova linha. As duas instruções dessas linhas são separadas por ponto e vírgula, que em Kotlin só é necessário para escrever várias instruções em uma única linha. Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=classes03.Classes03Kt
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 === p2 : true, p1 === p3 : false

Quando a variável [p1] é declarada por [val p1 = Person("Jean", "Dupont", 30)] (linha 6), [p1] referencia o objeto [Person("Jean", "Dupont", 30)] mas não é o objeto em si. Em C, isso seria chamado de ponteiro, isto é, o endereço do objeto criado. Se [p1] fosse declarada como [var p1: Person? = ...] e depois escrevêssemos [p1 = null], não seria o objeto [Person("Jean", "Dupont", 30)] que seria modificado, mas sim a referência [p1] que mudaria de valor. O objeto estaria “perdido” se não fosse referenciado por nenhuma outra variável: a memória que ele ocupa seria posteriormente recuperada pelo coletor de lixo da máquina virtual Java, que executa programas Kotlin da mesma forma que programas Java.

Quando escrevemos [val p2 = p1] (linha 9), inicializamos a referência [p2]: ela “aponta” para o mesmo objeto (refere-se ao mesmo objeto) que a referência [p1]. Assim, se você modificar o objeto “apontado” (ou referenciado) por [p1], também modifica aquele referenciado por [p2] (linhas 4–5 dos resultados). Observe que [p1] e [p2] são declaradas com [val]: a palavra-chave proíbe alterar a referência contida na variável, e não modificar o objeto referenciado, que é o que a chamada a [p1.initialize(...)] faz (linha 15).

Quando você digita [val p3 = Person(p1)] (linha 12), um novo objeto [Person] é criado. Esse novo objeto será referenciado por [p3]. Se você modificar o objeto referenciado por [p1], isso não afeta o objeto referenciado por [p3] (linha 6 dos resultados).

Por fim, na linha 22, o operador [===], aplicado a duas referências de objetos, indica se elas se referem ao mesmo objeto: [p1] e [p2] referem-se ao mesmo objeto, enquanto [p1] e [p3] referem-se a dois objetos diferentes, embora tenham o mesmo conteúdo (linha 7 dos resultados). Esse é o operador [] do Java. Em Kotlin, o operador [] compara o conteúdo dos objetos chamando o método [equals] deles: veremos mais adiante como defini-lo. Para uma classe que não define [equals], como neste caso, [p1 == p3] continua comparando as referências e resulta em [false].

4.1.12. Passagem de parâmetros de referência a objetos

No capítulo anterior, vimos que Kotlin, assim como Java, passa os parâmetros de função por valor: a função recebe uma cópia do valor do parâmetro real. Vejamos o que isso significa quando o parâmetro é uma referência a um objeto. Para isso, usaremos a classe [StringBuilder] (a classe do JDK, que Kotlin usa diretamente). Um objeto [String] não pode ser modificado: uma operação como [s.uppercase()] retorna um novo objeto [String]. Um objeto [StringBuilder], por outro lado, é uma string mutável: seu método [append] acrescenta caracteres à string sem criar um novo objeto.

Em Java, o exemplo atribuía um novo objeto ao parâmetro [sbf1] da função chamada. Isso não é possível em Kotlin: um parâmetro de função é somente leitura, exatamente como uma variável [val]. O compilador rejeita a instrução [sbf1 = StringBuilder("test1*****")]:

1
2
3
Classes04.kt:5:5: error: 'val' cannot be reassigned.
    sbf1 = StringBuilder("test1*****")
    ^^^^

O programa [Classes04.kt] copia, portanto, o parâmetro [sbf1] para uma variável local modificável:

// passagem de parâmetros de tipo referência a objeto
package classes04

fun main() {
    val sb0 = StringBuilder("test0")
    val sb1 = StringBuilder("test1")
    println("In calling function before the call: sb0=$sb0, sb1=$sb1")
    val sb2 = changeStringBuilder(sb0, sb1)
    println("In calling function after the call: sb0=$sb0, sb1=$sb1, sb2=$sb2")
}

// a função chamada
fun changeStringBuilder(sbf0: StringBuilder, sbf1: StringBuilder): StringBuilder {
    println("Start of called function: sbf0=$sbf0, sbf1=$sbf1")
    // modificamos o objeto referenciado por sbf0
    sbf0.append("*****")
    // um parâmetro é somente leitura: sbf1 = StringBuilder(...) seria rejeitado.
    // A variável local sbl referencia primeiro o mesmo objeto que sbf1, depois um novo objeto
    var sbl = sbf1
    sbl = StringBuilder("test1*****")
    // um novo objeto é retornado ao chamador
    val sbf2 = StringBuilder("test2*****")
    println("End of called function: sbf0=$sbf0, sbf1=$sbf1, sbl=$sbl, sbf2=$sbf2")
    return sbf2
}
  • Linhas 5–6: duas referências, [sb0] e [sb1], a objetos do tipo [StringBuilder];
  • linha 8: elas são passadas para a função [changeStringBuilder], cujo resultado — uma terceira referência — é atribuído a [sb2];
  • linhas 13–24: uma função de nível superior, que tem os parâmetros formais [sbf0] e [sbf1]. Quando a função começa, [sbf0] e [sb0] são duas referências distintas que apontam para o mesmo objeto: a referência [sb0] foi copiada para [sbf0] (as referências são passadas por valor). O mesmo vale para [sbf1] e [sb1];
  • linhas 19–20: a variável local [sbl] recebe primeiro a referência [sbf1] e depois a referência a um novo objeto. Era isso que o programa Java fazia com o próprio parâmetro [sbf1] .

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=classes04.Classes04Kt
In calling function before the call: sb0=test0, sb1=test1
Start of called function: sbf0=test0, sbf1=test1
End of called function: sbf0=test0*****, sbf1=test1, sbl=test1*****, sbf2=test2*****
In calling function after the call: sb0=test0*****, sb1=test1, sb2=test2*****

Explicações:

  • [sb0] e [sbf0] são duas referências distintas ao mesmo objeto. Esse objeto foi modificado por meio de [sbf0] (linha 16). Essa modificação é visível por meio de [sb0] (linha 4 dos resultados);
  • [sb1], [sbf1] e, inicialmente, [sbl] são três referências distintas ao mesmo objeto. [sbl] recebe um novo valor e passa a apontar para um novo objeto (linha 20). Isso não altera o valor de [sbf1] nem o de [sb1], que continuam apontando para o objeto original, não modificado (linhas 3 e 4 dos resultados);
  • uma função Kotlin não pode, portanto, alterar o valor de uma variável pertencente ao chamador. Para passar um novo objeto ao chamador, ela o retorna como resultado (linhas 22 e 24). Quando há vários resultados, eles são agrupados em um objeto: um par ([Pair]), como visto no capítulo anterior, ou uma classe de dados (veja adiante).

Lembre-se de que uma função pode modificar o objeto referenciado por um parâmetro, mas não a variável do chamador que contém a referência. Como Java, e diferentemente de C#, Kotlin não passa parâmetros por referência; vai um passo além do Java ao proibir qualquer atribuição a um parâmetro, o que evita confusão entre o parâmetro e a variável do chamador.

4.1.13. Objetos temporários

Em uma expressão, é possível chamar explicitamente o construtor de um objeto: o objeto é criado, mas não há variável para acessá-lo depois (para modificá-lo, por exemplo). Esse objeto temporário é criado para a avaliação da expressão e é descartado em seguida. O espaço de memória que ele ocupava será posteriormente recuperado automaticamente pelo coletor de lixo, cuja função é recuperar o espaço de memória ocupado por objetos que não são mais referenciados pelos dados do programa.

Considere o seguinte programa, [Classes05.kt], em que os construtores da classe [Person] exibem uma mensagem. É a oportunidade de apresentar o bloco de inicialização [init]:

// objetos temporários
package classes05

fun main() {
    Person(Person("Jean", "Dupont", 30)).identify()
}

class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // o bloco init é executado pelo construtor primário
    init {
        println("Constructor Person(String, String, Int)")
    }

    // o construtor secundário chama primeiro o construtor primário, depois executa seu corpo
    constructor(p: Person) : this(p.firstName, p.lastName, p.age) {
        println("Constructor Person(Person)")
    }

    // identidade da pessoa
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • linha 5: o objeto [Person("Jean", "Dupont", 30)] é construído e depois passado ao construtor de cópia, que constrói um segundo objeto; o método [identify] é então chamado nesse objeto. Nenhum dos dois objetos é referenciado por uma variável;
  • linhas 9–11: como o construtor primário não tem corpo, as instruções a serem executadas quando o objeto é construído são colocadas em um bloco [init]. Uma classe pode ter vários blocos [init]: eles são executados, junto com as inicializações das propriedades declaradas no corpo da classe, na ordem em que foram escritos. Fazem parte do construtor primário e têm acesso aos parâmetros dele;
  • linhas 15–16: um construtor secundário pode ter um corpo. Ele é executado depois do construtor chamado por [: this(...)] — neste caso, o construtor primário com seus blocos [init].

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=classes05.Classes05Kt
Constructor Person(String, String, Int)
Constructor Person(String, String, Int)
Constructor Person(Person)
[Jean, Dupont, 30]

Os resultados mostram a construção sequencial dos dois objetos temporários. O primeiro é construído pelo construtor primário (linha 1 dos resultados). O segundo é construído pelo construtor secundário, que começa chamando o construtor primário — daí a execução do bloco [init] (linha 2) — e depois executa o próprio corpo (linha 3). Em Java, o construtor de cópia do exemplo não era encadeado ao construtor primário e exibia apenas a própria mensagem; em Kotlin, desde que uma classe tenha um construtor primário, todo objeto passa por ele: os blocos [init] são sempre executados.

4.1.14. Propriedades: métodos getter e setter

Em Java, a convenção é declarar campos privados e dar acesso a seus valores por meio de métodos públicos: getters, como [getAge()], e setters, como [setAge(int)]. Esses métodos são escritos à mão (ou gerados pelo ambiente de desenvolvimento), e o usuário da classe escreve [p.setAge(p.getAge() + 1)]. Kotlin, como C#, tem propriedades: uma propriedade pública é um dado que o usuário lê e escreve com a notação de ponto, como um campo, mas que na verdade é lido e escrito por meio de um getter e de um setter. O compilador os gera. O programa [Classes06.kt] demonstra isso:

// propriedades em vez de getters e setters
package classes06

fun main() {
    val p = Person("Jean", "Michelin", 34)
    // leitura das propriedades: chamada implícita de seu getter
    println("p=(${p.firstName},${p.lastName},${p.age})")
    // escrita de uma propriedade: chamada implícita de seu setter
    p.age = 56
    println("p=(${p.firstName},${p.lastName},${p.age})")
}

// três propriedades públicas de leitura e escrita
class Person(var firstName: String, var lastName: String, var age: Int)
  • linha 14: a classe *[Person]* cabe em uma única linha. Os três parâmetros do construtor primário são precedidos por *[var]*: são três propriedades públicas (visibilidade padrão), que podem ser lidas e escritas. Como a classe não tem corpo, as chaves são omitidas;
  • linha 7: leitura das propriedades [p.firstName], [p.lastName] e [p.age]. Cada operação de leitura é uma chamada ao acessor da propriedade;
  • Linha 9: escrita da propriedade [age], isto é, chamada ao seu setter.

Resultados:

1
2
3
> gradlew -q run -Pmain=classes06.Classes06Kt
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

A ferramenta [javap] do JDK, que exibe o conteúdo de um arquivo [.class], mostra o que o compilador Kotlin gerou para a classe [Person] (a opção [-p] também exibe os membros privados):

> javap -p -cp build/classes/kotlin/main classes06.Person
Compiled from "Classes06.kt"
public final class classes06.Person {
  private java.lang.String firstName;
  private java.lang.String lastName;
  private int age;
  public classes06.Person(java.lang.String, java.lang.String, int);
  public final java.lang.String getFirstName();
  public final void setFirstName(java.lang.String);
  public final java.lang.String getLastName();
  public final void setLastName(java.lang.String);
  public final int getAge();
  public final void setAge(int);
}

Cada propriedade resultou em um campo privado (linhas 3–5), um getter público e um setter público (linhas 7–12), que seguem a convenção de nomenclatura estabelecida nos primórdios do Java, a dos “JavaBeans”: o getter da propriedade [age] chama-se [getAge], e seu setter é [setAge]; uma propriedade booleana cujo nome começa com [is] — como [isActive] — tem um getter com o mesmo nome, [isActive], e um setter chamado [setActive]. Isso é importante: muitas bibliotecas Java (como o Jackson para JSON e o Hibernate para bancos de dados, que usaremos mais adiante) se baseiam nessa convenção para localizar os dados de um objeto; elas conseguem encontrar os dados dos objetos Kotlin sem nenhuma dificuldade. Inversamente, um programa Kotlin que usa uma classe Java escreve [p.age] para chamar [p.getAge()], e [p.age = 56] para chamar [p.setAge(56)]. Observamos também que a classe e seus métodos são [final]: veremos, ao tratar da herança, que em Kotlin as classes e os métodos são final por padrão.

A notação [p.age = 56] lembra a atribuição a um campo público. A diferença é significativa: como ela usa um setter, podemos — sem alterar nada no código escrito pelos usuários da classe — atribuir mais tarde à propriedade um setter que controle os valores recebidos. Esse é o assunto da próxima seção. Em Kotlin, portanto, nunca escrevemos acessores e setters no estilo Java: declaramos propriedades.

4.1.15. Setters que validam os valores recebidos

A vantagem dos setters sobre os campos públicos é a possibilidade de controlar os valores atribuídos aos campos: um setter pode validar o valor recebido e lançar uma exceção se ele for inválido. Kotlin permite dotar uma propriedade de um getter personalizado ([get]) e de um setter personalizado ([set]). Considere o programa [Classes07.kt]:

// setters que verificam a validade dos valores recebidos
package classes07

fun main() {
    val p = Person("Jean", "Michelin", 34)
    println("p=(${p.firstName},${p.lastName},${p.age})")
    p.age = 56
    println("p=(${p.firstName},${p.lastName},${p.age})")
    try {
        p.age = -4
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    // construtor sem parâmetros e depois atribuição das propriedades
    val p2 = Person()
    p2.age = 7
    p2.firstName = "Arthur"
    p2.lastName = "Martin"
    println("p2=(${p2.firstName},${p2.lastName},${p2.age})")
    try {
        val p3 = Person()
        p3.firstName = "Paul"
        p3.lastName = " "
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    // o construtor também verifica os valores recebidos
    try {
        val p4 = Person("", "Durand", 20)
        println("p4=(${p4.firstName},${p4.lastName},${p4.age})")
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
}

// a classe tem um construtor primário sem parâmetros
class Person() {
    // propriedades com um setter personalizado (set)
    var firstName = ""
        set(value) {
            // nome válido?
            require(value.isNotBlank()) { "invalid first name ($value)" }
            // field designa o campo de apoio (backing field) que armazena o valor da propriedade
            field = value
        }

    var lastName = ""
        set(value) {
            // sobrenome válido?
            require(value.isNotBlank()) { "invalid last name ($value)" }
            field = value
        }

    var age = 0
        set(value) {
            // idade válida?
            require(value >= 0) { "invalid age ($value)" }
            field = value
        }

    // construtor secundário: ele passa pelos setters para se beneficiar de suas verificações
    constructor(firstName: String, lastName: String, age: Int) : this() {
        this.firstName = firstName
        this.lastName = lastName
        this.age = age
    }
}

As três propriedades têm um setter personalizado que valida o valor recebido:

  • linhas 39–44: a propriedade [firstName]. Sua declaração é seguida, nas linhas subsequentes, pela definição de seu setter, [set(value) { ... }]. O parâmetro [value] é o valor atribuído à propriedade (o nome [value] é convencional, como em C#); seu tipo é o da propriedade. A propriedade não tem acessor personalizado: ela mantém o acessor gerado, que retorna o valor armazenado;
  • Linha 42: a função [require(condition) { message }], vista no capítulo anterior, lança uma exceção [IllegalArgumentException] — a exceção criada para sinalizar um parâmetro inválido — se a condição for falsa. A mensagem, calculada pela expressão lambda entre chaves, só é construída nesse caso. A função [isNotBlank] retorna [true] se a string contiver pelo menos um caractere diferente de espaço. Não é preciso testar o valor [null] como em Java: a propriedade é do tipo [String], e não [String?], e o compilador proíbe atribuir [null] a ela;
  • Linha 44: em um getter ou setter, a palavra-chave [field] refere-se ao campo que armazena o valor da propriedade (conhecido como “backing field”). Não escreva [firstName = value]: isso seria uma chamada ao próprio setter, que chamaria a si mesmo indefinidamente;
  • linhas 47–58: as propriedades [lastName] e [age] são construídas segundo o mesmo padrão;
  • linha 37: a classe tem um construtor primário sem parâmetros. Os valores iniciais das propriedades ([""] e 0) são atribuídos diretamente aos campos, sem passar pelos setters;
  • Linhas 62–65: um construtor secundário que inicializa o objeto usando os setters. Isso permite aproveitar as verificações feitas pelos setters, que são escritas uma única vez. Aqui, [this.firstName = firstName] é a chamada ao setter da propriedade [firstName] com o valor do parâmetro [firstName].

Por que não escrever [class Person(firstName: String, lastName: String, age: Int)] com propriedades inicializadas por [var age = age]? Porque inicializar uma propriedade na declaração afeta diretamente o campo, sem chamar o setter: uma idade de -4 seria aceita sem erro. Para verificar os valores recebidos pelo construtor primário, escrevemos as verificações em um bloco [init] ou, como mostrado aqui, passamos os valores pelos setters.

Em Java, os setters chamados pelo construtor precisavam ser declarados como [final]: caso contrário, uma classe derivada poderia redefini-los, e o construtor da classe pai chamaria a nova versão antes mesmo de o construtor da classe derivada ser executado. Em Kotlin, as classes e seus membros são final por padrão: essa precaução é desnecessária.

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=classes07.Classes07Kt
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
invalid age (-4)
p2=(Arthur,Martin,7)
invalid last name ( )
invalid first name ()

A linha 3 dos resultados mostra que a atribuição [p.age = -4] (linha 10) foi rejeitada pelo setter: [ex.message] é a mensagem da exceção. Linhas 15–18: um objeto é criado com o construtor sem parâmetros e depois inicializado por seus setters. Linhas 21–23: o nome que contém um espaço é rejeitado (linha 5 dos resultados). Linhas 29–30: o construtor de três parâmetros rejeita um nome vazio (linha 6 dos resultados).

Java não tem inicializadores de objeto — uma sintaxe que permitiria definir várias propriedades na própria expressão de criação do objeto. Kotlin também não tem, mas oferece duas soluções equivalentes: parâmetros de construtor nomeados e com valores padrão, e a função [apply]. Vamos tratar delas nos próximos dois parágrafos.

4.1.16. Propriedades somente leitura e parâmetros opcionais

Uma propriedade declarada com [val] deve receber um valor exatamente uma vez — no momento de sua declaração, no construtor primário ou em um bloco [init] — e não pode ser modificada depois. O compilador garante isso. Isso equivale ao campo [final] em Java: a propriedade tem apenas um getter, sem setter. O programa [Classes08.kt] ilustra vários casos, bem como parâmetros padrão e argumentos nomeados:

// propriedades somente leitura, setter privado, propriedade calculada,
// parâmetros obrigatórios e opcionais, argumentos nomeados
package classes08

fun main() {
    val p = Person("Jean", "Dupont", 30, "Angers")
    println(p.identity)
    // o nome é de leitura / escrita
    p.firstName = "Jacques"
    // a idade só pode ser modificada dentro da classe
    p.growOlder()
    println(p.identity)
    // as linhas seguintes são rejeitadas pelo compilador
    // p.lastName = "Durand" // lastName é uma propriedade val
    // p.age = 40            // o setter de age é privado
    // p.identity = "?"      // identity é uma propriedade val (calculada)

    // um parâmetro obrigatório e um parâmetro opcional
    val c1 = Contact("jean.dupont@example.com")
    println("Contact : ${c1.email}, ${c1.phone}")
    // argumentos nomeados, em qualquer ordem
    val c2 = Contact(phone = "02 41 00 00 00", email = "paul.martin@example.com")
    println("Contact : ${c2.email}, ${c2.phone}")
    // Contact(null) é rejeitado pelo compilador; um e-mail vazio é rejeitado em tempo de execução
    try {
        val c3 = Contact(" ")
        println("Contact : ${c3.email}")
    } catch (ex: IllegalArgumentException) {
        println("Error: ${ex.message}")
    }
}

class Person(var firstName: String, val lastName: String, age: Int, val city: String) {
    // a idade pode ser lida por todos, mas seu setter é privado
    var age = age
        private set

    // uma propriedade calculada: ela não tem campo de apoio, seu getter calcula o valor
    val identity: String
        get() = "[$firstName, $lastName, $age, $city]"

    // a idade só é modificada pelos métodos da classe
    fun growOlder() {
        age++
    }
}

// o e-mail é obrigatório, o telefone opcional: seu parâmetro tem um valor padrão
class Contact(val email: String, val phone: String = "unknown") {
    // verificação executada quando o objeto é construído
    init {
        require(email.isNotBlank()) { "the email is mandatory" }
    }
}
  • linha 33: o nome próprio é uma propriedade [var], de leitura e escrita; o sobrenome e a cidade são propriedades [val], somente leitura. O construtor atribui um valor a elas, que não pode ser alterado depois. O parâmetro [age], sem [val] ou [var], é simplesmente um parâmetro de construtor;
  • linhas 35–36: a propriedade [age] é inicializada com o parâmetro [age]. Ela pode ser lida por todos, mas seu setter é privado ([private set]): ela só pode ser modificada pelos métodos da classe, como [growOlder] (linhas 43–44). O setter mantém seu comportamento padrão: não precisa de corpo;
  • linhas 39–40: uma propriedade calculada. Ela tem um acessor personalizado, [get() = ...], que calcula seu valor a cada leitura com base nas outras propriedades; não há campo para armazenar um valor. Para o usuário da classe, nada a distingue de outra propriedade: [p.identity] (linha 7). Isso equivale ao método [getIdentity()] da versão Java;
  • linhas 14–16: três instruções que o compilador rejeita, pelos motivos indicados nos comentários. Se as descomentarmos, o compilador relata o seguinte (também descomentamos a instrução [Contact(null)] mencionada na linha 24):
Classes08.kt:14:7: error: 'val' cannot be reassigned.
    p.lastName = "Durand" // lastName is a val property
      ^^^^^^^^
Classes08.kt:15:7: error: cannot access 'age': it is private in 'classes08.Person'.
    p.age = 40            // the setter of age is private
      ^^^
Classes08.kt:16:7: error: 'val' cannot be reassigned.
    p.identity = "?"      // identity is a val (computed) property
      ^^^^^^^^
Classes08.kt:24:13: error: null cannot be a value of a non-null type 'String'.
    Contact(null)
            ^^^^
  • linha 49: a classe [Contact] tem uma propriedade obrigatória, email, e uma propriedade opcional, phone. O caráter opcional da propriedade phone é expresso por um valor padrão para o parâmetro [phone] do construtor: [val phone: String = "unknown"]. Se o argumento for omitido, como na linha 19, o parâmetro assume esse valor. Em Java, que não tem parâmetros opcionais, era necessário um segundo construtor — encadeado ao primeiro; em Kotlin, um único construtor basta. Os valores padrão são usados da mesma forma nos parâmetros de qualquer função;
  • linha 22: os argumentos são nomeados: [phone = "02 41 00 00 00"]. Eles podem então ser fornecidos em qualquer ordem, e a chamada fica mais legível quando vários parâmetros têm o mesmo tipo. Os argumentos nomeados também permitem omitir apenas um parâmetro opcional entre vários: com [f(a: Int = 0, b: Int = 0)], você pode escrever [f(b = 5)];
  • Linhas 51–52: o caráter obrigatório do email é expresso primeiro pelo tipo do parâmetro: [String] não aceita o valor [null], e a chamada [Contact(null)] é rejeitada em tempo de compilação (último erro acima). Em Java, isso precisava ser verificado em tempo de execução ([Objects.requireNonNull]). O passo seguinte é rejeitar um endereço de email vazio: esse é o papel do bloco [init], que é executado quando o objeto é construído. Na linha 26, um endereço de email formado por um único espaço é rejeitado.

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=classes08.Classes08Kt
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact : jean.dupont@example.com, unknown
Contact : paul.martin@example.com, 02 41 00 00 00
Error: the email is mandatory

Observe como as declarações são curtas: a classe [Person], que ocupava cerca de cinquenta linhas em Java, com seus getters, setters e validação, ocupa apenas cerca de quinze linhas em Kotlin.

4.1.17. As funções apply e also no lugar dos mutadores fluentes

Em Java, quando um objeto tem muitos campos opcionais, o número de construtores aumenta e as chamadas de setters ficam mais longas. Uma técnica comum é fazer cada setter retornar o objeto atual ([this]): as chamadas podem então ser encadeadas — fala-se em métodos “encadeados”: [new Person().setFirstName("jean").setLastName("Dupont").setAge(30)]. Em Kotlin, os parâmetros padrão e os argumentos nomeados tornam essa técnica muito menos útil. E quando se quer definir várias propriedades de um objeto logo após sua criação, a biblioteca padrão oferece “funções de escopo” que podem ser usadas com qualquer objeto, entre elas [apply] e [also]. O programa [Classes09.kt] as ilustra e, de passagem, apresenta as propriedades [lateinit]:

// em vez de setters "fluentes": as funções de escopo apply e also
// uma propriedade lateinit
package classes09

fun main() {
    // apply executa o bloco com o objeto como objeto corrente (this), depois retorna o objeto
    val p = Person().apply {
        firstName = "  jean "
        lastName = "Dupont"
        age = 30
    }
    println(p.identity)
    try {
        p.lastName = ""
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    try {
        p.age = -4
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    println(p.identity)
    // also executa o bloco com o objeto como parâmetro (it), depois retorna o objeto
    val p2 = Person().apply { firstName = "Arthur"; lastName = "Martin"; age = 7 }
        .also { println("Creation of ${it.identity}") }
    // leitura de uma propriedade lateinit que ainda não recebeu um valor
    try {
        println(p2.city)
    } catch (ex: UninitializedPropertyAccessException) {
        println(ex.message)
    }
    p2.city = "Angers"
    println("${p2.identity} lives in ${p2.city}")
}

class Person {
    // propriedades verificadas pelo seu setter
    var firstName = ""
        set(value) {
            field = validate(value, "first name")
        }

    var lastName = ""
        set(value) {
            field = validate(value, "last name")
        }

    var age = 0
        set(value) {
            require(value >= 0) { "invalid age ($value)" }
            field = value
        }

    // uma propriedade sem valor inicial: ela receberá seu valor mais tarde
    lateinit var city: String

    // identity: o tipo da propriedade é inferido a partir de seu getter
    val identity get() = "[$firstName, $lastName, $age]"
}

// verificação de uma string obrigatória: ela é retornada sem espaços no início e no fim
// (função privada de nível superior: só é visível neste arquivo)
private fun validate(value: String, label: String): String {
    require(value.isNotBlank()) { "invalid $label ($value)" }
    return value.trim()
}
  • linhas 7–10: [obj.apply { ... }] executa o bloco entre chaves com [obj] como objeto atual: dentro do bloco, [firstName = " jean "] refere-se a [this.firstName = " jean "], em que [this] é a nova pessoa. Em seguida, [apply] retorna o próprio objeto, que é atribuído a [p]. A atribuição funciona como um inicializador de objeto; cada atribuição passa pelo setter da propriedade e, portanto, por suas validações;
  • linhas 39–46: os setters do nome próprio e do sobrenome atribuem ao campo o valor retornado pela função [validate];
  • linhas 64–66: as validações do nome próprio e do sobrenome, que são idênticas, foram extraídas para a função [validate]. Ela não usa nenhuma propriedade de uma pessoa: fizemos dela uma função de nível superior, declarada como [private] e, portanto, visível apenas no arquivo [Classes09.kt]. Em Java, isso teria de ser implementado como um método estático privado da classe. A função [trim] remove os espaços iniciais e finais da string;
  • linha 59: o tipo da propriedade calculada [identity], [String], é inferido a partir da expressão de seu acessor;
  • Linhas 25–26: [obj.also { ... }] executa o bloco passando-lhe o objeto como parâmetro, referenciado como [it], e depois retorna o objeto. É usada para uma ação secundária — como uma exibição de acompanhamento, como mostrado aqui — sem interromper a cadeia de chamadas. Aqui, [apply] retorna a pessoa, [also] a exibe e depois a retorna por sua vez, e ela é atribuída a [p2]. Linha 25: as três atribuições do bloco [apply] são escritas em uma única linha, separadas por ponto e vírgula;
  • Linha 56: uma propriedade de um tipo diferente de [null] deve, em princípio, receber um valor na criação. A palavra-chave [lateinit] (“inicialização tardia”) dispensa essa exigência: a propriedade [city] receberá seu valor mais tarde (linha 33). Se ela for acessada antes disso, uma exceção [UninitializedPropertyAccessException] é lançada (linhas 29–31). [lateinit] aplica-se apenas a uma propriedade [var] de um tipo de objeto que não seja [null] ([String], mas não [Int] ou [String?]) e sem acessores personalizados. É usada quando o valor é fornecido depois que o objeto é construído, por exemplo por um framework de injeção de dependência como o Spring (Capítulo 6) ou por um método de inicialização em um teste. Dentro da classe, a expressão [::city.isInitialized] indica se a propriedade já recebeu um valor.

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=classes09.Classes09Kt
[jean, Dupont, 30]
invalid last name ()
invalid age (-4)
[jean, Dupont, 30]
Creation of [Arthur, Martin, 7]
lateinit property city has not been initialized
[Arthur, Martin, 7] lives in Angers

O nome "jean", que foi informado com espaços ao redor (linha 8), foi armazenado sem eles (linha 1 dos resultados). As tentativas de modificação inválidas foram rejeitadas, e a pessoa não foi alterada (linhas 2–4 dos resultados). A linha 6 dos resultados é a mensagem da exceção [UninitializedPropertyAccessException].

Há outras três funções de escopo: [let], vista no capítulo anterior com os valores [null], [run], e [with]. Elas diferem na forma como o bloco se refere ao objeto ([this] ou [it]) e no que retornam (o objeto ou o resultado do bloco):

Função
Objeto no bloco
Resultado
Uso típico
[apply]
[this]
O objeto
Configurar um objeto recém-criado
[also]
[it]
O objeto
Ação complementar (monitoramento, verificação) em uma sequência
[let]
[it]
O resultado do bloco
Processar um valor não [null]: [x?.let { ... }]
[run]
[this]
O resultado do bloco
Calcular um valor a partir de um objeto
[with]
[this]
O resultado do bloco
[with(obj) { ... }]: várias chamadas no mesmo objeto

Para construir objetos complexos, o Java costuma usar o padrão de projeto “Builder”: uma classe auxiliar, dotada de métodos fluentes, coleta valores e depois constrói o objeto final. Em Kotlin, um construtor com parâmetros nomeados e valores padrão substitui esse padrão na maioria dos casos.

4.1.18. Membros da classe: o companion object

Suponha que queiramos contar o número de objetos [Person] criados em uma aplicação. Poderíamos gerenciar um contador por conta própria, mas corremos o risco de esquecer objetos temporários criados aqui e ali. Parece mais seguro incluir no construtor da classe [Person] uma instrução que incremente um contador. Esse contador não pode ser uma propriedade comum, já que cada objeto tem suas próprias propriedades: ele é uma propriedade da própria classe, e não de uma instância particular dessa classe.

Java declara esse tipo de membro com a palavra-chave [static]. Kotlin não tem a palavra-chave [static]: os membros de classe são declarados em um companion object ([companion object { ... }]), um objeto único associado à classe e declarado no corpo dela. Seus membros são usados com o nome da classe: [Person.nbPersons], [Person.unknown()]. Eis um exemplo, [Classes10.kt]:

// membros da classe: o companion object; um objeto singleton (object)
package classes10

fun main() {
    val p1 = Person("Jean", "Dupont", 30)
    val p2 = Person(p1)
    Person(p1)
    Log.write("Number of persons created: ${Person.nbPersons}")
    // um método de classe
    val p3 = Person.unknown()
    p3.identify()
    p2.identify()
    Log.write("Number of persons created: ${Person.nbPersons}")
}

class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // construtor secundário de cópia
    constructor(p: Person) : this(p.firstName, p.lastName, p.age)

    // o bloco init faz parte do construtor primário: toda construção incrementa o contador
    init {
        nbPersons++
    }

    // identidade da pessoa
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }

    // o companion object: seus membros são os da própria classe
    companion object {
        // propriedade de classe: legível por todos, modificável apenas pela classe Person
        var nbPersons = 0L
            private set

        // método de classe
        fun unknown() = Person("?", "?", 0)
    }
}

// um objeto singleton: a classe Log e sua única instância são declaradas juntas
object Log {
    // o estado do objeto: o número da última mensagem escrita
    private var number = 0

    fun write(message: String) {
        number++
        println("[$number] $message")
    }
}
  • linhas 31–37: o companion object da classe [Person];
  • linhas 33–34: a propriedade de classe [nbPersons], inicializada com 0 (do tipo [Long] por causa do sufixo [L]). Ela pode ser lida por todos ([Person.nbPersons], linha 8), mas seu setter é privado: somente a classe [Person] pode modificá-la. Não é preciso definir, como em Java, um campo privado e um método acessor estático [getNbPersons()];
  • linha 37: um método de classe. Ele é chamado com o nome da classe: [Person.unknown()] (linha 10). Um método do companion object não tem um objeto [Person] atual: ele não pode usar diretamente as propriedades de uma pessoa. Um método que cria e retorna um objeto de sua própria classe, como este, é chamado de “factory” (fábrica);
  • linhas 21–22: o bloco [init] incrementa o contador. Ele faz parte do construtor primário e, portanto, o construtor de cópia — que é encadeado ao construtor primário — também o executa.

O último elemento do programa é um objeto singleton, [Log], declarado com a palavra-chave [object] (linhas 42–48):

  • Uma declaração como [object Log { ... }] declara ao mesmo tempo uma classe e sua única instância, que é criada automaticamente na primeira vez em que é usada. Não há construtor: nenhum outro objeto [Log] pode ser criado. O objeto é referenciado pelo seu nome: [Log.write(...)];
  • um objeto tem um estado — neste caso, o número da última mensagem escrita — que é preservado de uma chamada para a seguinte;
  • Um companion object é um caso particular de objeto singleton: aquele que está associado a uma classe.

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=classes10.Classes10Kt
[1] Number of persons created: 3
[?, ?, 0]
[Jean, Dupont, 30]
[2] Number of persons created: 4

O programa contou corretamente o objeto temporário criado na linha 7. O log numerou suas duas mensagens. A compilação produz uma classe para o companion object, [Person$Companion], ao lado das classes [Person], [Log] e [Classes10Kt]; um método do companion object é, portanto, para a JVM, um método de instância do objeto [Person.Companion]. Para permitir que um programa Java o chame como método estático ([Person.unknown()] em vez de [Person.Companion.unknown()]), ele é anotado com [@JvmStatic].

Desde o início, temos usado funções que, em Java, seriam métodos estáticos: [println], [readln]… Em Kotlin, elas são funções de nível superior, declaradas fora de qualquer classe. Essa é a forma de Kotlin de escrever o que Java chama de classe utilitária, como a classe [Math]: um arquivo contendo funções de nível superior (a biblioteca padrão fornece [kotlin.math.sqrt] e [kotlin.math.PI]) ou, se você quiser agrupar funções sob um único nome, um [object]. O companion object é reservado para elementos que são realmente específicos da classe: fábricas, constantes e contadores.

4.1.19. Um array de pessoas

Um objeto é um dado como qualquer outro e, como tal, vários objetos podem ser agrupados em um array [Classes11.kt]:

// um array de pessoas
package classes11

fun main() {
    // um array de 3 referências, todas inicializadas com null
    val friends = arrayOfNulls<Person>(3)
    friends[0] = Person("Jean", "Dupont", 30)
    friends[1] = Person("Sylvie", "Vartan", 52)
    friends[2] = Person("Neil", "Armstrong", 66)
    // exibição: os elementos são do tipo Person?
    for (friend in friends) {
        friend?.identify()
    }
}

class Person(private val firstName: String, private val lastName: String, private val age: Int) {
    // identidade da pessoa
    fun identify() {
        println("[$firstName, $lastName, $age]")
    }
}
  • Linha 6: cria um array de 3 elementos. A função [arrayOfNulls<Person>(3)] inicializa esses elementos com o valor [null], o que significa que eles não referenciam nenhum objeto: o tipo do array é, portanto, [Array<Person?>], um array de referências que podem conter o valor [null]. Coloquialmente, falamos em “array de objetos”, embora se trate apenas de um array de referências a objetos. A criação do array — que é ela própria um objeto — não cria nenhum objeto do mesmo tipo de seus elementos; isso deve ser feito posteriormente;
  • linhas 7–9: criação dos 3 objetos do tipo [Person];
  • linhas 11–12: exibição do conteúdo do array [friends]. A variável [friend] é do tipo [Person?]: o compilador exige a chamada segura [friend?.identify()], que não faz nada se [friend] for igual a [null].

Resultados:

1
2
3
4
> gradlew -q run -Pmain=classes11.Classes11Kt
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

O tipo de elemento [Person?] indica que um array criado vazio em Java contém [null]. Em Kotlin, isso é evitado criando-se o array já com seus elementos, como mostrado no parágrafo seguinte.

4.1.20. Inferência de tipos e inicialização de arrays

O programa [Classes12.kt] demonstra a sintaxe que simplifica a criação de objetos e arrays:

// inferência de tipo e inicialização de arrays
package classes12

fun main() {
    // o tipo da variável é inferido a partir da expressão que a inicializa
    val p1 = Person("Jean", "Dupont", 30)
    val p2 = Person()
    p2.firstName = "Arthur"
    p2.lastName = "Martin"
    p2.age = 7
    // um array criado e inicializado por uma lista de valores
    val friends = arrayOf(
        p1,
        p2,
        Person("Sylvie", "Vartan", 52),
        Person("Neil", "Armstrong", 66),
    )
    for (friend in friends) {
        println(friend.identity)
    }
    // um array criado na hora, passado como parâmetro
    display(arrayOf(Person("Pauline", "Leduc", 12), p1))
    // um array cujos elementos são calculados por uma lambda a partir de seu índice
    val children = Array(3) { i -> Person("Child${i + 1}", "Martin", i + 2) }
    display(children)
}

// uma função que recebe um array de pessoas
fun display(persons: Array<Person>) {
    for (p in persons) {
        println("Display : ${p.identity}")
    }
}

// todas as propriedades têm um valor padrão: Person() é possível
class Person(var firstName: String = "", var lastName: String = "", var age: Int = 0) {
    // identidade
    val identity get() = "[$firstName, $lastName, $age]"
}
  • Linha 6: o tipo da variável, [Person], é inferido a partir da expressão que a inicializa. A variável é, no entanto, tipada: [p1] só pode referenciar uma pessoa. Essa é a notação padrão em Kotlin desde o início do curso; o equivalente em Java é a palavra-chave [var]. Kotlin vai um passo além do Java: a inferência de tipos também se aplica às propriedades ([identity], linha 38) e ao tipo de retorno das funções cujo corpo é uma expressão;
  • linha 36: todas as propriedades têm um valor padrão. O construtor primário pode, portanto, ser chamado sem argumentos, [Person()] (linha 7), e a pessoa recebe então suas propriedades (linhas 8–10). Não é preciso declarar um construtor sem parâmetros;
  • Linhas 12–16: um array criado e preenchido pela função [arrayOf(...)], que recebe os valores dos elementos. O tamanho do array é o número de valores; seu tipo, [Array<Person>], é derivado do tipo dos valores: os elementos não podem ser do tipo [null]. Uma vírgula final (linha 16) é permitida em uma lista de argumentos, como em qualquer lista de parâmetros: ela facilita a adição de um elemento;
  • linha 18: a variável de laço [friend] é do tipo [Person]: desta vez, sem chamada segura;
  • linha 22: um array criado na hora e passado como parâmetro. Isso é chamado de array anônimo: ele não é referenciado por nenhuma variável na função [main]. Diferentemente do Java, não há diferença de sintaxe conforme o array seja criado em uma declaração ou em outro lugar;
  • linha 24: o construtor [Array(size) { i -> ... }] cria um array em que cada elemento é calculado pela lambda com base em seu índice [i];
  • linhas 29–31: uma função de nível superior que recebe um array de pessoas.

Resultados:

> gradlew -q run -Pmain=classes12.Classes12Kt
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display : [Pauline, Leduc, 12]
Display : [Jean, Dupont, 30]
Display : [Child1, Martin, 2]
Display : [Child2, Martin, 3]
Display : [Child3, Martin, 4]

Faremos pouco uso de arrays de objetos: o próximo capítulo apresenta as listas ([List], [MutableList]), que são mais flexíveis ([listOf(p1, p2)] é escrito como [arrayOf(p1, p2)]).

4.2. Herança por meio de exemplos

4.2.1. Visão geral

Aqui tratamos do conceito de herança. O objetivo da herança é “personalizar” uma classe existente para que ela atenda às nossas necessidades. Suponha que queiramos criar uma classe [Teacher]: um professor é um tipo específico de pessoa. Ele tem atributos que outras pessoas não têm: a disciplina que leciona, por exemplo. Mas também tem os atributos comuns a todas as pessoas: nome, sobrenome e idade. Um professor é, portanto, um membro de pleno direito da classe [Person] mas tem atributos adicionais. Em vez de criar uma classe [Teacher] do zero, preferimos partir da classe existente [Person] e adaptá-la às características específicas dos professores. Isso é possibilitado pelo conceito de herança.

Para indicar que a classe [Teacher] herda da classe [Person], escrevemos [class Teacher(...) : Person(...)]: o nome da classe pai vem depois dos dois-pontos, como em C#, enquanto Java escreve [extends Person].

[Person] é chamada de classe pai (ou classe base, ou superclasse), e [Teacher] é chamada de classe derivada (ou classe filha, ou subclasse). Um objeto [Teacher] tem todas as características de um objeto [Person]: tem as mesmas propriedades e os mesmos métodos. Essas propriedades e métodos da classe pai não são repetidos na definição da classe filha; basta especificar as propriedades e os métodos acrescentados pela classe filha. Uma classe Kotlin só pode herdar de uma única classe pai.

Uma diferença importante em relação ao Java: em Kotlin, uma classe é final por padrão, ou seja, não pode ser herdada. Para permitir a derivação, a classe pai deve ser declarada [open] (“aberta”). Essa é uma escolha deliberada dos projetistas da linguagem: uma classe deve ser projetada para ser derivada, e quem a escreve deve declarar isso explicitamente.

Os exemplos deste parágrafo são dois programas de vários arquivos, localizados nos pacotes [inheritance1] e [inheritance2]. No pacote [inheritance1], a classe [Person] é definida da seguinte forma em [Person.kt]:

package inheritance1

// open: a classe Person pode ter classes derivadas
open class Person(firstName: String, lastName: String, age: Int) {
    // propriedades verificadas pelo seu setter
    var firstName = ""
        set(value) {
            field = validate(value, "first name")
        }

    var lastName = ""
        set(value) {
            field = validate(value, "last name")
        }

    var age = 0
        set(value) {
            require(value >= 0) { "invalid age ($value)" }
            field = value
        }

    // identidade da pessoa
    val identity get() = "[$firstName, $lastName, $age]"

    // construção: inicialização pelos setters, contagem, rastreamento
    init {
        this.firstName = firstName
        this.lastName = lastName
        this.age = age
        nbPersons++
        println("Constructor Person(String, String, Int)")
    }

    companion object {
        // número de pessoas criadas
        var nbPersons = 0L
            private set
    }
}

// verificação de uma string obrigatória
private fun validate(value: String, label: String): String {
    require(value.isNotBlank()) { "invalid $label ($value)" }
    return value
}
  • linha 4: a classe é aberta ([open]): é possível derivar subclasses dela. O construtor primário tem três parâmetros, que não são propriedades (sem [val] nem [var]);
  • linhas 6–19: três propriedades cujos setters verificam o valor recebido (veja o programa [Classes07.kt]). As verificações do nome e do sobrenome, que são idênticas, foram extraídas para a função privada [validate] (linhas 42–44), como no programa [Classes09.kt];
  • linha 23: o método [identify] dos primeiros exemplos foi substituído pela propriedade calculada [identity], que retorna a identidade da pessoa em vez de exibi-la;
  • Linhas 26–31: o bloco [init] do construtor primário inicializa o objeto usando os setters das propriedades, incrementa o contador de pessoas e exibe uma mensagem de acompanhamento. Ele é colocado depois das declarações das propriedades: as inicializações das propriedades e os blocos [init] são executados na ordem em que foram escritos, e uma propriedade precisa ter sido inicializada (aqui com [""] ou 0) antes de poder ser usada;
  • linhas 34–37: o contador de pessoas da seção sobre o companion object.

Criamos uma classe [Teacher] que herda da classe [Person] [Teacher.kt]:

package inheritance1

// a classe Teacher deriva da classe Person:
// seu construtor primário passa três de seus parâmetros ao construtor da classe pai
class Teacher(firstName: String, lastName: String, age: Int, var section: Int) :
    Person(firstName, lastName, age) {

    // rastreamento
    init {
        println("Constructor Teacher(String, String, Int, Int)")
    }
}

A classe [Teacher] acrescenta às propriedades e aos métodos da classe [Person]:

  • linhas 5–6: a classe [Teacher] deriva da classe [Person]. O cabeçalho é escrito em duas linhas para caber na página;
  • linha 5: uma propriedade [section], declarada no construtor primário ([var section: Int]), que é o número da seção a que o professor pertence dentro da faculdade (aproximadamente uma seção por disciplina). A propriedade é de leitura e escrita: ela substitui o getter e o setter da versão Java;
  • Linhas 9–10: um bloco [init] que exibe uma mensagem de acompanhamento.

4.2.2. Criação de um objeto Teacher

Uma classe filha não herda os construtores da classe pai. Ela deve definir seus próprios construtores. O cabeçalho da classe [Teacher] é o seguinte:

class Teacher(firstName: String, lastName: String, age: Int, var section: Int) :
    Person(firstName, lastName, age) {

O construtor primário recebe quatro parâmetros ([firstName], [lastName], [age], [section]) e passa três ([firstName], [lastName], [age]) à sua classe pai — neste caso, a classe [Person] — usando a sintaxe [: Person(firstName, lastName, age)] (linha 2). Sabemos que essa classe tem um construtor, [Person(String, String, Int)], que nos permitirá criar uma pessoa com os parâmetros passados. Uma vez concluída a construção da parte [Person] (inicializações e blocos [init] da classe [Person]), a construção do objeto [Teacher] continua com a inicialização de sua propriedade [section] e a execução de seus próprios blocos [init]. A notação [: Person(firstName, lastName, age)] corresponde à instrução [super(firstName, lastName, age);] do construtor Java; se a classe derivada não tem construtor primário, cada um de seus construtores secundários chama o construtor da classe pai por meio de [constructor(...) : super(...)].

Em resumo, o construtor de uma classe derivada:

  • passa à sua classe pai os parâmetros de que ela precisa para se construir;
  • usa os demais parâmetros para inicializar suas próprias propriedades.

Talvez fosse preferível inicializar diretamente as propriedades [firstName], [lastName] e [age] diretamente na classe [Teacher], usando instruções como [this.firstName = firstName]. Isso é possível aqui porque essas propriedades são públicas e mutáveis, mas seria uma solução ruim e seria impossível se elas fossem privadas: os membros privados da classe [Person] são acessíveis apenas aos métodos da classe [Person]. Todos os outros objetos, inclusive os objetos de classes derivadas, como neste caso, devem acessá-los por meio de membros públicos (ou protegidos, como [protected]). Mais importante ainda, a parte [Person] do objeto deve, de qualquer forma, ser instanciada por um construtor da classe [Person]. Se você escrever [: Person()] sem argumentos, o compilador informa que faltam os parâmetros do construtor da classe pai:

1
2
3
4
5
6
7
8
9
Teacher.kt:6:5: error: no value passed for parameter 'firstName'.
    Person() {
    ^^^^^^
Teacher.kt:6:5: error: no value passed for parameter 'lastName'.
    Person() {
    ^^^^^^
Teacher.kt:6:5: error: no value passed for parameter 'age'.
    Person() {
    ^^^^^^

Usar o construtor da classe pai é, portanto, a solução correta e a abordagem padrão: ao criar um objeto filho, primeiro chama-se o construtor do objeto pai e depois completam-se as inicializações específicas do objeto filho ([section] em nosso exemplo).

Por fim, se você omitir a palavra-chave [open] antes da classe [Person], a derivação é rejeitada:

1
2
3
Teacher.kt:6:5: error: this type is final, so it cannot be extended.
    Person(firstName, lastName, age) {
    ^^^^^^

4.2.3. Métodos herdados

A classe [Teacher] não define uma propriedade chamada [identity]. A expressão [e.identity], em que [e] é um professor, refere-se, portanto, à propriedade [identity] herdada da classe [Person]: ela é pública e, por herança, torna-se uma propriedade pública da classe [Teacher]. O mesmo vale para os métodos. O programa de teste [Main.kt] do pacote [inheritance1] é o seguinte:

package inheritance1

fun main() {
    // um professor
    val e = Teacher("Lucile", "Dumas", 56, 61)
    // a propriedade identity herdada da classe Person
    println(e.identity)
    // a propriedade section específica da classe Teacher
    println("section=${e.section}")
    // uma pessoa
    val p = Person("Jean", "Dupont", 30)
    // a função display recebe uma Person ou um objeto de uma classe derivada
    display(e)
    display(p)
    // o método toString herdado da classe Any
    println(e.toString())
    println(p.toString())
    println("Number of persons created: ${Person.nbPersons}")
}

// exibe a identidade de p
fun display(p: Person) {
    println(p.identity)
}
  • linha 5: criação de um professor;
  • linha 7: exibição da identidade do professor, obtida por meio da propriedade [identity] herdada da classe [Person];
  • linha 9: a propriedade [section], específica da classe [Teacher];
  • linhas 13–14: chamada à função [display] (linhas 22–23) com um professor e depois com uma pessoa. Voltaremos a isso no próximo parágrafo;
  • linhas 16–17: chamada ao método [toString] nos dois objetos. Também voltaremos a isso.

Resultados:

> gradlew -q run -Pmain=inheritance1.MainKt
Constructor Person(String, String, Int)
Constructor Teacher(String, String, Int, Int)
[Lucile, Dumas, 56]
section=61
Constructor Person(String, String, Int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
inheritance1.Teacher@2f0e140b
inheritance1.Person@7440e464
Number of persons created: 2

Podemos observar que:

  • um objeto [Person] (linha 1 dos resultados) foi construído antes do objeto [Teacher] (linha 2);
  • [e.identity] forneceu a identidade da parte [Person] do professor, sem sua seção (linha 3);
  • o contador de pessoas também conta o professor (linha 10): um professor é uma pessoa.

Para obter a identidade completa de um professor, a classe [Teacher] deve definir sua própria propriedade [identity]. É isso que o pacote [inheritance2] faz.

4.2.4. Polimorfismo

Considere uma hierarquia de classes: C0 ← C1 ← C2 ← … ← Cn, em que Ci ← Cj indica que a classe Cj é derivada da classe Ci. Isso implica que a classe Cj tem todas as características da classe Ci, mais outras adicionais. Sejam Oi objetos do tipo Ci. É válido escrever [Oi = Oj] com j > i. De fato, por herança, a classe Cj tem todas as características da classe Ci, mais outras adicionais. Portanto, um objeto Oj do tipo Cj contém um objeto do tipo Ci. A operação [Oi = Oj] faz com que a variável Oi, do tipo Ci, referencie o objeto Oj: somente os membros definidos na classe Ci podem ser acessados por meio dela.

O fato de que uma variável Oi da classe Ci pode, na verdade, referenciar não apenas um objeto da classe Ci, mas qualquer objeto derivado da classe Ci é chamado de polimorfismo: a capacidade de uma variável de referenciar diferentes tipos de objetos.

Vejamos um exemplo e consideremos a função [display] do programa anterior:

1
2
3
fun display(p: Person) {
    println(p.identity)
}

Podemos passar a ela tanto uma *[Person] quanto um *[Teacher]: no segundo caso, o parâmetro formal [p], que é do tipo [Person], recebe um valor do tipo [Teacher]. Como o tipo [Teacher] é derivado do tipo [Person], isso é válido. A expressão [p.identity] usou aqui a propriedade [identity] da classe [Person], a única que existe no programa: para o professor (linha 6 dos resultados), obtemos apenas a identidade de sua parte “Person”.” Vejamos o que acontece quando a classe [Teacher] tem sua própria propriedade [identity].

4.2.5. Redefinição de métodos e ligação dinâmica

No pacote [inheritance2], a classe [Person] é a mesma do pacote [inheritance1], com duas alterações:

1
2
3
4
5
    // identidade da pessoa: open, pode ser sobrescrita em uma classe derivada
    open val identity get() = "[$firstName, $lastName, $age]"

    // sobrescrita do método toString da classe Any
    override fun toString() = identity
  • Linha 2: a propriedade [identity] é declarada como [open]: ela pode ser sobrescrita em uma classe derivada. Em Kotlin, métodos e propriedades são final por padrão, assim como as classes: somente os membros [open] de uma classe [open] podem ser sobrescritos;
  • linhas 4–5: uma sobrescrita do método [toString], tratada no parágrafo seguinte.

Na classe [Teacher], a propriedade [identity] é redefinida da seguinte forma:

package inheritance2

// uma classe Kotlin é final por padrão: a classe Teacher não pode ser derivada
class Teacher(firstName: String, lastName: String, age: Int, var section: Int) :
    Person(firstName, lastName, age) {

    // rastreamento
    init {
        println("Constructor Teacher(String, String, Int, Int)")
    }

    // a propriedade identity sobrescreve a da classe pai
    override val identity get() = "Teacher[${super.identity},$section]"
}
  • Linha 13: a propriedade [identity] sobrescreve a propriedade da classe pai; ela tem o mesmo nome e o mesmo tipo. Ela usa a propriedade [identity] de sua classe pai, designada como [super.identity], para obter a parte “Person” e a complementa com a seção específica da classe [Teacher]. Um método é redefinido da mesma forma: mesmo nome, mesmos parâmetros, mesmo tipo de retorno e a palavra-chave [override];
  • Linha 13: a palavra-chave [override] é obrigatória. Ela cumpre o mesmo papel da anotação [@Override] em Java, que é opcional: se a propriedade não redefinisse nada (por exemplo, um erro de digitação no nome ou um tipo diferente), o compilador relataria o erro em vez de criar silenciosamente um novo membro. Inversamente, uma redefinição sem *[override]* é rejeitada:
1
2
3
Teacher.kt:13:9: error: 'identity' hides member of supertype 'Person' and needs an 'override' modifier.
    val identity get() = "Teacher[${super.identity},$section]"
        ^^^^^^^^
  • e, se a propriedade [identity] da classe [Person] não for declarada como [open], a redefinição é rejeitada:
1
2
3
Teacher.kt:13:5: error: 'identity' in 'Person' is final and cannot be overridden.
    override val identity get() = "Teacher[${super.identity},$section]"
    ^^^^^^^^
  • Linha 3: a classe [Teacher] não é declarada como [open]: ela é final, como explicaremos um pouco mais adiante.

Considere um objeto [Teacher] [E]. Esse objeto contém um objeto [Person]:

Image

A propriedade [identity] é definida tanto na classe [Teacher] quanto em sua classe pai [Person]. A versão usada por [p.identity] é determinada em tempo de execução, com base no tipo real do objeto referenciado por [p], e não em tempo de compilação com base no tipo declarado da variável. Isso é conhecido como ligação dinâmica. Para executar [o.m()], a máquina virtual procura um método chamado [m] na seguinte ordem:

  • na classe do objeto [o];
  • em sua classe pai, se houver;
  • na classe-mãe de sua classe-mãe, se ela existir;
  • e assim por diante.

O mesmo vale para uma propriedade, cuja leitura envolve a chamada de seu acessor, que é um método. A herança permite, portanto, redefinir na classe-filha membros que tenham a mesma assinatura que os da classe-mãe. É isso que permite adaptar a classe-filha às suas próprias necessidades. O programa [Main.kt] do pacote [inheritance2] é o seguinte:

package inheritance2

fun main() {
    // um professor
    val e = Teacher("Lucile", "Dumas", 56, 61)
    display(e)
    // uma pessoa
    val p = Person("Jean", "Dupont", 30)
    display(p)
    // visto como uma Person, o professor continua sendo um professor
    val pe: Person = e
    println(pe.identity)
    println((e as Person).identity)
    // println(Any?) exibe o resultado do método toString do objeto
    println(e)
    println(p)
    // um array de pessoas de tipos diferentes
    val persons = arrayOf(p, e)
    for (person in persons) {
        println("${person::class.simpleName} : $person")
    }
}

// exibe a identidade de p
fun display(p: Person) {
    println(p.identity)
}

Resultados:

> gradlew -q run -Pmain=inheritance2.MainKt
Constructor Person(String, String, Int)
Constructor Teacher(String, String, Int, Int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(String, String, Int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

Desta vez, na linha 3 dos resultados, a função [display] exibiu corretamente a identidade completa do professor. As linhas 11 a 13 do programa mostram que, quando visto por meio de uma variável do tipo [Person] ou convertido em [Person] pelo operador [as] (o equivalente ao operador [(Person)] de Java), o professor continua sendo um professor: é sempre a propriedade [identity] da classe [Teacher] que é utilizada (linhas 6 e 7 dos resultados). A conversão altera o tipo da referência, não o do objeto.

Nesse aspecto, Kotlin está mais próximo de C# do que de Java. Em C#, um método só pode ser sobrescrito se for declarado virtual ([virtual]), e a sobrescrita é indicada por [override]; em Kotlin, [open] tem a mesma função que [virtual]. Em Java, por outro lado, todos os métodos podem ser sobrescritos por padrão, exceto os declarados como [final]. Em todos os casos, uma vez que o método é sobrescrito, a vinculação é dinâmica.

4.2.6. A classe Any e o método toString

A classe [Any] é a classe “mãe” de todas as classes Kotlin. Assim, quando você escreve [class Person], está escrevendo implicitamente [class Person : Any()]. Ela corresponde à classe Java [java.lang.Object]: em tempo de execução, na JVM, trata-se de fato de [Object].

A classe *[Any] define três métodos, todos *[open], dos quais todos os objetos herdam:

  • [toString(): String]: retorna uma representação textual do objeto. Por padrão, trata-se do nome completo da classe do objeto, seguido do caractere [@] e de um código hash escrito em hexadecimal;
  • [equals(other: Any?): Boolean]: indica se o objeto é “igual” ao objeto [other]. Por padrão, ele só é igual a si mesmo: o método compara referências, exatamente como o operador [===]. É o método chamado pelo operador [==];
  • [hashCode(): Int]: retorna um código hash do objeto, usado por dicionários e conjuntos (próximo capítulo). Os métodos [equals] e [hashCode] são tratados mais adiante.

O método [getClass()] da classe Java [Object] não é um método de [Any]: em Kotlin, a expressão [obj::class] retorna a descrição Kotlin da classe real do objeto (do tipo [KClass]), cuja propriedade [simpleName] é o nome da classe; [obj::class.java], ou [obj.javaClass], retorna a descrição Java ([Class]).

Foi o método [toString] da classe [Any] que foi usado pelas chamadas [e.toString()] e [p.toString()] do pacote [inheritance1]: [inheritance1.Teacher@2f0e140b] e [inheritance1.Person@7440e464] (linhas 8 e 9 dos resultados; os números variam de uma execução para outra). Embora não tenhamos redefinido o método [toString] nas classes [Person] e [Teacher] , o método [toString] da classe [Any] conseguiu exibir o nome da classe real do objeto.

No pacote [inheritance2], a classe [Person] redefine o método [toString]: [override fun toString() = identity]. A palavra-chave [override] também é obrigatória aqui. Voltemos ao programa [Main.kt] do pacote [inheritance2]:

1
2
3
4
5
6
7
8
    // println(Any?) exibe o resultado do método toString do objeto
    println(e)
    println(p)
    // um array de pessoas de tipos diferentes
    val persons = arrayOf(p, e)
    for (person in persons) {
        println("${person::class.simpleName} : $person")
    }

Na linha 2, a função [println(message: Any?)] aceita um parâmetro do tipo [Any?]; portanto, como [Any] é a superclasse de todas as classes, qualquer objeto (neste caso, um [Teacher]) pode ser passado. Ela imprime no console o resultado do método [toString] do objeto. Como a vinculação é dinâmica, é usado o método [toString] do objeto real, neste caso o herdado da classe [Person]. Esse método retorna [identity], uma propriedade redefinida: para o professor [e], é, portanto, a propriedade [identity] da classe [Teacher] que é utilizada, como mostra a linha 8 dos resultados. Portanto, é desnecessário redefinir [toString] na classe [Teacher].

O mesmo mecanismo se aplica aos templates de string: em ["... : $person"] (linha 7), o objeto [person] é convertido em string pelo seu método [toString]. O laço da linha 6 percorre um array de referências para [Person], que na verdade apontam para objetos de tipos diferentes: [person::class.simpleName] retorna o nome da classe real de cada objeto (linhas 10 e 11 dos resultados).

4.2.7. Classes final, open e sealed

A classe [Teacher] do pacote [inheritance2] é declarada como [class Teacher(...) : Person(...)], sem a palavra-chave [open]: ela é final. A declaração [class TeacherResearcher(...) : Teacher(...)] seria rejeitada pelo compilador com a mensagem já encontrada: [this type is final, so it cannot be extended]. Em Java, é o oposto: uma classe é aberta por padrão, e você a torna final com a palavra-chave [final]. A abordagem de Kotlin evita a criação acidental de subclasses de uma classe que não foi projetada para isso. O mesmo vale para os membros: um método ou uma propriedade só pode ser sobrescrito se for declarado como [open]. Um membro que sobrescreve outro ([override]) é, ele próprio, sobrescrevível nas classes derivadas seguintes, a menos que seja declarado como [final override].

Entre uma classe aberta a todas as derivações e uma classe final, Kotlin oferece — assim como Java desde a versão 17 — uma opção intermediária: a classe sealed ([sealed]), cujas classes derivadas diretas são todas conhecidas em tempo de compilação. O programa [Classes13.kt] ilustra isso:

// classes final, classes open e classes sealed
package classes13

fun main() {
    val persons = arrayOf(
        Teacher("Lucile", "Dumas", 61),
        Student("Paul", "Martin", "computer science"),
        Adjunct("Marc", "Petit"),
        Consultant("Lise", "Morel", "Airbus"),
    )
    for (p in persons) {
        println("${p::class.simpleName} : ${p.identity}")
    }
    // when sobre uma classe sealed: o compilador sabe que todos os casos são tratados
    for (p in persons) {
        println("${p.firstName} is ${description(p)}")
    }
    // as subclasses diretas permitidas da classe sealed Person
    println("Person is sealed: ${Person::class.java.isSealed}")
    for (c in Person::class.java.permittedSubclasses) {
        println("allowed subclass: ${c.simpleName}")
    }
}

// uma expressão when sem ramo else
fun description(p: Person): String = when (p) {
    is Teacher -> "a teacher in section ${p.section}"
    is Student -> "a student in ${p.major}"
    is Adjunct -> "an adjunct"
}

// uma classe sealed: suas classes derivadas diretas são todas conhecidas em tempo de compilação
sealed class Person(val firstName: String, val lastName: String) {
    open val identity get() = "[$firstName, $lastName]"
}

// uma classe derivada é final por padrão
class Teacher(firstName: String, lastName: String, val section: Int) : Person(firstName, lastName) {
    override val identity get() = "${super.identity}, section $section"
}

class Student(firstName: String, lastName: String, val major: String) : Person(firstName, lastName) {
    override val identity get() = "${super.identity}, major $major"
}

// open: a hierarquia volta a ser aberta a partir desta classe
open class Adjunct(firstName: String, lastName: String) : Person(firstName, lastName)

// uma classe derivada de Adjunct: permitido, pois Adjunct é open
class Consultant(firstName: String, lastName: String, val company: String) : Adjunct(firstName, lastName) {
    override val identity get() = "${super.identity}, company $company"
}
  • linha 33: a classe [Person] é sealed. Suas subclasses diretas devem ser declaradas no mesmo pacote e no mesmo módulo que ela (em qualquer arquivo desse pacote). Ao contrário de Java, não há uma lista de classes permitidas ([permits]): ela inclui todas as classes do pacote que são suas subclasses diretas, neste caso [Teacher], [Student], e [Adjunct]. Uma classe sealed é implicitamente abstract (veja adiante: não é possível criar objetos dessa classe, apenas de suas classes derivadas) e seu construtor é protected: ele se destina apenas às classes derivadas;
  • linha 34: a propriedade [identity] é open: as classes derivadas podem redefini-la;
  • Linhas 38 a 43: as classes [Teacher] e [Student] são final por padrão. Em Java, uma classe derivada de uma classe sealed deve ser declarada como [final], [sealed], ou [non-sealed]; em Kotlin, a regra padrão basta;
  • Linha 47: a classe [Adjunct] é aberta ([open]): ela reabre a hierarquia, permitindo que qualquer classe derive dela. Isso equivale ao [non-sealed] de Java. Uma terceira opção é declará-la, ela própria, como [sealed]. A classe não tem corpo: não há nada a acrescentar à classe [Person];
  • linha 50: a classe [Consultant] deriva de [Adjunct], o que é permitido;
  • linhas 5 a 9: o tipo do array, [Array<Person>], é inferido pelo compilador: é o tipo comum mais específico entre os quatro objetos;
  • linhas 26 a 29: a expressão [when], vista no capítulo anterior, testa aqui o tipo da pessoa usando o operador [is]. Em cada ramo, o compilador sabe que [p] é do tipo testado: [p.section] é aceito no ramo [is Teacher] sem conversão explícita. Isso é o “smart cast”, que é explicado com mais detalhes no final do capítulo. O mais importante é que a expressão [when] não tem ramo [else]: como a classe [Person] é sealed, o compilador sabe que toda pessoa é um [Teacher], um [Student] ou um [Adjunct], e que os três casos são tratados. Um consultor é um adjunto: ele é tratado pelo terceiro ramo;
  • linhas 19 a 21: a descrição Java da classe ([Person::class.java]) indica se ela é sealed ([isSealed]) e lista suas subclasses diretas permitidas ([permittedSubclasses]). Para uma classe sealed, o compilador Kotlin produz as mesmas informações que o compilador Java: na JVM, a classe [Person] é uma classe Java sealed.

Resultados:

> gradlew -q run -Pmain=classes13.Classes13Kt
Teacher : [Lucile, Dumas], section 61
Student : [Paul, Martin], major computer science
Adjunct : [Marc, Petit]
Consultant : [Lise, Morel], company Airbus
Lucile is a teacher in section 61
Paul is a student in computer science
Marc is an adjunct
Lise is an adjunct
Person is sealed: true
allowed subclass: Adjunct
allowed subclass: Student
allowed subclass: Teacher

Se você escrever uma classe [Artist] derivada de [Person] em outro pacote (neste caso, o pacote [others]), o compilador informa:

1
2
3
Artist.kt:6:53: error: a class can only extend a sealed class or interface declared in the same package.
class Artist(firstName: String, lastName: String) : Person(firstName, lastName)
                                                    ^^^^^^

E se removermos o ramo [is Adjunct] da expressão [when], o compilador informa que nem todos os casos estão sendo tratados:

1
2
3
Classes13.kt:26:38: error: 'when' expression must be exhaustive. Add the 'is Adjunct' branch or an 'else' branch.
fun description(p: Person): String = when (p) {
                                     ^^^^

Para que serve uma classe sealed? Ela permite que o autor de uma hierarquia de classes mantenha o controle sobre ela: o autor sabe que toda [Person] é um [Teacher], um [Student], ou um [Adjunct]. O compilador também sabe disso e tira proveito na expressão [when]: se uma quarta classe derivada de [Person] for adicionada mais tarde, todas as expressões [when] que não a tratam são sinalizadas durante a compilação. Um ramo como [else], por outro lado, teria mascarado essa omissão. Esse mecanismo também se aplica a interfaces ([sealed interface]), tratadas mais adiante, e é uma forma muito comum em Kotlin de modelar um conjunto fechado de casos: os resultados possíveis de uma operação (sucesso, falha), os estados de uma tela, as mensagens trocadas entre dois programas…

4.3. Sobrecarga de operadores

Algumas linguagens, como C# ou C++, permitem redefinir o significado dos operadores ([+], [==], [<]…) para uma classe. Java não permite isso: é preciso escrever métodos, como [a.add(b)] em vez de [a + b], [s1.equals(s2)] em vez de [s1 == s2], [a.compareTo(b) < 0] em vez de [a < b]. Kotlin permite isso de forma simples e controlada: cada operador corresponde a um método com nome fixo, e basta declarar um método com esse nome, precedido da palavra-chave [operator], para que o operador possa ser usado com objetos dessa classe. A expressão [a + b] é, assim, traduzida pelo compilador em [a.plus(b)]. Não é possível inventar novos operadores nem alterar sua precedência. As principais convenções são as seguintes:

Expressão
Traduzida para
Nota
[a + b], [a - b], [a * b], [a / b], [a % b]
[a.plus(b)], [a.minus(b)], [a.times(b)], [a.div(b)], [a.rem(b)]
operadores aritméticos
[-a], [+a], [!a]
[a.unaryMinus()], [a.unaryPlus()], [a.not()]
operadores unários
[a++], [a--]
[a.inc()], [a.dec()]
O método retorna o novo valor
[a += b]
[a.plusAssign(b)], ou então [a = a.plus(b)]
o mesmo vale para [-=], [*=]…
[a == b], [a != b]
[a?.equals(b) ?: (b === null)]
[equals] é herdado de [Any]: ele é redefinido como [override]
[a < b], [a <= b], [a > b], [a >= b]
[a.compareTo(b) < 0]…
[compareTo] retorna um inteiro negativo, zero ou positivo
[b in a], [b !in a]
[a.contains(b)], [!a.contains(b)]
pertinência
[a[i]], [a[i] = v]
[a.get(i)], [a.set(i, v)]
indexadores (próximo parágrafo)
[a(x)]
[a.invoke(x)]
um objeto “chamado” como uma função
[a..b]
[a.rangeTo(b)]
intervalos
[for (x in a)]
[a.iterator()]
iteração

Os operadores [===] e [!==], que comparam referências, não podem ser redefinidos. As classes da biblioteca padrão de Kotlin usam essas convenções e, graças às funções de extensão (tratadas mais adiante neste capítulo), Kotlin também as aplica a classes do JDK, como [BigDecimal]. Em uma classe Java, um método com o nome e a assinatura esperados ([compareTo], [get]…) também pode ser usado como operador sem a palavra-chave [operator].

4.3.1. Um exemplo

O pacote [lists] contém uma classe chamada [ListOfPersons], uma lista de pessoas, cujos métodos definem os operadores [+], [+=], [in], a iteração e os indexadores. As classes [Person] e [Teacher] deste pacote são versões simplificadas das do pacote [inheritance2]: as propriedades são somente leitura ([val]) e não há mais validações, mensagens de andamento nem contadores. A classe [Person] ganha um operador de comparação, [Person.kt]:

package lists

open class Person(val firstName: String, val lastName: String, val age: Int) {
    // identidade da pessoa
    open val identity get() = "[$firstName, $lastName, $age]"

    override fun toString() = identity

    // os operadores de comparação <, <=, >, >=: as pessoas são comparadas pela idade
    operator fun compareTo(other: Person) = age.compareTo(other.age)
}
  • Linha 10: o método [compareTo], declarado como [operator], define os quatro operadores [<], [<=], [>], e [>=] entre duas pessoas: [p1 < p2] é traduzido para [p1.compareTo(p2) < 0]. O método deve retornar um inteiro negativo se o objeto atual precede o objeto [other], zero se são equivalentes e um inteiro positivo nos demais casos. Aqui, as pessoas são comparadas pela idade: o método [compareTo] dos inteiros resolve o problema.

As pessoas são armazenadas em uma lista mutável do tipo [MutableList<Person>] (as listas são tratadas no próximo capítulo). Em vez de fazer a classe [ListOfPersons] herdar de uma classe de lista, colocamos a lista em uma propriedade privada da classe. Isso é chamado de usar composição em vez de herança: a classe *[ListOfPersons]* expõe, assim, apenas as operações que escolheu. Da lista, usamos apenas os seguintes elementos:

  • o método [l.add(p)], que adiciona a pessoa [p] à lista [l], e o método [l.addAll(l2)], que adiciona a ela todos os elementos da lista [l2];
  • a propriedade [l.size], que retorna o número de elementos da lista [l], e a propriedade [l.indices], o intervalo [0..size-1] de seus índices;
  • a notação [l[i]], que se refere ao elemento de número i da lista [l], tanto para leitura quanto para escrita: as listas Kotlin têm indexadores;
  • o método [l.iterator()], que retorna um iterador sobre os elementos da lista, e o método [l.joinToString(...)], que constrói uma string a partir de seus elementos.

A definição da classe [ListOfPersons] é a seguinte: [ListOfPersons.kt]:

package lists

class ListOfPersons {
    // as pessoas da lista
    private val persons = mutableListOf<Person>()

    // número de pessoas na lista
    val size get() = persons.size

    // o operador +: retorna uma nova lista contendo as pessoas
    // da lista atual e a pessoa p
    operator fun plus(p: Person): ListOfPersons {
        val result = ListOfPersons()
        result.persons.addAll(persons)
        result.persons.add(p)
        return result
    }

    // o operador +=: adiciona p à lista atual
    operator fun plusAssign(p: Person) {
        persons.add(p)
    }

    // o operador in: a lista contém uma pessoa com o sobrenome dado?
    operator fun contains(lastName: String) = indexOf(lastName) != -1

    // o operador de iteração: permite escrever for (p in list)
    operator fun iterator(): Iterator<Person> = persons.iterator()

    // os indexadores: list[i] para leitura e escrita
    operator fun get(i: Int) = persons[i]

    operator fun set(i: Int, p: Person) {
        persons[i] = p
    }

    // um segundo indexador de leitura: list[lastName] retorna a pessoa com esse sobrenome, ou null
    operator fun get(lastName: String): Person? {
        val i = indexOf(lastName)
        return if (i != -1) persons[i] else null
    }

    // posição da pessoa com o sobrenome dado, -1 se não houver nenhuma
    fun indexOf(lastName: String): Int {
        for (i in persons.indices) {
            if (persons[i].lastName == lastName) {
                return i
            }
        }
        return -1
    }

    // toString: retorna (person1,person2,...)
    override fun toString() = persons.joinToString(",", "(", ")")
}
  • linha 5: a lista de pessoas. A função [mutableListOf<Person>()] cria uma lista vazia e mutável de elementos do tipo [Person]. A palavra-chave [val] indica que a propriedade sempre se referirá à mesma lista; o conteúdo da lista pode mudar. Nenhuma importação é necessária: as listas fazem parte da biblioteca padrão de Kotlin e são importadas automaticamente;
  • Linha 8: o número de pessoas, como propriedade calculada;
  • Linhas 12 a 16: o método [plus] define o operador [+] para a operação [l + p], em que [l] é do tipo [ListOfPersons] e [p] é do tipo [Person] ou de um tipo derivado. Ele cria uma nova lista (linha 13), copia para ela as pessoas da lista atual (linha 14) e, em seguida, adiciona a pessoa [p] (linha 15). Como no operador [+] para números ou strings, os operandos não são modificados. Como a lista [result] é da mesma classe, o método tem acesso à sua propriedade privada [result.persons]. A lista retornada é do tipo [ListOfPersons], o que permite encadear operações como em [l + p1 + p2];
  • linhas 20 e 21: o método [plusAssign] define o operador [+=]: ele modifica a lista atual adicionando a ela a pessoa [p] e não retorna nada;
  • linha 25: o método [contains] define o operador [in]: ["leduc" in l] é traduzido para [l.contains("leduc")]. O parâmetro aqui é um nome; é o método [indexOf], tratado no parágrafo seguinte, que procura a pessoa;
  • linha 28: o método [iterator] permite percorrer a lista com um laço [for (p in l)]. Ele expõe o iterador da lista de forma privada, do tipo [Iterator<Person>], que permite apenas o acesso de leitura aos elementos;
  • linha 54: redefinimos o método [toString] para exibir uma lista de pessoas na forma (pessoa1, pessoa2, ...), em que pessoai é, ela própria, o resultado do método [toString] da pessoa. O método [joinToString(separator, prefix, postfix)] das listas constrói uma string a partir dos elementos sucessivos (convertidos em strings pelo seu método [toString]), separando-os pelo separador especificado (aqui, uma vírgula) e envolvendo-os com um prefixo e um sufixo (aqui, parênteses).

Observe que a classe [ListOfPersons] não tem construtor. Ela usa, portanto, o construtor padrão, que não recebe parâmetros e não faz nada além de inicializar a propriedade [persons] com o valor especificado em sua declaração. As linhas 30 a 50 são tratadas na seção seguinte.

O programa de teste [Main.kt] começa da seguinte forma:

package lists

import java.math.BigDecimal

fun main() {
    // --- os operadores de strings e de números BigDecimal
    val s1 = "jean"
    val s2 = StringBuilder("je").append("an").toString()
    println("s1 == s2 : ${s1 == s2}, s1 === s2 : ${s1 === s2}")
    println("s1 < \"paul\" : ${s1 < "paul"}, s1.compareTo(\"paul\") : ${s1.compareTo("paul")}")
    val a = BigDecimal("0.10")
    val b = BigDecimal("0.20")
    println("a + b = ${a + b}, a * b = ${a * b}, -a = ${-a}, a < b : ${a < b}")

    // --- o operador compareTo da classe Person
    val jean = Person("jean", "martin", 10)
    val pauline = Person("pauline", "leduc", 12)
    println("jean < pauline : ${jean < pauline}, jean >= pauline : ${jean >= pauline}")

    // --- o operador +
    // uma lista de pessoas
    var l = ListOfPersons()
    // adição de pessoas
    l = l + jean + pauline
    // exibição
    println("l=$l")
    // l + p retorna uma nova lista: l não é modificada
    val l2 = l + Person("louis", "durand", 8)
    println("l=$l")
    println("l2=$l2")

    // --- o operador +=
    val l3 = l
    // += modifica a lista referenciada por l3 (e por l), sem criar uma nova lista
    l3 += Teacher("camille", "germain", 27, 60)
    println("l=$l")
    // l e l3 continuam referenciando o mesmo objeto
    println("l3 === l : ${l3 === l}")

    // --- os operadores in e !in, iteração
    println("\"leduc\" in l : ${"leduc" in l}, \"xx\" !in l : ${"xx" !in l}")
    for (p in l) {
        print("${p.firstName} ")
    }
    println("(${l.size} persons)")
  • Linhas 7 a 10: duas strings com o mesmo conteúdo, mas distintas: a string [s2] é construída em tempo de execução. O operador [] compara o conteúdo (ele chama [equals]*), enquanto o operador *[=] compara as referências. Em Kotlin, portanto, duas strings são comparadas com [==], o que é um erro clássico em Java. O operador [<] compara duas strings com base na ordem dos códigos de seus caracteres: ele chama o método [compareTo], que aqui retorna um número negativo porque “jean” vem antes de “paul”;
  • Linhas 11 a 13: a classe [BigDecimal] do JDK (números decimais exatos, que usaremos para os valores monetários) contém apenas métodos: [add], [multiply], [negate], [compareTo]. A biblioteca padrão de Kotlin acrescenta os operadores unários [+], [*], [-]…: você escreve [a + b] em vez de [a.add(b)], e [-a] em vez de [a.negate()]. Os operadores de comparação, por outro lado, usam diretamente o método [compareTo] de [BigDecimal]. A importação da linha 3 é necessária: [BigDecimal] é uma classe do JDK;
  • linhas 16 a 18: os operadores de comparação definidos pelo método [compareTo] da classe [Person];
  • linha 22: criação de uma lista vazia de pessoas [l]. A variável é declarada como [var]: seu valor vai mudar;
  • linha 24: adiciona duas pessoas usando o operador [+], que retorna uma nova lista a cada vez;
  • linha 28: [l + p] cria uma nova lista, [l2]; a lista [l] permanece inalterada;
  • linha 35: um professor é adicionado usando o operador [+=], isto é, o método [plusAssign];
  • linha 41: os operadores [in] e [!in];
  • Linhas 42 a 45: percurso da lista com um laço [for], por meio do método [iterator] e da propriedade [size];
  • linha 26 e seguintes: um template de string contendo um objeto usa o método redefinido [toString] da classe [ListOfPersons].

Resultados (início):

> gradlew -q run -Pmain=lists.MainKt
s1 == s2 : true, s1 === s2 : false
s1 < "paul" : true, s1.compareTo("paul") : -6
a + b = 0.30, a * b = 0.0200, -a = -0.10, a < b : true
jean < pauline : true, jean >= pauline : false
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3 === l : true
"leduc" in l : true, "xx" !in l : true
jean pauline camille (3 persons)

Por que existem dois operadores, se [l = l + p] produz o mesmo resultado que [l += p]? O operador [+] cria uma nova lista, copia para ela todas as pessoas de [l] e, depois, [l] passa a se referir a essa nova lista, enquanto a antiga é descartada para o coletor de lixo. O operador [+=], definido por [plusAssign], adiciona a pessoa à lista existente, sem cópia. A linha 33 armazena uma segunda referência, [l3], à lista [l]; após a operação [l3 += ...], as duas referências continuam apontando para o mesmo objeto (linha 9 dos resultados), e a pessoa adicionada aparece em [l] (linha 8), o que prova que a lista não foi recriada. Para uma lista grande, ou dentro de um laço, a diferença de desempenho é significativa. A escolha entre os dois estilos se reflete na biblioteca: os objetos imutáveis [String] e [BigDecimal] retornam novos objetos; as listas mutáveis e [StringBuilder] são modificados.

Por que foi escrito [l3 += ...] e não [l += ...]? Porque [l] é uma variável [var]: para essa variável, [l += p] poderia significar tanto [l.plusAssign(p)] quanto [l = l.plus(p)], e o compilador se recusa a escolher:

1
2
3
4
5
Main.kt:35:7: error: ambiguity between assign operator candidates:
fun plus(p: Person): ListOfPersons
fun plusAssign(p: Person): Unit
    l += Teacher("camille", "germain", 27, 60)
      ^^

Com uma variável como [val] (ou [l3]), apenas a primeira tradução é possível. Na prática, uma classe define uma ou outra: [plus] para uma classe imutável, [plusAssign] para uma classe mutável. As listas Kotlin seguem essa regra: uma [List] (somente leitura) tem o operador [+], uma [MutableList] tem o operador [+=]; para uma [MutableList] referenciada por uma variável [var], o compilador informa a mesma ambiguidade.

A sobrecarga de operadores não deve ser usada em excesso: ela só faz sentido se o operador conservar seu significado habitual (adição, comparação, pertinência etc.). Nos demais casos, é preferível um método com nome explícito.

4.4. Indexadores: os operadores get e set

Aqui, continuamos a usar a classe [ListOfPersons]. Se *[l]* é um objeto [ListOfPersons] , queremos poder nos referir à pessoa de número i da lista *[l] tanto para leitura quanto para escrita, usando a notação de array ***[l[i]]***. C# chama isso de indexador. Java não permite isso: a notação [[i]] é reservada aos arrays em Java, e os métodos são escritos como [get(int i)] e [set(int i, value)]. Em Kotlin, esses dois métodos, declarados como [operator], definem a notação [l[i]]: [l[i]] é traduzido para [l.get(i)], e [l[i] = p] é traduzido para [l.set(i, p)]*. É assim que as listas e os dicionários Kotlin são usados como arrays.

    // os indexadores: list[i] para leitura e escrita
    operator fun get(i: Int) = persons[i]

    operator fun set(i: Int, p: Person) {
        persons[i] = p
    }

    // um segundo indexador de leitura: list[lastName] retorna a pessoa com esse sobrenome, ou null
    operator fun get(lastName: String): Person? {
        val i = indexOf(lastName)
        return if (i != -1) persons[i] else null
    }

    // posição da pessoa com o sobrenome dado, -1 se não houver nenhuma
    fun indexOf(lastName: String): Int {
        for (i in persons.indices) {
            if (persons[i].lastName == lastName) {
                return i
            }
        }
        return -1
    }
  • linha 2: o método [get] retorna a pessoa de número i da lista privada [persons], que é, ela própria, identificada pelo seu índice;
  • linhas 4 e 5: o método [set] atribui a ele a pessoa [p];
  • linhas 9 a 11: um segundo indexador, somente leitura (não há método [set(String, Person)]). O índice não é necessariamente um inteiro: [l["martin"]] retorna a pessoa de nome “martin” ou [null] se essa pessoa não estiver na lista. O tipo do resultado, [Person?], indica isso. Os dois métodos [get] são sobrecargas: o compilador escolhe com base no tipo do índice. Um indexador também pode ter vários parâmetros: [m[i, j]] é traduzido para [m.get(i, j)];
  • linhas 15 a 21: também queremos poder obter a posição na lista da pessoa com um determinado nome, ou -1 se essa pessoa não estiver na lista. O nome [indexOf] é o do método equivalente para listas e strings. O laço percorre os índices da lista ([persons.indices]); os nomes são comparados com o operador [==] (linha 17).

O programa de teste continua da seguinte forma:

    // --- os indexadores: os operadores get e set
    // alteração do elemento nº 1
    l[1] = Person("franck", "gallon", 5)
    // exibição do elemento nº 1
    println("l[1]=${l[1]}")
    // exibição da lista l
    println("l=$l")
    // busca de pessoas pelo sobrenome, com indexOf
    val names = arrayOf("martin", "germain", "xx")
    for (name in names) {
        val iname = l.indexOf(name)
        if (iname != -1) {
            println("Person($name)=${l[iname]}")
        } else {
            println("Person($name) does not exist")
        }
    }
    // a mesma busca com o indexador l[name]
    for (name in names) {
        println("l[\"$name\"]=${l[name] ?: "does not exist"}")
    }
}
  • linha 3: chamada ao método [set];
  • linha 5: chamada ao método [get];
  • Linha 11: chamada ao método [indexOf];
  • linha 13: chamada ao método [get] com um índice inteiro;
  • linha 20: chamada ao método [get] com um nome. O operador [?:] substitui o resultado [null] por uma mensagem.

Resultados (final):

1
2
3
4
5
6
7
8
9
...
l[1]=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist
l["martin"]=[jean, martin, 10]
l["germain"]=Teacher[[camille, germain, 27],60]
l["xx"]=does not exist

4.5. Valor e referência

4.5.1. Tipos básicos e classes

Outras linguagens, como C ou C#, oferecem estruturas além das classes: tipos cujas variáveis contêm diretamente os dados, e não uma referência a um objeto. Java não as tem: ela distingue entre os oito tipos primitivos ([int], [double], [boolean]…), cujas variáveis contêm o próprio valor, e os tipos de referência (classes, arrays…), cujas variáveis contêm uma referência a um objeto. Kotlin também não tem estruturas e, do ponto de vista do programador, nem sequer tem tipos primitivos: tudo é objeto; [Int], [Double] e [Boolean] são classes cujos métodos ([10.toString()], [age.coerceAtLeast(0)]) são chamados. Mas, como vimos no capítulo anterior, o compilador traduz os tipos básicos [Int], [Long], [Double], [Boolean], [Char]… nos tipos primitivos da JVM ([int], [long]…) sempre que possível: uma variável [Int] contém, então, o próprio valor. O programa [Classes14.kt] destaca a diferença em relação a uma classe:

// tipos e classes básicos: cópia de valor, cópia de referência
package classes14

fun main() {
    // duas variáveis do tipo Int
    val age1 = 10
    var age2 = age1
    println("age1=$age1, age2=$age2")
    // age2 é modificada
    age2 = 30
    // verificação de age1 e age2
    println("age1=$age1, age2=$age2")

    // um objeto op1
    val op1 = CPerson()
    op1.name = "paul"
    op1.age = 10
    println("op1=CPerson(${op1.name},${op1.age})")
    // um objeto op2
    val op2 = op1
    println("op2=CPerson(${op2.name},${op2.age})")
    // op2 é modificado
    op2.name = "nicole"
    op2.age = 30
    // verificação de op1 e op2
    println("op1=CPerson(${op1.name},${op1.age})")
    println("op2=CPerson(${op2.name},${op2.age})")

    // uma cópia explícita do objeto
    val op3 = CPerson()
    op3.name = op1.name
    op3.age = op1.age
    op3.age = 50
    println("op1=CPerson(${op1.name},${op1.age})")
    println("op3=CPerson(${op3.name},${op3.age})")
}

// classe CPerson: duas propriedades públicas modificáveis
class CPerson {
    var name = ""
    var age = 0
}
  • linhas 39 a 41: uma classe com duas propriedades públicas e mutáveis: [name], [age].

Resultados:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=classes14.Classes14Kt
age1=10, age2=10
age1=10, age2=30
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)
op1=CPerson(nicole,30)
op3=CPerson(nicole,50)

A declaração [val age1 = 10] (linha 6) reserva uma posição de memória que contém o inteiro 10: o valor de [age1] é o próprio inteiro. No caso da classe, o objeto ([name], [age]) é criado explicitamente pela chamada ao construtor [CPerson()] (linha 15). O objeto é colocado em uma área de memória gerenciada pelo coletor de lixo, o heap, e o valor de [op1] é o endereço (a referência) desse objeto.

Quando [var age2 = age1] é escrito no programa (linha 7), o valor de [age1], o inteiro 10, é copiado para [age2]: trata-se de uma cópia de valor. Modificar [age2] não modifica [age1] (linha 2 dos resultados). Considere agora a instrução [val op2 = op1] (linha 20). O valor de [op1] é copiado para [op2], mas, como esse valor é o endereço do objeto, o objeto em si não é duplicado: [op1] e [op2] se referem ao mesmo objeto. Se o objeto apontado por [op2] for modificado, o objeto apontado por [op1] também o será, já que são o mesmo (linhas 5 e 6 dos resultados). Para obter um segundo objeto, é preciso criá-lo e copiar para ele as propriedades do primeiro (linhas 30 a 32): modificar a cópia não modifica o original (linhas 7 e 8 dos resultados).

Image

Dessas explicações, podemos concluir que:

  • o valor de uma variável de um tipo básico ([Int], [Double]…) é o próprio dado;
  • O valor de uma variável de um tipo de classe é o endereço do objeto para o qual ela aponta;
  • A atribuição e a passagem de parâmetros sempre copiam o valor da variável: o dado, no caso de um tipo básico, e a referência, no caso de um objeto.

O compilador nem sempre pode usar um tipo primitivo da JVM. Uma variável do tipo [Int?] precisa poder conter um valor [null], o que um [int] não consegue, e um elemento de uma lista [List<Int>] precisa ser um objeto (os genéricos da JVM só aceitam tipos de referência; veja adiante): nesses casos, o inteiro é colocado dentro de um objeto [java.lang.Integer], o que Java chama de “autoboxing”. O programador Kotlin não precisa se preocupar com isso, com uma exceção: ele não deve comparar dois números com o operador [===], que compararia as referências dos objetos [Integer]. O compilador emite um aviso ([identity equality for arguments of types 'Int?' and 'Int?' is prohibited]) nesse caso. Os números são comparados com [==], que sempre compara os valores.

Para representar um tipo de dado composto simples (um ponto, uma cor, uma data, um valor monetário) tratado como um valor, usam-se classes imutáveis: seus objetos não podem ser modificados após a criação. Compartilhar uma referência a um objeto imutável é seguro: ninguém pode modificá-lo, e o objeto passa a se comportar como um valor. Duas ferramentas completam o sistema: o método [equals], chamado pelo operador [==], que compara dois objetos pelo conteúdo, e as data classes ([data class]), que declaram em uma única linha uma classe imutável dotada desse método. Esse é o assunto dos dois parágrafos seguintes.

4.5.2. Igualdade de dois objetos: equals e hashCode

Como vimos, o operador [===], quando aplicado a duas referências, indica se elas se referem ao mesmo objeto. O operador [] chama o método [equals], e o herdado de [Any]* faz o mesmo que *[=]. Para que dois objetos distintos com o mesmo conteúdo sejam considerados iguais, uma classe deve redefinir o método [equals] e, necessariamente junto com ele, o método [hashCode]. O programa [Classes15.kt] demonstra isso:

// igualdade de dois objetos: equals e hashCode
package classes15

import java.util.Objects

fun main() {
    val p1 = Person("paul", 10)
    val p2 = Person("paul", 10)
    val p3 = Person("nicole", 30)
    // === compara referências, == compara valores (método equals)
    println("p1 === p2 : ${p1 === p2}, p1 == p2 : ${p1 == p2}, p1 == p3 : ${p1 == p3}")
    // dois objetos iguais têm o mesmo código hash
    println("p1.hashCode() == p2.hashCode() : ${p1.hashCode() == p2.hashCode()}")
    // um conjunto (Set) não contém dois objetos iguais
    val persons = hashSetOf(p1, p2, p3)
    println("size of the set: ${persons.size}")
    println("the set contains (paul,10): ${Person("paul", 10) in persons}")
    // o operador == aceita o valor null
    val unknown: Person? = persons.find { it.name == "pierre" }
    println("unknown == p1 : ${unknown == p1}, unknown == null : ${unknown == null}")
}

class Person(val name: String, val age: Int) {
    // duas pessoas são iguais se tiverem o mesmo nome e a mesma idade
    override fun equals(other: Any?): Boolean {
        // mesmo objeto?
        if (this === other) {
            return true
        }
        // other é uma Person (e não null)?
        if (other !is Person) {
            return false
        }
        // comparação das propriedades: other agora é conhecido como uma Person
        return age == other.age && name == other.name
    }

    // código hash consistente com equals
    override fun hashCode() = Objects.hash(name, age)

    override fun toString() = "Person($name,$age)"
}
  • linhas 25 a 35: o método [equals] sobrescreve o da classe [Any]. Seu parâmetro é do tipo [Any?]: uma pessoa pode ser comparada com qualquer objeto, e até com [null]. O método segue um padrão clássico:
    • linhas 27 e 28: um objeto é igual a si mesmo;
    • linhas 31 e 32: a expressão [other !is Person] é verdadeira se [other] não referencia um objeto do tipo [Person] (ou de uma classe derivada), em particular se for igual a [null]. Retorna-se, então, [false];
    • Linha 35: as propriedades são comparadas. Após o teste da linha 31, o compilador sabe que [other] é um [Person]: [other.age] pode ser usado sem conversão. É o “smart cast” que já encontramos com a expressão [when]. Os nomes são comparados com [==], que chama o método [equals] das strings;
  • linha 39: o método [hashCode] retorna um inteiro calculado a partir das mesmas propriedades, neste caso pelo método [Objects.hash] do JDK (daí a importação na linha 4). A regra é obrigatória: dois objetos que são iguais no sentido de [equals] devem ter o mesmo código hash. Dicionários e conjuntos (próximo capítulo) organizam os objetos com base nesse código e deixariam de funcionar se a regra não fosse respeitada;
  • linha 11: [===] compara referências, enquanto [==] compara conteúdos. Em Java, escreveríamos [p1.equals(p2)]; em Kotlin, escrevemos [p1 == p2], o que é mais legível;
  • Linhas 15 a 17: um conjunto [HashSet], criado pela função [hashSetOf], nunca contém dois objetos iguais: adicionar [p2], que é igual a [p1], não tem efeito, e a busca por uma nova pessoa ([paul, 10]) com o operador [in] é bem-sucedida;
  • linhas 19 e 20: a função [find] das coleções retorna o primeiro elemento que satisfaz a condição dada pela lambda, ou [null] se não houver nenhum (as lambdas são tratadas no Capítulo 7). A variável [unknown] é, portanto, igual a [null]. O operador [==] aceita um operando [null]: [a == b] é traduzido para [a?.equals(b) ?: (b === null)]. Não há com que se preocupar quanto a uma exceção [NullPointerException], ao contrário da chamada Java [a.equals(b)] quando [a] é igual a [null].

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=classes15.Classes15Kt
p1 === p2 : false, p1 == p2 : true, p1 == p3 : false
p1.hashCode() == p2.hashCode() : true
size of the set: 2
the set contains (paul,10): true
unknown == p1 : false, unknown == null : true

Escrever [equals] e [hashCode] à mão é trabalhoso e sujeito a erros; o IntelliJ e o IDEA podem gerá-los (pelo menu “Code / Generate…”). As data classes, por outro lado, os fornecem automaticamente.

4.5.3. Objetos imutáveis

O programa [Classes16.kt] oferece três maneiras de definir dados imutáveis:

// objetos imutáveis: uma classe imutável, uma data class, uma value class
package classes16

fun main() {
    val a = Point(1, 2)
    // a.x = 5   // rejeitado: x é uma propriedade val
    val b = a.move(3, 4)
    println("a=$a, b=$b")

    // uma data class: toString, equals, hashCode, copy... são gerados
    val red = Color(255, 0, 0)
    val red2 = Color(255, 0, 0)
    println("red=$red, r=${red.r}")
    println("red == red2 : ${red == red2}, red === red2 : ${red === red2}")
    // uma cópia modificada: o método copy e argumentos nomeados
    val pink = red.copy(g = 128, b = 128)
    println("red=$red, pink=$pink")
    // desestruturação de um objeto de uma data class
    val (r, g, blue) = pink
    println("r=$r, g=$g, b=$blue")

    // uma value class: um Int encapsulado e verificado
    val age = Age(30)
    println("age=$age, age.value + 1 = ${age.value + 1}")
    try {
        val age2 = Age(-4)
        println("age2=$age2")
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
}

// uma classe imutável: propriedades val, sem setter; ela é final por padrão
class Point(val x: Int, val y: Int) {
    // não modificamos o ponto: retornamos um novo
    fun move(dx: Int, dy: Int) = Point(x + dx, y + dy)

    override fun toString() = "($x,$y)"
}

// uma data class: uma classe imutável declarada em uma linha
data class Color(val r: Int, val g: Int, val b: Int)

// uma value class: em tempo de execução, um objeto Age é na maioria das vezes um simples int
@JvmInline
value class Age(val value: Int) {
    init {
        require(value >= 0) { "invalid age ($value)" }
    }
}
  • linhas 34 a 38: uma classe imutável escrita à mão. Suas propriedades são somente leitura ([val]); ela é final (como todas as classes Kotlin por padrão), para que nenhuma classe derivada possa lhe acrescentar estado mutável. Para “mover” um ponto, o método [move] retorna um novo ponto (linha 36). A instrução [a.x = 5] (linha 6) seria rejeitada pelo compilador: ['val' cannot be reassigned];
  • linha 42: uma data class ([data class]). O cabeçalho [data class Color(val r: Int, val g: Int, val b: Int)] declara uma classe com três propriedades, um construtor de três parâmetros e os métodos [toString], [equals] e [hashCode], todos os quais usam as propriedades do construtor primário, além dos métodos [copy] e [component1], [component2] e [component3], apresentados adiante. É o equivalente Kotlin do record de Java, que surgiu muito antes dele; como as propriedades são declaradas com [val], a classe é imutável;
  • linha 13: uma propriedade é acessada pelo seu nome, [red.r];
  • linha 14: dois objetos com o mesmo conteúdo são iguais no sentido de [==], ainda que sejam distintos;
  • linha 16: como uma data class é imutável, ela não pode ser modificada; em vez disso, cria-se uma cópia na qual certas propriedades foram alteradas. Esse é o papel do método gerado [copy], em que o valor padrão de cada parâmetro é o valor atual da propriedade: com argumentos nomeados, especificam-se apenas as propriedades que mudam. Em Java, é preciso escrever à mão métodos “wither” ([withG(int g)]…) para obter o mesmo resultado;
  • Linha 19: desestruturação, como vista no capítulo anterior com pares: as três variáveis recebem os valores das três propriedades, na ordem especificada pelo construtor. Isso se baseia nos métodos gerados [component1], [component2] e [component3]. Os nomes das variáveis podem ser escolhidos livremente: escrevemos [blue] porque [b] já está em uso;
  • Linhas 45 a 48: uma value class ([value class]), anotada com [@JvmInline]. Ela tem uma única propriedade (neste caso, um inteiro) que “encapsula” para lhe dar um tipo próprio e regras de validação próprias: um [Age] não é simplesmente um [Int]; uma função que espera um *[Age] não aceitará um peso nem um número de filhos, e uma idade negativa é rejeitada pelo bloco *[init] (linha 26). A vantagem da value class é que, em tempo de execução, o compilador geralmente a substitui pelo valor encapsulado: uma variável do tipo [Age] é simplesmente um [int] da JVM, sem nenhum objeto criado no heap. Isso oferece a segurança de um tipo distinto sem o seu custo. Uma value class é imutável; ela tem [toString], [equals] e [hashCode] gerados, assim como uma data class.

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=classes16.Classes16Kt
a=(1,2), b=(4,6)
red=Color(r=255, g=0, b=0), r=255
red == red2 : true, red === red2 : false
red=Color(r=255, g=0, b=0), pink=Color(r=255, g=128, b=128)
r=255, g=128, b=128
age=Age(value=30), age.value + 1 = 31
invalid age (-4)

O [toString] gerado para uma data class exibe o nome da classe e suas propriedades (linha 2 dos resultados); o mesmo vale para a value class (linha 6). Observe aqui que uma data class é a maneira mais concisa de declarar um pequeno dado imutável: é o tipo que usaremos para as faixas do imposto na aplicação de exemplo deste capítulo. As data classes são tratadas em detalhes mais adiante.

4.6. Interfaces

4.6.1. Um primeiro exemplo

Uma interface é um conjunto de declarações de métodos (e, em Kotlin, de propriedades) que forma um contrato. Uma classe que decide implementar uma interface se compromete a fornecer uma implementação para todos os membros abstratos definidos na interface. O compilador verifica essa implementação.

Por exemplo, eis a definição (simplificada) da interface [Iterator<T>] da biblioteca padrão de Kotlin, que permite percorrer os elementos de uma coleção: [interface Iterator<out T> { operator fun next(): T; operator fun hasNext(): Boolean }]. Os métodos da interface são definidos apenas por suas assinaturas: não têm corpo e são implicitamente públicos e abstratos (a palavra-chave [out] será explicada na seção sobre genéricos; a palavra-chave [operator] indica que o laço [for] pode usar esses métodos). São as classes que implementam a interface que fornecem o código de seus métodos. Uma classe chamada [C] declara que implementa a interface listando-a após os dois-pontos, exatamente como uma classe-mãe, mas sem parênteses (uma interface não tem construtor): [class C : Iterator<String>], e deve então definir os dois métodos [override fun hasNext(): Boolean { ... }] e [override fun next(): String { ... }]. Enquanto Java distingue entre [extends] (herança) e [implements] (implementação), Kotlin, como C#, usa os mesmos dois-pontos; a palavra-chave [override] é obrigatória para implementar um membro de interface, assim como para sobrescrever um método da classe-mãe.

Uma convenção comum (embora não universal, pois nem o JDK nem a biblioteca Kotlin a seguem) é começar o nome de uma interface com a letra I. Os exemplos a seguir formam o pacote [statistics] (diretório [src/main/kotlin/statistics]). Considere a seguinte interface [IStats.kt]:

package statistics

// as estatísticas de uma série de valores
interface IStats {
    // média da série: uma propriedade abstrata
    val average: Double

    // desvio padrão da série
    val standardDeviation: Double
}

A interface [IStats] tem:

  • uma propriedade [average]: a média de uma série de valores;
  • uma propriedade [standardDeviation]: o desvio padrão dessa série.

Observe que não é especificado em lugar algum a qual série de valores se faz referência. Podem ser as notas médias de uma turma, as vendas médias mensais de um determinado produto, a temperatura média em um dado local… Esse é o princípio das interfaces: elas pressupõem a existência de membros no objeto, mas não a de dados específicos.

Enquanto a interface Java declarava dois métodos, [double average()] e [double standardDeviation()], a interface Kotlin declara duas propriedades abstratas, [val average: Double] e [val standardDeviation: Double]. Uma propriedade de interface nada diz sobre como o valor é obtido: uma classe de implementação pode armazená-lo em um campo, calculá-lo a cada leitura por meio de um acessor *[get]*, ou calculá-lo na primeira leitura e depois armazená-lo. É o que demonstram as duas classes seguintes. Uma propriedade [val] de interface promete apenas acesso de leitura; uma propriedade [var] prometeria, além disso, acesso de escrita.

Uma implementação possível da interface [IStats] poderia ser uma classe usada para armazenar as notas dos alunos de uma turma em uma determinada disciplina. Um aluno é caracterizado pela seguinte data class [Student]: [Student.kt]:

1
2
3
4
package statistics

// um aluno
data class Student(val firstName: String, val lastName: String)

O aluno é identificado por seu nome e sobrenome. A data class, apresentada acima (na seção “Objetos imutáveis”) e tratada em detalhes mais adiante, pode ser resumida em uma única linha: ela substitui o record da versão Java. Uma nota é representada pela seguinte data class: [Grade] [Grade.kt]:

1
2
3
4
5
6
package statistics

// a nota de um aluno
data class Grade(val student: Student, val value: Double) {
    override fun toString() = "[${student.firstName},${student.lastName},$value]"
}

A nota é definida pelo aluno avaliado e pela nota propriamente dita. A classe redefine o método [toString] gerado pelo compilador para exibir uma nota na forma [firstName,lastName,value]. Observe a forma [fun f() = expression]: uma função cujo corpo consiste em uma única expressão pode ser escrita com o símbolo [=], sem chaves nem [return], caso em que o tipo do resultado é inferido a partir da expressão.

As notas de todos os alunos de uma determinada disciplina são reunidas na seguinte classe [ArrayOfGrades]:

package statistics

import kotlin.math.pow
import kotlin.math.sqrt

// notas armazenadas em um array, fixadas na construção
class ArrayOfGrades(val subject: String, val grades: Array<Grade>) : IStats {
    // implementação das propriedades da interface IStats:
    // a média e o desvio padrão são calculados uma vez por todas, na construção
    override val average: Double =
        if (grades.isNotEmpty()) grades.sumOf { it.value } / grades.size else -1.0

    override val standardDeviation: Double =
        if (grades.isNotEmpty()) sqrt(grades.sumOf { (it.value - average).pow(2) } / grades.size) else -1.0

    override fun toString() = "subject=$subject, grades=${grades.contentToString()}"
}
  • Linha 7: a classe [ArrayOfGrades] implementa a interface [IStats], listada após os dois-pontos. Ela deve, portanto, implementar as propriedades [average] e [standardDeviation]. Seu construtor primário declara duas propriedades somente leitura: a disciplina para a qual o objeto armazena as notas e o array de notas;
  • linhas 10 a 14: a implementação das duas propriedades da interface, precedidas da palavra-chave [override]. Supomos aqui que as notas passadas ao construtor não mudarão depois. Portanto, a média e o desvio padrão dessas notas são calculados imediatamente e armazenados nos campos das propriedades: os inicializadores das propriedades são executados quando o objeto é construído, na ordem em que foram escritos, o que permite que o cálculo do desvio padrão use a média já calculada. Em Java, teriam sido necessários quatro campos ([final]) e um construtor para obter o mesmo resultado;
  • linha 11: [if] é uma expressão Kotlin: ela substitui o operador Java [condition ? value1 : value2] e define a média de um array vazio como -1. A função de extensão [sumOf] para arrays e coleções soma os valores que a lambda [{ it.value }] calcula para cada elemento (as lambdas são tratadas no Capítulo 7; [it] designa ali o elemento atual): ela substitui o laço acumulador [for] da versão Java;
  • linha 14: [x.pow(2)] calcula x², e [sqrt] calcula a raiz quadrada. São funções do pacote [kotlin.math], importadas nas linhas 3 e 4; elas substituem os métodos estáticos [Math.pow] e [Math.sqrt] de Java (que continuam utilizáveis);
  • linha 16: o método [toString] usa a função de extensão de arrays [contentToString], que retorna os elementos do array entre colchetes, separados por vírgulas, com cada elemento convertido em string pelo seu método [toString], aqui o da classe [Grade]. Isso equivale ao método estático [Arrays.toString] de Java. O [toString] de um array Kotlin, como o de um array Java, exibe apenas seu tipo e um código hash.

Na classe anterior, as notas eram armazenadas em um array. Não era possível adicionar uma nova nota depois que o objeto [ArrayOfGrades] era construído. Propomos agora uma segunda implementação da interface [IStats], chamada [ListOfGrades], na qual, desta vez, as notas são armazenadas em uma lista, com a possibilidade de adicionar notas após a construção inicial dos objetos [ListOfGrades] e [ListOfGrades.kt] :

package statistics

import kotlin.math.pow
import kotlin.math.sqrt

// notas armazenadas em uma lista, à qual notas podem ser adicionadas
class ListOfGrades(val subject: String, grades: List<Grade>) : IStats {
    // a lista mutável privada: uma cópia da lista recebida
    private val _grades = grades.toMutableList()

    // a visão pública somente leitura dessa lista
    val grades: List<Grade>
        get() = _grades

    // média e desvio padrão em cache (null: ainda não calculados)
    private var averageCache: Double? = null
    private var standardDeviationCache: Double? = null

    // adição de uma nota
    fun add(grade: Grade) {
        _grades.add(grade)
        // a média e o desvio padrão precisarão ser recalculados
        averageCache = null
        standardDeviationCache = null
    }

    // média das notas: calculada na primeira solicitação
    override val average: Double
        get() = averageCache ?: computeAverage().also { averageCache = it }

    // desvio padrão das notas: calculado na primeira solicitação
    override val standardDeviation: Double
        get() = standardDeviationCache ?: computeStandardDeviation().also { standardDeviationCache = it }

    private fun computeAverage(): Double =
        if (_grades.isEmpty()) -1.0 else _grades.sumOf { it.value } / _grades.size

    private fun computeStandardDeviation(): Double {
        if (_grades.isEmpty()) return -1.0
        val m = average
        return sqrt(_grades.sumOf { (it.value - m).pow(2) } / _grades.size)
    }

    override fun toString() = "subject=$subject, grades=$_grades"
}
  • Linha 7: a classe [ListOfGrades] implementa a interface [IStats]. O parâmetro do construtor [grades] não é precedido de [val]: é um simples parâmetro usado apenas para inicializar a propriedade da linha 9;
  • Linha 9: as notas agora são colocadas em uma lista mutável ([MutableList<Grade>]), uma cópia da lista recebida, feita pela função de extensão [toMutableList]. Kotlin distingue entre coleções somente leitura ([List]) e coleções mutáveis ([MutableList]); a cópia garante que o chamador não possa modificar, pelas nossas costas, a lista armazenada pelo objeto (veja o Capítulo 5);
  • linhas 12 e 13: a lista é exposta como o tipo [List<Grade>], que é somente leitura: o código externo pode ler as notas, mas não pode adicionar novas sem chamar o método [add]. Esse par formado por uma propriedade privada [_grades] e uma propriedade pública [grades] de um tipo mais restrito é um idioma Kotlin comum, conhecido como “backing property”;
  • linhas 20 a 24: agora podemos adicionar uma nota às já armazenadas. A média e o desvio padrão não são mais calculados na construção, mas sob demanda, dentro dos acessores das propriedades da interface: [average] (linhas 28 e 29) e [standardDeviation] (linhas 32 e 33). Uma vez calculados, esses valores são armazenados para que não sejam recalculados a cada solicitação: diz-se que ficam em cache. Adicionar uma nota invalida o cache;
  • linhas 16 e 17: o cache. Seu tipo, [Double?], é um tipo anulável (Capítulo 3): o valor [null] significa “ainda não calculado”. Enquanto Java usava a classe wrapper *[Double] para ter acesso ao valor *[null], Kotlin simplesmente acrescenta um ponto de interrogação ao tipo;
  • Linha 29: o acessor é lido assim: o valor em cache, se não for [null] (operador Elvis [?:]), caso contrário o resultado de ***[computeAverage()]***, que a função *[also] armazena no cache antes de retorná-lo. [x.also { ... }] executa o bloco com [it = x] e depois retorna [x]: ela serve para enxertar uma ação secundária (neste caso, o cache) em uma expressão. O compilador sabe que o resultado da expressão nunca é [null]: ele é do tipo [Double]*, como exige a interface;
  • linhas 35 a 41: os dois cálculos, escritos com [sumOf]. Observe, na linha 39, o estilo de “saída antecipada”: a função retorna -1 imediatamente se a lista estiver vazia;
  • linha 44: o [toString] de uma lista exibe seus elementos entre colchetes, sem necessidade de uma função especial.

Um programa de teste poderia ser como o seguinte [Main.kt]:

package statistics

fun main() {
    // alguns alunos e suas notas de inglês
    val students = arrayOf(Student("Paul", "Martin"), Student("Maxime", "Germain"), Student("Berthine", "Samin"))
    val grades = arrayOf(Grade(students[0], 14.0), Grade(students[1], 16.0), Grade(students[2], 18.0))
    // que são registradas em um objeto ArrayOfGrades
    val english = ArrayOfGrades("English", grades)
    // exibição da média e do desvio padrão
    displayStats(english)
    // as mesmas notas em um objeto ListOfGrades
    val french = ListOfGrades("French", grades.toList())
    displayStats(french)
    // adicionamos uma nota
    french.add(Grade(Student("Jérôme", "Jaric"), 10.0))
    displayStats(french)
    // uma variável pode ter uma interface como tipo
    var stats: IStats = english
    println("English average: ${stats.average}")
    stats = french
    println("French average: ${stats.average}")
}

// exibição da média e do desvio padrão de um objeto que implementa IStats
fun displayStats(values: IStats) {
    println("$values, Average=${values.average}, Standard deviation=${values.standardDeviation}")
}
  • linha 5: cria um array de alunos usando a função [arrayOf];
  • linha 6: criação de um array de notas. As notas são escritas como [14.0], e não [14]: Kotlin não converte implicitamente um [Int] em um [Double], e o construtor de [Grade] espera um [Double];
  • linha 8: um objeto [ArrayOfGrades] cuja média e cujo desvio padrão são exibidos na linha 10;
  • linha 12: um objeto [ListOfGrades], cuja média e cujo desvio padrão são exibidos na linha 13. A função de extensão [toList] converte o array em uma lista; a classe [ListOfGrades] cria uma cópia modificável dela. Em Java, seria preciso escrever [new ArrayList<>(List.of(grades))];
  • linha 15: adiciona uma nova nota e, em seguida, atualiza a exibição;
  • Linhas 25 e 26: a função [displayStats] recebe como parâmetro um tipo [IStats], que é um tipo de interface. Isso significa que o parâmetro real pode ser qualquer objeto que implemente a interface [IStats]. Ao usar um dado de um tipo de interface, apenas os membros da interface implementados por esse objeto são utilizados. O restante é ignorado. Essa propriedade é semelhante ao polimorfismo que vimos com as classes. Se um conjunto de classes Ci que não estão relacionadas entre si por herança (e que, portanto, não podem usar o polimorfismo baseado em herança) tem um conjunto de métodos com a mesma assinatura, pode ser útil agrupar esses métodos em uma interface I que todas as classes envolvidas implementariam. As instâncias dessas classes Ci podem então ser usadas como parâmetros reais de funções que aceitam um parâmetro formal do tipo I, isto é, funções que usam apenas os membros dos objetos Ci definidos na interface I, e não as propriedades e os métodos específicos das diversas classes Ci;
  • linhas 18 a 21: uma variável pode ser do tipo de uma interface. Ela pode, então, se referir a qualquer objeto de uma classe que implemente a interface. O compilador permite o acesso apenas aos membros da interface (e aos da classe *[Any]*, como [toString]*). O tipo deve ser especificado aqui; sem ele, o compilador teria inferido o tipo [ArrayOfGrades]* a partir do valor inicial, e a atribuição da linha 20 teria sido rejeitada.

O pacote contém duas funções de nível superior, [main] e [displayStats], definidas no arquivo [Main.kt]: a classe JVM que as contém se chama, portanto, [statistics.MainKt].

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=statistics.MainKt
subject=English, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=French, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=French, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0], [Jérôme,Jaric,10.0]], Average=14.5, Standard deviation=2.958039891549808
English average: 16.0
French average: 14.5

Em um template de string, um número [Double] é convertido em string pelo método [Double.toString] da JVM, que sempre escreve o número com um ponto decimal e pelo menos uma casa decimal (16.0), independentemente do idioma da estação de trabalho. Para uma exibição no estilo francês, use ["%.2f".format(x)], como no exemplo a seguir.

Por fim, observe que as interfaces podem ser implementadas várias vezes; ou seja, é possível escrever [class DerivedClass : BaseClass(), I1, I2, ..., In], em que as Ij são interfaces: uma classe herda de apenas uma classe (cujo construtor é chamado, daí os parênteses), mas pode implementar quantas interfaces quiser. Uma interface pode, ela própria, herdar de uma ou mais outras interfaces: [interface I3 : I1, I2].

4.6.2. Métodos de interface com corpo

Uma interface Kotlin pode fornecer uma implementação padrão para alguns de seus métodos: basta dar-lhes um corpo, sem nenhuma palavra-chave específica (Java exige a palavra-chave [default]). Uma classe que implementa a interface pode, então, usar essa implementação ou fornecer a sua própria. Isso permite, por exemplo, adicionar um método a uma interface já publicada sem exigir que todas as classes que a implementam sejam modificadas. Uma propriedade de interface pode, da mesma forma, ter um acessor padrão [get]. Uma interface também pode conter funções privadas. No entanto, Kotlin não tem membros estáticos ([static]), nem em interfaces nem em classes: seu papel é cumprido pelo objeto companheiro ([companion object]), tratado acima, que uma interface pode ter assim como uma classe. O programa [Classes17.kt] fornece um exemplo:

package classes17

import kotlin.math.PI

// interfaces: métodos com corpo padrão, membros "estáticos" (companion object),
// funções privadas, implementação de várias interfaces
fun main() {
    val shapes = arrayOf(Square(2.0), Circle(1.0), IShape.unitSquare())
    for (shape in shapes) {
        println(shape.description())
    }
    // o método padrão é herdado pela classe Square
    val square = Square(3.0)
    println(square.description())
    // uma classe que implementa duas interfaces
    val redSquare = ColoredSquare(1.5, "red")
    println(redSquare.description())
    println("name=${redSquare.name}, color=${redSquare.color}")
}

interface IShape {
    // método abstrato: a ser implementado
    fun area(): Double

    // método com implementação padrão
    fun description(): String = "${this::class.simpleName} of area ${formatNumber(area())}"

    // propriedade com getter padrão (uma interface não tem campo de apoio)
    val name: String
        get() = "shape"

    // função privada: utilizável apenas pelos métodos da interface
    private fun formatNumber(value: Double) = "%.2f".format(value)

    // o companion object da interface: seus membros são chamados com o nome da interface
    companion object {
        fun unitSquare(): IShape = Square(1.0)
    }
}

// Square usa a implementação padrão de description
open class Square(private val side: Double) : IShape {
    override fun area() = side * side
}

// Circle fornece sua própria implementação de description
class Circle(private val radius: Double) : IShape {
    override fun area() = PI * radius * radius

    override fun description() = "Circle of radius %s and area %.2f".format(radius, area())
}

// uma segunda interface, que também tem um método description padrão
interface IColored {
    // propriedade abstrata: a ser implementada
    val color: String

    fun description(): String = "$color object"
}

// uma classe derivada de Square que também implementa IColored:
// ela herda dois métodos description e deve, portanto, sobrescrevê-lo
class ColoredSquare(side: Double, override val color: String) : Square(side), IColored {
    override fun description() = "${super<Square>.description()}, ${super<IColored>.description()}"

    override val name = "colored square"
}
  • linhas 21 a 37: a interface [IShape]:
    • linha 23: um método abstrato [area], a ser implementado;
    • linha 26: um método [description] com uma implementação padrão. Essa implementação pode usar os demais métodos da interface ([area], [formatNumber]). A expressão [this::class.simpleName] retorna o nome simples da classe do objeto ([Square]): [this::class] é a classe Kotlin ([KClass]) do objeto, equivalente a [getClass()] em Java;
    • linhas 29 e 30: uma propriedade com um acessor padrão. Uma interface não tem estado: ela não pode armazenar um valor e, portanto, uma propriedade de interface nunca tem um campo. Ela é abstrata ou calculada por um acessor;
    • linha 33: uma função privada, acessível apenas pelos métodos da interface. ["%.2f".format(value)] formata o número com duas casas decimais, seguindo as convenções da localidade do sistema (neste caso, a vírgula decimal francesa). A função de extensão de strings [format] é o equivalente Kotlin de [String.format];
    • linhas 36 e 37: o objeto companheiro da interface. Seu método [unitSquare] é chamado usando o nome da interface: [IShape.unitSquare()] (linha 8), exatamente como o método estático da versão Java. Trata-se de uma fábrica;
  • Linhas 42 e 43: a classe [Square] implementa apenas [area]; ela usa o método [description] por padrão. Ela é declarada como [open] porque uma classe herda dela mais adiante. Em Java, a classe [Square] teria precisado ser declarada como [static] porque a interface cria quadrados; em Kotlin, as classes declaradas em um arquivo são todas de nível superior, portanto esse problema não existe;
  • Linhas 47 a 50: a classe [Circle] fornece seu próprio método [description]. O formato [%s] insere o raio convertido em string por [Double.toString] (“1.0”), enquanto o formato [%.2f] insere a área com duas casas decimais. A constante [PI] vem do pacote [kotlin.math];
  • linha 14: o método padrão é herdado pela classe [Square] como qualquer outro método: ele pode ser chamado em uma variável do tipo [Square];
  • linhas 54 a 58: uma segunda interface, com uma propriedade abstrata [color] e um método padrão [description], com a mesma assinatura que o de [IShape];
  • linhas 63 a 66: a classe [ColoredSquare] deriva de [Square] (que implementa [IShape]) e implementa [IColored]. Ela herda, portanto, dois métodos [description] por padrão. O compilador exige então que a classe redefina o método; caso contrário, ele a rejeita (veja adiante). O novo método pode chamar qualquer uma das versões herdadas usando a sintaxe [super<Type>.method()], em que [Type] é a classe-mãe ou a interface cuja versão se deseja: na linha 64, o método combina as duas. Java escreve [I1.super.method()];
  • linha 63: a propriedade abstrata [color] da interface [IColored] é implementada diretamente no construtor primário por [override val color: String];
  • linha 66: a propriedade [name] da interface [IShape], que tinha um acessor padrão, é redefinida como uma propriedade com campo: a própria classe pode armazenar um valor.

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=classes17.Classes17Kt
Square of area 4,00
Circle of radius 1.0 and area 3,14
Square of area 1,00
Square of area 9,00
ColoredSquare of area 2,25, red object
name=colored square, color=red

Eis os erros que o compilador gera quando uma classe [C] implementa duas interfaces, [I1] e [I2], cada uma com um método [fun f() = ...] , sem redefini-lo, e quando uma interface tenta inicializar uma propriedade ([val counter: Int = 0]):

Error17.kt:9:1: error: class 'C' must override 'f' because it inherits multiple interface methods for it.
Error17.kt:12:24: error: property initializers in interfaces are prohibited.

Ao contrário de uma classe abstrata, uma interface não tem, portanto, estado: ela não pode declarar propriedades armazenadas. As constantes, que em Java são campos [static final] da interface, são colocadas em Kotlin dentro de seu objeto companheiro ([const val]).

Por fim, para os leitores vindos de Java, observe que um método de interface Kotlin com corpo é compilado (desde o Kotlin 2.2) em um método [default] da interface Java gerada: uma classe Java pode, portanto, implementar uma interface Kotlin sem reescrever esses métodos.

4.7. Classes abstratas

Uma classe abstrata é uma classe que não pode ser instanciada. É preciso criar classes derivadas, que então podem ser instanciadas. As classes abstratas podem ser usadas para fatorar código em uma linhagem de classes. Examinemos o exemplo a seguir, que forma o pacote [users] [User.kt]:

package users

// uma classe abstrata: ela não pode ser instanciada
abstract class User protected constructor(
    private val login: String,
    private val password: String,
) {
    // o papel do usuário, obtido pelo método abstrato identify
    // usuário não identificado: exceção
    private val role: String = identify() ?: throw UnknownUserException("[$login,$password]")

    override fun toString() = "User[$login,$password,$role]"

    // identificação: retorna o papel do usuário ou null se não for reconhecido
    protected abstract fun identify(): String?
}
  • Linha 4: a classe é declarada abstrata com a palavra-chave [abstract]. Uma classe abstrata é implicitamente aberta à herança: não é preciso acrescentar [open];
  • Linhas 4 a 6: o construtor primário da classe [User]. Essa classe armazena informações sobre os usuários de uma aplicação web. A aplicação tem vários tipos de usuários, que são autenticados por um nome de usuário e uma senha (linhas 5 e 6). Essas duas informações são verificadas em um diretório (LDAP) para alguns usuários, em um banco de dados para outros, e assim por diante. Para tornar visível o construtor primário, é preciso incluir explicitamente a palavra-chave [constructor] após o nome da classe: [protected constructor(...)]. O construtor é [protected]: ele se destina aos construtores das classes derivadas. A vírgula após o último parâmetro (linha 6) é permitida: ela facilita a adição de um parâmetro posteriormente;
  • linha 10: as informações são verificadas por um método chamado [identify]. Como o método de identificação não é conhecido neste nível, ele é declarado abstrato (linha 15) com a palavra-chave [abstract]. Um método abstrato não tem corpo: as classes derivadas fornecerão um. Uma classe que tem um método abstrato deve, ela própria, ser declarada abstrata. O método [identify] retorna uma string que especifica o papel do usuário (basicamente, o que ele está autorizado a fazer) ou [null] se o usuário não for reconhecido: seu tipo é, portanto, [String?];
  • Linha 10: se o usuário não for reconhecido, uma exceção é lançada. O operador Elvis [?:] avalia a expressão como o papel retornado por [identify] se não for [null]e, caso contrário, executa a expressão à direita, neste caso [throw UnknownUserException(...)]. Em Kotlin, [throw] é uma expressão (do tipo [Nothing]), o que permite essa sintaxe compacta. A propriedade [role] é do tipo [String] e não anulável: o compilador sabe que ela não pode ser [null]. Nenhuma cláusula [throws] é necessária: Kotlin não tem exceções verificadas (Capítulo 3);
  • linha 12: o método *[toString],* que identifica uma instância da classe.

Supomos aqui que o desenvolvedor deseja controlar a construção das instâncias da classe [User] e de suas classes derivadas, talvez porque queira garantir que uma exceção de um certo tipo seja lançada se o usuário não for reconhecido. As classes derivadas poderão contar com esse construtor. Para isso, elas devem fornecer o método [identify]. Observe que a inicialização da propriedade [role], que faz parte da construção do objeto, chama um método redefinido pelas classes derivadas, ainda que essas classes não tenham realizado sua própria inicialização: o método *[identify] não deve, portanto, usar propriedades da classe derivada, que ainda não foram inicializadas (uma propriedade não anulável poderia até valer *[null] nesse momento!). Essa é uma prática que deve ser tratada com cautela. O compilador Kotlin não a sinaliza; é o IntelliJ IDEA que a destaca por meio de uma inspeção de código (“Leaking 'this' in constructor of non-final class”). Neste caso, ela é intencional e segura, porque os métodos das classes derivadas não usam nenhuma propriedade.

A classe [UnknownUserException] é a seguinte:

1
2
3
4
package users

// uma exceção específica da aplicação
class UnknownUserException(message: String) : Exception(message)
  • Linha 4: ela deriva da classe [Exception] (um alias de [java.lang.Exception]) e tem um único construtor que recebe como parâmetro uma mensagem de erro, repassada imediatamente ao construtor da classe-mãe. Uma linha basta. Em Java, uma classe derivada de [Exception] é uma exceção verificada (checked): o compilador verifica se todo método capaz de lançá-la a declara com uma cláusula [throws]. Kotlin não faz essa verificação: todas as exceções em Kotlin se comportam como as exceções não verificadas de Java. Se um método Kotlin for chamado a partir de código Java que deseja capturar a exceção, ele é marcado para Java com a anotação [@Throws(UnknownUserException::class)]. O compilador Kotlin também não exige um número de versão [serialVersionUID].

Derivamos agora a classe [Administrator] da classe-mãe [User]:

package users

class Administrator(login: String, password: String) : User(login, password) {
    // identificação
    override fun identify(): String {
        // identificação LDAP
        // ...
        return "admin"
    }
}
  • Linha 3: o construtor primário simplesmente repassa os parâmetros que recebe à sua classe-mãe: [: User(login, password)]. Os parâmetros [login] e [password] não são precedidos de [val]: são simples parâmetros, com as propriedades correspondentes declaradas na classe-mãe;
  • Linhas 5 a 8: o método [identify] da classe [Administrator]. Suponha que um administrador seja identificado por um diretório chamado LDAP. Esse método implementa o método abstrato [identify] de sua classe-mãe. Ele mantém o nível de acesso [protected] do método que sobrescreve: em Kotlin, um método sobrescrito herda por padrão a visibilidade do método sobrescrito (ele pode ampliá-la, mas não restringi-la). Seu tipo de retorno é *[String]*, e não *[String?]: um método sobrescrito pode retornar um tipo mais específico que o do método que sobrescreve, e uma *[String] é um caso particular de *[String?]*.

As classes [Observer] e [Unknown] também derivam da classe [User]. Elas diferem da classe [Administrator] apenas por seu método [identify]. O método da classe [Observer] supõe que um observador seja identificado por um banco de dados e retorna o papel “observer”:

1
2
3
4
5
6
    // identificação
    override fun identify(): String {
        // identificação por meio de um banco de dados
        // ...
        return "observer"
    }

O método da classe [Unknown] retorna a referência [null] para indicar que o usuário não foi reconhecido; seu tipo de resultado é, portanto, [String?]:

1
2
3
4
5
6
    // identificação
    override fun identify(): String? {
        // usuário desconhecido
        // ...
        return null
    }

Em última análise, os objetos [Administrator], [Observer], e [Unknown] são inicializados pelo mesmo código, o da classe-mãe [User]. Essa classe usa o método [identify] fornecido por essas classes. Um programa de teste poderia ser como o seguinte [Main.kt]:

package users

fun main() {
    try {
        println(Observer("observer", "pwd1"))
        println(Administrator("admin", "pwd2"))
        println(Unknown("xx", "yy"))
    } catch (e: UnknownUserException) {
        println("Unknown user: ${e.message}")
    }
    // val u = User("x", "y")   // rejeitado: a classe User é abstrata
}

Observe que, nas linhas 5 e 6, o método [User.toString()] é usado pela função [println]. Na linha 7, o construtor lança uma exceção [UnknownUserException], que é capturada na linha 8: o objeto não é criado e nada é exibido por [println]. O bloco [try] não é exigido pelo compilador, como era em Java: sem ele, a exceção encerraria o programa. A linha 11, se descomentada, é rejeitada pelo compilador, que apresenta dois motivos:

Main.kt:11:13: error: cannot access 'constructor(login: String, password: String): User': it is protected in 'users.User'.
Main.kt:11:13: error: cannot create an instance of an abstract class.

Não é possível chamar um construtor protegido fora das classes derivadas e, mais importante, não é possível criar um objeto de uma classe abstrata.

Resultados:

1
2
3
4
> gradlew -q run -Pmain=users.MainKt
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

Uma classe abstrata é semelhante a uma interface: ambas declaram membros que outras classes devem implementar. No entanto, uma classe abstrata pode ter estado (propriedades armazenadas), construtores e código comum às suas classes derivadas; em contrapartida, uma classe só pode derivar de uma única classe abstrata, ao passo que pode implementar várias interfaces. Os dois recursos costumam ser combinados: uma interface define o contrato, enquanto uma classe abstrata que a implementa concentra o código comum a várias implementações. É isso que a aplicação de exemplo deste capítulo fará. Por fim, lembre-se de que a classe selada ([sealed class]), vista anteriormente, é uma classe abstrata cujas classes derivadas são todas conhecidas pelo compilador: vamos usá-la mais adiante com a expressão [when].

4.8. Classes, interfaces e funções genéricas

4.8.1. Classes e funções genéricas

Suponha que queremos escrever uma classe [IntPair] que armazena dois inteiros e pode trocá-los: duas propriedades, [var first: Int] e [var second: Int], e um método, [swap()], que troca seus valores usando uma variável temporária, [val temp]. Se depois quiséssemos um par de strings, seguido de um par de pessoas, escreveríamos mais duas classes, [StringPair] e [PersonPair], idênticas à anterior, exceto pelo tipo: [String] ou [Person] em vez de [Int].

Classes, interfaces e funções genéricas atendem à necessidade de código que difere apenas no tipo de certos dados. O Kotlin as possui desde a sua primeira versão; elas se baseiam nos genéricos introduzidos na JVM com o Java 5 (2004), com os quais compartilham os pontos fortes e certas limitações (apagamento de tipos, discutido mais adiante), além de algumas melhorias notáveis (variância declarativa, tipos reificados). Convém notar que o Kotlin, assim como o Java, não oferece passagem de parâmetros por referência: uma função não pode trocar os valores de duas variáveis do chamador, mas pode trocar dois elementos de um objeto, de um par ou de um array.

O programa [Classes18.kt] contém uma classe genérica, uma função genérica e uma segunda classe genérica:

package classes18

// classes e funções genéricas
fun main() {
    // --- uma classe genérica Pair<T>
    // Int
    val pi = Pair<Int>(1, 2)
    pi.swap()
    println("pi=$pi")
    // String: o tipo T é inferido a partir dos parâmetros reais
    val ps = Pair("s1", "s2")
    ps.swap()
    println("ps=$ps")
    // Person
    val p1 = Person("jean", "clu", 20)
    val p2 = Person("pauline", "dard", 55)
    val pp = Pair(p1, p2)
    pp.swap()
    println("pp=$pp")
    // o primeiro elemento é do tipo Person: sem conversão
    val firstOne: Person = pp.first
    println("first element: $firstOne")

    // --- uma função genérica swap<T>
    val integers = arrayOf(1, 2, 3)
    swap<Int>(integers, 0, 2)
    println("integers=${integers.contentToString()}")
    // o compilador infere T a partir do tipo dos parâmetros reais
    val persons = arrayOf(p1, p2)
    swap(persons, 0, 1)
    println("persons=${persons.contentToString()}")

    // --- uma classe genérica com estado: uma pilha de elementos do tipo T
    val stack = MyStack<Person>()
    stack.push(p1)
    stack.push(p2)
    println("The stack contains ${stack.size} persons")
    val top = stack.pop()
    println("Person popped: $top, ${stack.size} left")
    // stack.push("x")   // rejeitado: a pilha só aceita objetos Person
}

// uma classe genérica: um par de dois elementos do tipo T
class Pair<T>(first: T, second: T) {
    // duas propriedades legíveis de fora, modificáveis apenas pela classe
    var first = first
        private set
    var second = second
        private set

    // trocamos os dois elementos
    fun swap() {
        val temp = first
        first = second
        second = temp
    }

    override fun toString() = "($first,$second)"
}

// uma função genérica de nível superior:
// ela troca os elementos nº i e j de um array de elementos do tipo T
fun <T> swap(array: Array<T>, i: Int, j: Int) {
    val temp = array[i]
    array[i] = array[j]
    array[j] = temp
}

// uma pilha de elementos do tipo T
class MyStack<T> {
    // os elementos da pilha
    private val elements = mutableListOf<T>()

    // número de elementos
    val size: Int
        get() = elements.size

    // adição de um elemento no topo da pilha
    fun push(element: T) {
        elements.add(element)
    }

    // remoção do elemento no topo da pilha
    fun pop(): T {
        check(elements.isNotEmpty()) { "empty stack" }
        return elements.removeLast()
    }
}

// uma pessoa
data class Person(val firstName: String, val lastName: String, val age: Int) {
    override fun toString() = "[$firstName, $lastName, $age]"
}
  • linhas 44–58: a classe [Pair] é parametrizada por um tipo denotado [T], entre colchetes angulares após o nome da classe. Você pode dar a ele o nome que quiser; por convenção, usa-se uma letra maiúscula ([T] para tipo, [E] para elemento, [K] e [V] para chave e valor). Esse tipo, [T], é então usado na classe como qualquer outro tipo: nos parâmetros do construtor, nas duas propriedades e na variável temporária [temp] (linha 53), da qual o compilador infere o tipo [T]. Diz-se que a classe [Pair] é uma classe genérica;
  • linhas 46–49: duas propriedades inicializadas pelos parâmetros do construtor, que têm os mesmos nomes. Elas são declaradas como [var] porque o método [swap] as modifica, mas o seu acessor [set] é privado ([private set]): o código externo pode ler [pp.first], mas não pode atribuir um valor a ela. Isso equivale aos campos privados e aos seus acessores [getFirst] e [getSecond] na versão em Java;
  • Linhas 52–55: troca dos dois elementos. Os fãs dos idiomas do Kotlin às vezes escrevem isso em uma única linha: [first = second.also { second = first }] ([also] retorna o valor de [second] após executar a atribuição no bloco). A versão com variável temporária é mais legível;
  • Linha 7: ao usar uma classe genérica parametrizada pelos tipos T1, T2, …, esses tipos podem ser especificados entre colchetes angulares. Aqui, [Pair<Int>] é um par de inteiros. Diferentemente do Java, que exige [Pair<Integer>] e rejeita [Pair<int>], o Kotlin tem um único tipo, [Int]: o compilador usa a classe wrapper *[java.lang.Integer]* para a JVM sempre que um objeto é necessário, como mostrado aqui;
  • linhas 11 e 17: na maioria das vezes, o tipo não é especificado; o compilador o infere a partir dos parâmetros reais do construtor, aqui [String] e depois [Person]. Isso é o equivalente ao operador “diamante” do Java, [new Pair<>(...)], porém mais conciso;
  • linha 21: a propriedade [first] de um [Pair<Person>] é do tipo [Person], sem conversão;
  • linhas 63–66: uma função genérica de alto nível. O parâmetro de tipo [<T>] é declarado entre a palavra-chave [fun] e o nome da função. Em Java, era necessária uma classe chamada [Generic2] para conter o método estático; em Kotlin, uma função pode existir fora de qualquer classe. Ela troca os elementos i e j de um array de elementos do tipo [T]. O tipo [Array<T>] é um array de objetos do Kotlin (o equivalente de [T[]] em Java);
  • linha 26: a função [swap] é chamada, especificando o tipo [T] entre [<>]. Na verdade, o compilador é capaz de inferir [T] a partir do tipo dos parâmetros reais. Portanto, a sintaxe da linha 30 é válida, e é a que se usa na prática. Observe que [arrayOf(1, 2, 3)] cria um [Array<Int>] (um array de objetos [Integer]), ao qual a função é aplicada; um array [IntArray] (criado por [intArrayOf]), que é um array de inteiros primitivos [int[]], não seria aceito: como em Java, um parâmetro de tipo não pode se referir a um tipo primitivo da JVM;
  • Linhas 70–86: uma classe genérica com estado: uma pilha de elementos do tipo [T]. Os elementos são empilhados no topo da pilha e desempilhados do topo. Eles são armazenados em uma lista genérica mutável do tipo [MutableList<T>] (linha 72), criada pela função genérica [mutableListOf<T>()], que por sua vez é parametrizada pelo tipo da pilha, [T]. O número de elementos é uma propriedade calculada [size]. A função [removeLast] recupera e retorna o último elemento da lista. Uma pilha vazia causa uma exceção [IllegalStateException], a exceção lançada quando se solicita uma operação a um objeto que não está no estado esperado: é precisamente a exceção lançada pela função [check(condition) { message }] do Kotlin quando a condição é falsa (linha 85);
  • linha 34: uma pilha de pessoas. Aqui, o tipo deve ser especificado, pois o compilador não tem como inferi-lo. O compilador garante que ela conterá apenas pessoas: a instrução da linha 40, quando descomentada, é rejeitada ([argument type mismatch: actual type is 'String', but 'Person' was expected]). O método [pop] retorna um objeto do tipo [Person], sem conversão;
  • linhas 91–92: a pessoa é uma classe de dados para a qual o método [toString] foi redefinido.

Resultados:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=classes18.Classes18Kt
pi=(2,1)
ps=(s2,s1)
pp=([pauline, dard, 55],[jean, clu, 20])
first element: [pauline, dard, 55]
integers=[3, 2, 1]
persons=[[pauline, dard, 55], [jean, clu, 20]]
The stack contains 2 persons
Person popped: [pauline, dard, 55], 1 left

4.8.2. Limites de parâmetros genéricos

Na classe [Pair<T>], o compilador não sabe nada sobre o tipo [T]: ele permite apenas os métodos da classe [Any] ([toString], [equals], [hashCode]) e, mesmo assim, somente por meio do operador [?.]: por padrão, [T] pode, de fato, ser um tipo anulável! O limite implícito de um parâmetro genérico é [Any?]. Para usar outros métodos, é preciso restringir o parâmetro genérico especificando, após os dois-pontos, o tipo do qual ele deve derivar:

Restrição
Significado
[<T : SomeClass>]
T deve ser a classe especificada ou uma classe derivada
[<T : Interface>]
T deve implementar a interface especificada
[<T> ... where T : I1, T : I2]
Restrições múltiplas: elas são listadas em uma cláusula [where], colocada antes do corpo da função ou da classe
[<T : Comparable<T>>]
um limite que usa o próprio T: T deve ser comparável a T
[<T : Any>]
T deve ser um tipo não anulável

A sintaxe é a mesma da herança: o Java escreve [<T extends SomeClass>] e [<T extends SomeClass & I1 & I2>], enquanto o C# escreve [where T : SomeClass]. Como em Java, não existe uma restrição que exija um construtor sem parâmetros: não é possível escrever [T()] em uma classe genérica (veja o apagamento de tipos mais adiante). O programa [Classes19.kt] usa uma restrição:

package classes19

import kotlin.random.Random

// os limites (bounds) dos parâmetros genéricos
fun main() {
    // --- T pode ser qualquer tipo, inclusive Int e um tipo anulável
    val pi = Pair(1, 2)
    println("pi=$pi")
    val pn = Pair<String?>("a", null)
    println("pn=$pn")

    // --- o limite T : IValue
    // ordenação de pares de objetos do tipo RandomValue
    repeat(5) {
        val pair = Pair(RandomValue(), RandomValue())
        print("Before --> $pair")
        order(pair)
        println("   After --> $pair")
    }
    // ordenação de um par de objetos do tipo StringValue
    val strings = Pair(StringValue("xxxxxxxxxxxxxx"), StringValue("xx"))
    println("Before --> $strings")
    order(strings)
    println("After --> $strings")
    // order(pi)   // erro: Int não implementa IValue
}

// um par de dois elementos do tipo T
class Pair<T>(first: T, second: T) {
    var first = first
        private set
    var second = second
        private set

    fun swap() {
        val temp = first
        first = second
        second = temp
    }

    override fun toString() = "($first,$second)"
}

// o tipo T deve implementar IValue
fun <T : IValue> order(pair: Pair<T>) {
    // se o 1º elemento for maior que o 2º, os elementos são trocados
    if (pair.first.value > pair.second.value) {
        pair.swap()
    }
}

// um objeto que tem um valor inteiro
interface IValue {
    val value: Int
}

// um objeto que tem um valor aleatório
class RandomValue : IValue {
    // valor do objeto
    override val value = generator.nextInt(100)

    override fun toString() = value.toString()

    companion object {
        // gerador de números aleatórios compartilhado por todas as instâncias
        // (inicializado com uma semente fixa para que os resultados sejam reproduzíveis)
        private val generator = Random(2026)
    }
}

// um objeto cujo valor é o comprimento de uma string
class StringValue(private val s: String) : IValue {
    override val value: Int
        get() = s.length

    override fun toString() = s
}
  • linha 8: um par de inteiros. Diferentemente da versão em Java, não há erro a relatar aqui: [Pair<Int>] é permitido, e o compilador usa a classe [Integer] no código gerado;
  • linha 10: como o limite implícito é [Any?], o tipo [T] pode ser um tipo anulável: o par [pn] contém uma string e o valor [null]. Para impedir isso, teríamos declarado [class Pair<T : Any>];
  • Linhas 46–49: a função genérica [order] exige que o tipo [T] implemente a interface [IValue] (linhas 54–55). Essa interface tem uma propriedade [value], usada na linha 48, que retorna o valor do objeto do tipo [T]. Sem o limite, o compilador rejeitaria a expressão [pair.first.value]: nem todo tipo [T] tem uma propriedade [value]. Os dois elementos do par só são trocados se o valor do primeiro for maior que o do segundo: a função [order] ordena os dois elementos em ordem crescente de valor;
  • linhas 59–68: a classe [RandomValue] implementa a interface [IValue]. O valor de uma instância é um número aleatório entre 0 e 99 (linha 61), fornecido por um gerador de números aleatórios da classe [kotlin.random.Random] compartilhado por todas as instâncias: ele é armazenado no objeto companheiro da classe (linha 68), que cumpre o mesmo papel do campo estático na versão em Java. Esse gerador é inicializado com uma “semente” fixa: ele, portanto, produz sempre a mesma sequência de números, tornando os resultados reproduzíveis. Não se trata do mesmo algoritmo da classe [java.util.Random]: a sequência obtida, portanto, não é a mesma da versão em Java. Se a reprodutibilidade não for necessária, usa-se o gerador padrão [Random.Default] (por exemplo, [Random.nextInt(100)]); ou, para fins de segurança, a classe [java.security.SecureRandom];
  • linhas 73–77: a classe [StringValue] também implementa a interface [IValue]: o valor de uma instância é o comprimento da cadeia de caracteres passada ao construtor, calculado pelo acessor da propriedade;
  • linhas 15–19: pares de objetos do tipo [RandomValue] são ordenados. A função [repeat(5) { ... }] executa o bloco cinco vezes;
  • linhas 22–25: um par de objetos do tipo [StringValue] é ordenado;
  • linha 26: se essa linha for descomentada, o compilador informa que o tipo [Int] é inválido.

Resultados:

> gradlew -q run -Pmain=classes19.Classes19Kt
pi=(1,2)
pn=(a,null)
Before --> (67,8)   After --> (8,67)
Before --> (73,41)   After --> (41,73)
Before --> (28,53)   After --> (28,53)
Before --> (26,93)   After --> (26,93)
Before --> (31,39)   After --> (31,39)
Before --> (xxxxxxxxxxxxxx,xx)
After --> (xx,xxxxxxxxxxxxxx)

Eis os erros encontrados durante a compilação quando a linha 26 é descomentada:

Classes19.kt:26:5: error: cannot infer type for type parameter 'T'. Specify it explicitly.
Classes19.kt:26:11: error: argument type mismatch: actual type is 'Pair<Int>', but 'Pair<uninferred T (of fun <T : IValue> order)>' was expected.

O compilador tentou inferir o tipo [T]: a restrição do par exige [T] = [Int], e a restrição do limite exige que [T] implemente [IValue]; como as duas restrições são incompatíveis, ele não consegue encontrar um tipo [T] (“uninferred T”). Se você especificar o tipo por conta própria—[order<Int>(pi)]—a mensagem é mais direta: [type argument is not within its bounds: type parameter 'T (of fun <T : IValue> order)' must be subtype of 'IValue', but actual: 'Int'].

4.8.3. Interfaces genéricas: Comparable<T> e Comparator<T>

Para ilustrar o conceito de interface genérica, vamos ordenar uma lista de pessoas segundo diferentes critérios. Para isso, o Kotlin oferece funções para listas mutáveis (e arrays) que ordenam a coleção no próprio local, e funções para todas as coleções que retornam uma nova lista ordenada sem modificar a original. Vamos usar várias delas:

  • [list.sort()] ordena a lista segundo a ordem natural de seus elementos: esses elementos devem implementar a interface [Comparable<T>], cujo único método, [operator fun compareTo(other: T): Int], compara o objeto atual com o objeto [other]. Trata-se da interface Java [java.lang.Comparable], vista a partir do Kotlin;
  • [list.sortWith(comparator)] ordena a lista segundo a ordem definida por um objeto comparador, que implementa a interface [Comparator<T>] (um alias de [java.util.Comparator]), cujo método [fun compare(a: T, b: T): Int] compara dois objetos;
  • [list.sortedWith(comparator)], [list.sortedBy { ... }] e [list.sortedByDescending { ... }] retornam uma nova lista ordenada.

Os métodos [compareTo] e [compare] seguem a mesma regra: retornam um número positivo se x > y, 0 se x == y e um número negativo se x < y. Cabe ao desenvolvedor definir o significado dos operadores <, == e >. Por exemplo, se [p1] e [p2] são dois objetos [Person], podemos dizer que p1 > p2 se o nome de [p1] vier depois do nome de [p2] em ordem alfabética. Isso resultará em uma ordenação crescente com base nos nomes das pessoas. Se quisermos ordenar por idade, diremos que p1 > p2 se a idade de [p1] for maior que a idade de [p2]. Para ordenar em ordem decrescente, basta inverter os sinais dos resultados.

Já sabemos o suficiente para ordenar uma lista de pessoas. O programa [Classes20.kt] é o seguinte:

package classes20

import java.text.Collator
import java.util.Locale

// as interfaces genéricas Comparable<T> e Comparator<T>: ordenação de uma lista de pessoas
fun main() {
    val persons = mutableListOf(
        Person("claude", "pollon", 25),
        Person("valentine", "germain", 35),
        Person("paul", "germain", 32),
    )
    // exibição
    display("List to sort", persons)
    // ordenação segundo a ordem natural das pessoas (Comparable): a idade
    persons.sort()
    display("List after sorting by age", persons)
    // ordenação por sobrenome e nome (Comparator)
    persons.sortWith(CompareNames())
    display("List after sorting by last and first name", persons)
    // ordenação por idade decrescente, com um objeto anônimo
    persons.sortWith(object : Comparator<Person> {
        override fun compare(p1: Person, p2: Person) = p2.age.compareTo(p1.age)
    })
    display("List after sorting by decreasing age", persons)
    // o operador > usa o método compareTo de Comparable
    println("${persons[0]} > ${persons[1]} : ${persons[0] > persons[1]}")
    // comparadores construídos por compareBy e thenBy; sortedWith retorna uma nova lista
    val collator = Collator.getInstance(Locale.FRENCH)
    val byNames = compareBy<Person, String>(collator) { it.lastName }.thenBy(collator) { it.firstName }
    display("New list sorted by last and first name", persons.sortedWith(byNames))
    // uma ordenação por uma única propriedade
    display("New list sorted by first name", persons.sortedBy { it.firstName })
    // a lista original não mudou
    display("Original list", persons)
}

// exibição de uma lista de pessoas
fun display(text: String, persons: List<Person>) {
    println(text + "-".repeat(50 - text.length))
    for (p in persons) {
        println(p)
    }
}

// uma pessoa, comparável a outra pessoa
class Person(val firstName: String, val lastName: String, val age: Int) : Comparable<Person> {
    // a ordem natural das pessoas: a ordem das idades
    override fun compareTo(other: Person) = age.compareTo(other.age)

    override fun toString() = "[$firstName, $lastName, $age]"
}

// comparação dos sobrenomes e nomes de duas pessoas
class CompareNames : Comparator<Person> {
    // comparação de strings segundo as regras da língua francesa
    private val collator = Collator.getInstance(Locale.FRENCH)

    override fun compare(p1: Person, p2: Person): Int {
        // comparamos os sobrenomes
        val i = collator.compare(p1.lastName, p2.lastName)
        if (i != 0) {
            return i
        }
        // sobrenomes iguais: comparamos os nomes
        return collator.compare(p1.firstName, p2.firstName)
    }
}
  • linhas 8–11: a lista editável de pessoas. A versão em Java ordenava um array; as mesmas funções [sort] e [sortWith] existem para os arrays do Kotlin;
  • Linhas 47–51: a classe [Person] implementa a interface genérica [Comparable<Person>]: seus objetos são comparáveis a outras pessoas. Seu método [compareTo] (linha 49) define a ordem natural das pessoas, neste caso, a ordem das idades. O método [a.compareTo(b)] para inteiros retorna um número negativo, zero ou positivo conforme [a] seja menor que, igual a ou maior que [b]: é exatamente o que o método [compareTo] espera (o Java escreve [Integer.compare(a, b)]). O parâmetro se chama [other] na interface; mantemos esse nome ao redefini-lo, caso contrário o compilador—que permite argumentos nomeados—emitiria um aviso;
  • linha 16: ordenação na ordem natural;
  • linha 19: ordenação da lista de pessoas por sobrenome e nome. O parâmetro da função [sortWith] é uma instância da classe [CompareNames], que implementa a interface genérica [Comparator<Person>];
  • linhas 55–66: a classe [CompareNames]. Seu método [compare] implementa o método [compare(a: T, b: T)] da interface [Comparator<T>], em que [T] = [Person]. As strings não são comparadas pelo método [compareTo], que segue a ordem dos códigos de caracteres (letras maiúsculas antes das minúsculas, letras acentuadas depois do "z"), mas sim por um objeto [java.text.Collator] (linha 57) que aplica as regras de ordenação da língua francesa. O Kotlin usa aqui diretamente uma classe do JDK;
  • linhas 22–24: ordenação por idade decrescente. Desta vez, o comparador é um objeto anônimo: a expressão [object : Comparator<Person> { ... }] declara uma classe sem nome que implementa a interface [Comparator<Person>] e cria imediatamente uma instância dessa classe. Isso equivale à classe anônima do Java ([new Comparator<Person>() { ... }]). O corpo do objeto fornece o método [compare]. Um objeto anônimo evita ter de declarar uma classe usada uma única vez;
  • Linha 27: o método [compareTo] da interface [Comparable] é declarado como [operator]: os operadores [<], [>], [<=] e [>=] podem, portanto, ser aplicados a pessoas ([p1 > p2] é traduzido para [p1.compareTo(p2) > 0]), como vimos antes com a sobrecarga de operadores;
  • Linhas 29–30: a biblioteca do Kotlin cria comparadores: [compareBy(comparator) { it.lastName }] retorna um comparador de pessoas que compara seus sobrenomes (o valor calculado pela lambda) usando o comparador especificado, neste caso [Collator]; [thenBy(comparator) { it.firstName }] adiciona um segundo critério, usado em caso de empate no primeiro. Os dois tipos de [compareBy] (o do elemento e o da chave) são especificados entre colchetes angulares, pois o compilador não consegue inferi-los apenas a partir da lambda. Sem um comparador específico, basta escrever [compareBy<Person> { it.lastName }.thenBy { it.firstName }]: as chaves são então comparadas em sua ordem natural. O comparador [byNames] é um substituto melhor para a classe [CompareNames];
  • linha 31: a função [sortedWith] retorna uma nova lista ordenada pelo comparador; a lista [persons] permanece inalterada;
  • linha 33: a função [sortedBy] ordena segundo a chave calculada pela expressão lambda—neste caso, o nome—em sua ordem natural ([sortedByDescending] ordenaria em ordem decrescente);
  • linha 35: a lista original não foi modificada pelas funções [sortedWith] e [sortedBy];
  • linha 40: a função [repeat] repete uma string: a linha de título é preenchida com traços até 50 caracteres.

Resultados:

> gradlew -q run -Pmain=classes20.Classes20Kt
List to sort--------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
List after sorting by age-------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
List after sorting by last and first name---------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
List after sorting by decreasing age--------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]
[valentine, germain, 35] > [paul, germain, 32] : true
New list sorted by last and first name------------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
New list sorted by first name---------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
Original list-------------------------------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]

Neste caso, a versão em Java apresentava três tipos de classes declaradas dentro de outra classe. O Kotlin tem os mesmos tipos, mas com nomes diferentes: uma classe declarada dentro de outra classe é aninhada por padrão (o equivalente da [static class] do Java: ela não está vinculada a nenhum objeto da classe envolvente); uma classe interna, associada a um objeto da classe envolvente, é declarada com a palavra-chave [inner] ([inner class]); por fim, a expressão [object : ...] cria um objeto anônimo. Veremos no Capítulo 7 que é possível ser ainda mais conciso do que com um objeto anônimo para uma interface que tem apenas um método abstrato, como [Comparator]: uma lambda, [persons.sortWith { p1, p2 -> p2.age.compareTo(p1.age) }], ou, como acabamos de fazer, um comparador construído a partir de uma lambda: [persons.sortWith(compareByDescending { it.age })].

4.8.4. Variância, projeções e apagamento de tipos

Uma [MutableList<Int>] não é uma [MutableList<Number>], embora [Int] derive de [Number]: se fosse, seria possível adicionar um [Double] a uma lista de inteiros por meio de uma variável do tipo [MutableList<Number>]. Diz-se que o tipo [MutableList<T>] é invariante: uma função que aceita uma [MutableList<Number>] rejeita uma [MutableList<Int>]. Em contrapartida, uma lista somente leitura do tipo [List<Int>] é uma [List<Number>]: como nada pode ser adicionado a ela, o risco anterior não existe, e todo inteiro lido da lista é de fato um número. Diz-se que o tipo [List<T>] é covariante.

Esta é uma diferença significativa em relação ao Java. Em Java, todas as interfaces genéricas são invariantes, e é preciso escrever curingas (wildcards) a cada uso: [List<? extends Number>] para uma lista da qual se lê, [List<? super Integer>] para uma lista que se está preenchendo. O Kotlin permite especificar a variância de uma vez por todas, na declaração da classe ou interface: trata-se da variância na declaração. A interface [List] é declarada como [interface List<out E>]: a palavra-chave [out] significa que o tipo [E] aparece apenas como “saída” (o resultado de métodos e de propriedades do tipo [val]), o que torna o tipo covariante. Da mesma forma, a interface [Comparable] é declarada como [interface Comparable<in T>]: o tipo [T] aparece nela apenas como “entrada” (parâmetro de [compareTo]), o que torna o tipo contravariante: um [Comparable<Number>] é um [Comparable<Int>] (quem sabe comparar quaisquer números sabe comparar um inteiro). O compilador verifica se a classe respeita a sua declaração.

Para tipos invariantes como [MutableList], o Kotlin também oferece projeções de tipo, que são equivalentes aos curingas do Java:

Kotlin
Java
Significado
[MutableList<out Number>]
[List<? extends Number>]
Uma lista de elementos de um tipo desconhecido derivado de [Number]: é possível ler [Number] dela, mas não é possível adicionar elementos a ela
[MutableList<in Int>]
[List<? super Integer>]
uma lista de elementos de um tipo desconhecido do qual [Int] deriva ([Int], [Number], [Any]): é possível adicionar [Int] a essa lista
[MutableList<*>]
[List<?>]
uma lista de elementos de um tipo desconhecido (projeção em estrela): é possível ler [Any?]

O programa [Classes21.kt] ilustra a variância, as projeções e uma característica específica dos genéricos da JVM—o apagamento de tipos—, bem como a solução parcial do Kotlin para esse problema: os parâmetros de tipo reificados:

package classes21

// variância (out, in), projeções, projeção estrela, apagamento de tipos e tipos reified
fun main() {
    val integers: List<Int> = listOf(1, 2, 3)
    val reals: List<Double> = listOf(1.5, 2.25)
    // List<out E> é covariante: uma List<Int> é uma List<Number>
    println("Sum of integers: ${sum(integers)}")
    println("Sum of reals: ${sum(reals)}")
    // MutableList<in Int>: uma lista mutável que pode receber Ints
    val numbers = mutableListOf<Number>()
    addIntegers(numbers, 3)
    numbers.add(2.5)
    println("numbers=$numbers, sum=${sum(numbers)}")
    // MutableList<out Number>: uma lista mutável cujos elementos são apenas lidos
    val mutableIntegers = mutableListOf(10, 20)
    println("Sum of a mutable list: ${mutableSum(mutableIntegers)}")
    // um limite recursivo: T deve ser comparável a si mesmo
    println("max : ${max(listOf("paul", "jean", "valentine"))}, ${max(integers)}")
    // variância no local da declaração em nossas próprias classes
    val box: Box<Number> = Box(5)
    println("box : ${box.content}")
    // a projeção estrela: uma lista de elementos de um tipo desconhecido
    displaySize(listOf("a", "b"))
    displaySize(mutableIntegers)
    // apagamento de tipos: em tempo de execução, uma lista é uma lista
    val l1 = ArrayList<String>()
    val l2 = ArrayList<Int>()
    println("same class: ${l1.javaClass == l2.javaClass} (${l1.javaClass.name})")
    // os parâmetros de tipo reified das funções inline
    val mixed = listOf(1, "two", 3.0, "four", 5)
    println("strings : ${countOf<String>(mixed)}, integers : ${countOf<Int>(mixed)}")
    println("the strings : ${mixed.filterIsInstance<String>()}")
    println("type name : ${typeName<Double>()}")
}

// soma dos elementos de uma lista de números (List é covariante)
fun sum(values: List<Number>): Double {
    var sum = 0.0
    for (value in values) {
        sum += value.toDouble()
    }
    return sum
}

// soma dos elementos de uma lista mutável de números (MutableList é invariante)
fun mutableSum(values: MutableList<out Number>): Double {
    // values.add(1)   // rejeitado: o tipo exato dos elementos é desconhecido
    return values.sumOf { it.toDouble() }
}

// adição dos inteiros 1, 2, ..., n a uma lista capaz de receber Ints
fun addIntegers(list: MutableList<in Int>, n: Int) {
    for (i in 1..n) {
        list.add(i)
    }
}

// o maior elemento de uma lista não vazia
fun <T : Comparable<T>> max(elements: List<T>): T {
    var max = elements.first()
    for (element in elements) {
        if (element > max) {
            max = element
        }
    }
    return max
}

// uma classe covariante: T só aparece na saída (resultado de método, propriedade val)
class Box<out T>(val content: T)

// uma lista cujo tipo de elemento é desconhecido
fun displaySize(list: List<*>) {
    println("list of ${list.size} elements, first element: ${list.firstOrNull()}")
}

// o tipo T é conhecido em tempo de execução graças a reified (função inline)
inline fun <reified T> countOf(elements: List<Any>) = elements.count { it is T }

inline fun <reified T : Any> typeName() = T::class.simpleName
  • linhas 38–43: a função [sum] aceita uma [List<Number>]; portanto, como [List] é covariante, ela aceita uma lista de elementos de qualquer tipo derivado de [Number]: [Int], [Double], [BigDecimal]… Ela lê os elementos como [Number] e usa o seu método [toDouble]. O Kotlin, como o Java, não oferece aritmética genérica: não é possível escrever [a + b] para dois objetos do tipo [T] ou [Number], daí o uso de [Double]. Onde o Java precisaria escrever ***[List<? extends Number>], o simples tipo ***[List<Number>] é suficiente;
  • linhas 8–9: a mesma função soma uma lista de [Int] a uma lista de [Double]. [listOf(...)] cria uma lista somente leitura;
  • Linhas 47–49: uma lista editável, por outro lado, é invariante. Para aceitar uma [MutableList<Int>] (linha 17), a função declara uma projeção [MutableList<out Number>]. Ela pode ler elementos como [Number], mas a adição de um elemento (linha 48) é rejeitada: o compilador não sabe se é uma lista de [Int] ou de [Double] ([receiver type 'MutableList<out Number>' contains out projection which prohibits the use of 'fun add(element: E): Boolean']);
  • linhas 53–55: a função [addIntegers] aceita qualquer lista mutável capaz de conter [Int], neste caso uma [MutableList<Number>] (linha 11). Seguimos a regra “produtor: [out], consumidor: [in]”: uma lista cujos elementos são lidos é escrita como [out], e uma lista que é preenchida é escrita como [in]. As palavras-chave do Kotlin expressam diretamente o que o Java transmite com [extends] e [super];
  • linhas 60–67: a função genérica [max] retorna o maior elemento de uma lista. O limite [T : Comparable<T>] exige que os elementos sejam comparáveis entre si; ele se aplica tanto a strings quanto a inteiros (linha 19). Em Java, é preciso escrever [T extends Comparable<? super T>] para aceitar também um tipo cuja classe-mãe é comparável; em Kotlin, como a interface [Comparable] é contravariante ([in T]), [T : Comparable<T>] é suficiente. A função [first] retorna o primeiro elemento da lista, e o operador [>] chama [compareTo]. (A biblioteca do Kotlin já fornece a função [maxOf] e, para coleções, [max()].);
  • Linha 71: nossa própria classe covariante. O tipo *[T] aparece nela apenas como saída, como o tipo de uma propriedade *[val]*. Linha 21: um ***[Box<Int>] é, portanto, aceito onde se espera um ***[Box<Number>] . Se adicionarmos à classe um método [fun replace(newValue: T)], no qual [T] aparece como entrada, o compilador rejeita a classe: [type parameter 'T' is declared as 'out' but occurs in 'in' position in type 'T (of class Box<out T>)']*;
  • Linhas 74–75: a função [displaySize] aceita uma lista de elementos de qualquer tipo: [List<*>]. Ela não pode fazer nenhuma suposição sobre seus elementos, que lê como [Any?]. A função [firstOrNull] retorna o primeiro elemento ou [null] se a lista estiver vazia;
  • linhas 27–29: em tempo de execução, um ***[ArrayList<String>] e um ***[ArrayList<Int>] são dois objetos da mesma classe *[java.util.ArrayList] (*[javaClass] retorna a classe Java de um objeto). O compilador verifica os tipos genéricos e depois os apaga: o código compilado reconhece apenas [ArrayList] e [Object], e conversões são inseridas onde necessário. Esse “apagamento de tipos”, adotado pelo Java em 2004 para garantir que o código genérico permaneça compatível com o código existente, também se aplica ao Kotlin, que gera código para a mesma JVM. Isso explica várias limitações: não é possível escrever [T()] nem testar [o is List<String>] ([cannot check for instance of erased type 'List<String>']); no entanto, é possível testar [o is List<*>];
  • Linhas 79–81: o Kotlin contorna parcialmente o apagamento de tipos para as funções [inline]. O código de uma função [inline] é copiado pelo compilador em cada ponto em que ela é chamada (voltaremos a isso no Capítulo 7): nesse ponto, o tipo [T] é conhecido. Se o parâmetro de tipo for declarado como [reified] (“reificado”), a função pode usá-lo como um tipo de verdade: para testar [it is T] (linha 79) ou para obter a sua classe [T::class] (linha 81). Sem [reified], o teste [it is T] é rejeitado: [cannot check for instance of erased type 'T (of fun <T> countOf)'];
  • linhas 31–34: uso de funções reificadas. O tipo é especificado entre colchetes angulares: [countOf<String>(mixed)] conta as strings da lista. A biblioteca do Kotlin faz amplo uso desse mecanismo, por exemplo na função [filterIsInstance<String>()], que retorna os elementos de uma coleção que são strings como o tipo [List<String>].

Resultados:

> gradlew -q run -Pmain=classes21.Classes21Kt
Sum of integers: 6.0
Sum of reals: 3.75
numbers=[1, 2, 3, 2.5], sum=8.5
Sum of a mutable list: 30.0
max : valentine, 3
box : 5
list of 2 elements, first element: a
list of 2 elements, first element: 10
same class: true (java.util.ArrayList)
strings : 2, integers : 2
the strings : [two, four]
type name : Double

Diferentemente de outras linguagens como o C#, em que as interfaces podem declarar membros estáticos abstratos para implementar cálculos genéricos, o Kotlin não permite exigir que um tipo [T] tenha um método “de classe”: os membros do objeto companheiro de uma interface são chamados usando o nome da interface e não são herdados pelas classes que a implementam.

4.9. Pacotes

Para imprimir uma linha na tela, usamos a função [println(...)]. Se consultarmos a sua definição na documentação da biblioteca do Kotlin (kotlinlang.org/api), veremos que ela faz parte do pacote [kotlin.io]. Isso significa que o seu nome completo é [kotlin.io.println] e que poderíamos escrever [kotlin.io.println(...)]. Um pacote do Kotlin contém classes, bem como funções, propriedades e objetos de nível superior. Vários pacotes são importados automaticamente em todo arquivo Kotlin: [kotlin.*] ([Any], [String], [Int]…), [kotlin.io.*] ([println], [readln]), [kotlin.collections.*] ([List], [listOf]…), [kotlin.text.*] ([StringBuilder], [Regex]…), [kotlin.ranges.*], [kotlin.sequences.*], [kotlin.comparisons.*] ([compareBy]…), [kotlin.annotation.*] e, na JVM, [java.lang.*], e [kotlin.jvm.*]. Para os demais, usa-se uma cláusula [import], colocada no início do arquivo, após a declaração do pacote:

  • [import java.text.Collator] importa a classe [Collator] do pacote [java.text] (sem ponto e vírgula no final, como em todas as instruções do Kotlin);
  • [import java.util.*] importa sob demanda todas as declarações públicas do pacote [java.util];
  • [import kotlin.math.sqrt] importa uma função de nível superior, que pode então ser usada sem o seu pacote: [sqrt(2.0)]. O Kotlin não exige a cláusula [import static] do Java: classes, funções, propriedades e até membros estáticos de uma classe Java ([import java.lang.Math.PI]) são importados da mesma maneira;
  • [import namespaces.e2.Person as PersonE2] importa uma declaração com outro nome—um alias—que é válido apenas dentro desse arquivo.

Quando o compilador encontra um nome simples, ele o procura no pacote atual e entre as declarações importadas. Uma cláusula [import] não acrescenta nada ao programa: ela apenas evita ter de escrever os nomes completos.

Ao criar uma classe, você a coloca em um pacote. A finalidade dos pacotes é evitar conflitos de nomes entre classes, por exemplo, quando elas são distribuídas. Considere duas empresas, E1 e E2, que distribuem classes empacotadas nos arquivos [e1.jar] e [e2.jar], respectivamente. Suponha que um cliente C compre esses dois conjuntos de classes, nos quais ambas as empresas definiram uma classe chamada [Person]. Se a empresa E1 criar suas classes em um pacote chamado [e1] e a empresa E2 criar suas classes em um pacote chamado [e2], as duas classes [Person] passarão a se chamar [e1.Person] e [e2.Person]. O cliente pode importar uma delas e se referir à outra pelo seu nome completo, ou dar a ela um alias. O pacote resolve a ambiguidade. Por convenção, os nomes de pacotes são escritos em minúsculas e começam com o nome de domínio invertido da organização que os publica ([com.mysql.cj.jdbc], [org.hibernate], [kotlinx.coroutines]…); em nossos exemplos, usaremos nomes curtos.

Para colocar as declarações de um arquivo em um pacote, escreve-se a declaração [package name] no início do arquivo. É o que fazemos desde o início deste curso: cada programa está em um pacote com o seu próprio nome. Diferentemente do Java, o Kotlin não exige uma correspondência biunívoca entre pacotes e pastas, mas a recomenda, e o IntelliJ IDEA indica um arquivo que não está organizado corretamente: os arquivos-fonte do pacote [namespaces.e1] ficam em uma pasta chamada [namespaces/e1], a partir da raiz do código-fonte ([src/main/kotlin]). O pacote [namespaces] e seus dois subpacotes ilustram esses conceitos:

1
2
3
4
5
6
src/main/kotlin/namespaces/
  Main.kt               the main program (namespaces package)
  e1/
    Person.kt           the namespaces.e1.Person class
  e2/
    Person.kt           the namespaces.e2.Person class

A primeira classe [Person] [e1/Person.kt]:

1
2
3
4
5
6
7
8
9
// as declarações deste arquivo pertencem ao pacote namespaces.e1
package namespaces.e1

class Person(private val firstName: String, private val lastName: String) {
    override fun toString() = "e1.Person[$firstName, $lastName]"
}

// uma função de nível superior também pertence a um pacote
fun greet(person: Person) = "Hello $person"
  • Linha 2: a declaração do pacote. Todas as declarações do arquivo pertencem a esse pacote: a classe [Person] e a função de nível superior [greet] (linha 9), cujo nome completo é [namespaces.e1.greet]. Na JVM, essa função é colocada em uma classe chamada [namespaces.e1.PersonKt], que recebe o nome do arquivo.

A segunda, [e2/Person.kt]:

// as declarações deste arquivo pertencem ao pacote namespaces.e2
package namespaces.e2

class Person(val name: String) {
    override fun toString() = "e2.Person[$name]"
}

// uma constante visível em todo o módulo, e somente no módulo
internal const val VERSION = "e2-1.0"

// uma função visível somente neste arquivo
private fun tool() = "private tool"
  • linha 4: uma classe chamada [Person], que tem o mesmo nome da anterior, mas está em um pacote diferente;
  • linha 9: uma constante de visibilidade [internal]: ela é acessível apenas às declarações do mesmo módulo. Em Kotlin, um módulo é um conjunto de arquivos compilados juntos: um projeto (ou subprojeto) Gradle, um módulo do IntelliJ IDEA… Aqui, é o projeto [04-classes];
  • Linha 12: uma função de nível superior privada: ela é acessível apenas às declarações do seu próprio arquivo. Uma tentativa de importá-la de [Main.kt] é rejeitada: [cannot access 'fun tool(): String': it is private in file].

Ambas as classes são públicas, que é a visibilidade padrão do Kotlin (uma classe Java sem a palavra-chave [public] é acessível apenas às classes do seu próprio pacote). Vamos resumir os quatro níveis de visibilidade de uma declaração de nível superior:

Visibilidade
Acessível a partir de
[public] (padrão)
qualquer lugar
[internal]
o mesmo módulo
[private]
o mesmo arquivo
[protected]
(aplica-se apenas a membros de uma classe: a classe e suas classes derivadas)

O Kotlin não tem equivalente à visibilidade de “pacote” do Java—a visibilidade padrão das declarações Java sem modificador: em Kotlin, um pacote é apenas um namespace, e é o módulo que define o que uma biblioteca expõe a seus usuários. O programa principal [Main.kt] é o seguinte:

package namespaces

// importação de uma classe de um pacote
import namespaces.e1.Person
// importação de uma função de nível superior
import namespaces.e1.greet
// importação de uma classe com outro nome
import namespaces.e2.Person as PersonE2
// importação de uma constante interna ao módulo
import namespaces.e2.VERSION
// importação de uma função da biblioteca Kotlin
import kotlin.math.sqrt

fun main() {
    // Person designa namespaces.e1.Person, que foi importada
    val p1 = Person("Jean", "Dupont")
    // o nome completo de uma classe elimina qualquer ambiguidade
    val p2 = namespaces.e2.Person("Durand")
    // o alias PersonE2 designa a classe namespaces.e2.Person
    val p3 = PersonE2("Martin")
    println("$p1 $p2 $p3")
    // uma função de nível superior do pacote namespaces.e1
    println(greet(p1))
    // nome completo e pacote de uma classe
    println("${Person::class.qualifiedName}, ${PersonE2::class.qualifiedName}")
    println("package of the Person class: ${Person::class.java.packageName}")
    // o módulo JPMS que contém uma classe
    println("e1.Person is in a named module: ${Person::class.java.module.isNamed}")
    println("${String::class.java.name} is in the module ${String::class.java.module.name}")
    // StringBuilder é conhecido sem import
    val sb = StringBuilder("abc")
    println(sb.append("def"))
    // sqrt é conhecida graças ao import
    println("sqrt(2)=${sqrt(2.0)}")
    // uma declaração internal é acessível em todo o módulo
    println("version=$VERSION")
}
  • linha 4: importação da classe [namespaces.e1.Person];
  • linha 6: importação da função de nível superior [greet], exatamente como se importa uma classe;
  • Linha 8: importação da classe [namespaces.e2.Person] com o nome [PersonE2]. Neste arquivo, o nome [PersonE2] refere-se a essa classe. O Java não oferece suporte a aliases: não é possível dar a uma classe um nome diferente em Java. (O Kotlin também permite declarar um alias de tipo para o nome completo, como [typealias PersonE2 = namespaces.e2.Person]: já vimos exemplos disso, em que [Comparator] e [Exception] são aliases de tipos Java);
  • linha 10: importação da constante [internal], o que é permitido porque [Main.kt] está no mesmo módulo;
  • linha 12: importação da função [sqrt] do pacote [kotlin.math];
  • linha 16: [Person] refere-se à classe [namespaces.e1.Person], que foi importada;
  • linha 18: o nome completo da classe [namespaces.e2.Person] elimina qualquer ambiguidade;
  • linha 20: o alias produz o mesmo resultado, mas é mais legível;
  • linha 23: chamada da função importada;
  • linhas 25–26: a propriedade [qualifiedName] da descrição Kotlin de uma classe ([Person::class]) retorna o seu nome completo, prefixado com o seu pacote. A propriedade [java] retorna a descrição Java da classe ([java.lang.Class]), cujo método [getPackageName]—visto em Kotlin como uma propriedade [packageName]—retorna o nome do pacote;
  • linhas 28–29: o método [getModule] da classe Java retorna o módulo JPMS que contém a classe (veja abaixo);
  • linhas 31–32: a classe [StringBuilder] é reconhecida sem importação (é um alias, definido no pacote [kotlin.text], para a classe [java.lang.StringBuilder]);
  • linha 34: uso da função importada;
  • linha 36: uso da constante [internal].

Resultados:

> gradlew -q run -Pmain=namespaces.MainKt
e1.Person[Jean, Dupont] e2.Person[Durand] e2.Person[Martin]
Hello e1.Person[Jean, Dupont]
namespaces.e1.Person, namespaces.e2.Person
package of the Person class: namespaces.e1
e1.Person is in a named module: false
java.lang.String is in the module java.base
abcdef
sqrt(2)=1.4142135623730951
version=e2-1.0

Se substituirmos as importações de [Person] pelas duas importações sob demanda [import namespaces.e1.*] e [import namespaces.e2.*], sem o alias, o nome [Person] torna-se ambíguo. As duas importações se anulam, e o compilador não consegue mais encontrar a classe:

Main.kt:7:14: error: unresolved reference 'Person'.

Observe que uma importação com alias oculta o nome original no arquivo: com a cláusula [import namespaces.e2.Person as PersonE2], o nome [Person] agora só pode se referir à classe do pacote [e1], mesmo que ambos os pacotes sejam importados sob demanda.

4.9.1. Módulos

O termo módulo tem dois significados para um desenvolvedor Kotlin. Acabamos de ver o primeiro: o módulo Kotlin, um conjunto de arquivos compilados juntos, que define o escopo [internal]. O segundo significado vem do Java: desde o Java 9, os pacotes são agrupados em módulos (o “Java Platform Module System”, JPMS). O JDK é dividido em módulos: [java.base] contém os pacotes essenciais ([java.lang], [java.util], [java.math], [java.io]…), [java.sql] fornece acesso a bancos de dados, [java.net.http] é o cliente HTTP, e assim por diante. Um módulo JPMS declara, em um arquivo chamado [module-info.java], o seu nome, os módulos dos quais depende ([requires java.sql;]) e os pacotes que disponibiliza a outros módulos ([exports tax.business;]). Um projeto Kotlin pode declarar um (o arquivo [module-info.java], escrito em Java, é colocado junto dos arquivos-fonte Kotlin e deve então depender do módulo [kotlin.stdlib]). As classes de uma aplicação que não declara um módulo JPMS—como a nossa—pertencem ao módulo sem nome (linha 5 da saída), que tem acesso a todos os módulos. Esse é o caso da maioria das aplicações e de todas as deste curso: os módulos JPMS interessam principalmente aos autores de bibliotecas e ao próprio JDK.

4.10. Classes de dados

Muitas classes servem unicamente para transportar dados: uma pessoa, uma nota, uma faixa de imposto… Para elas, sempre escrevemos o mesmo código: propriedades somente leitura, um método [toString] que as exibe e os métodos [equals] e [hashCode]. O construtor primário do Kotlin já poupa você de escrever os campos, o construtor e os acessores; a palavra-chave [data], colocada antes de [class], também instrui o compilador a gerar o restante. As classes de dados existem desde a primeira versão do Kotlin (2016); o Java as alcançou, com seus records, em 2021. Já as encontramos antes (na seção “Objetos imutáveis”) e várias vezes desde então; o programa [Classes22.kt] as apresenta de forma mais completa:

package classes22

// classes de dados (data class)
fun main() {
    val r1 = Person("Jean", "Dupont", 30)
    val r2 = Person("Jean", "Dupont", 30)
    // toString gerado pelo compilador
    println(r1)
    // as propriedades são as declaradas pelo construtor primário
    println("firstName=${r1.firstName}, identity=${r1.identity()}")
    // igualdade por valor: r1 e r2 são dois objetos diferentes, mas iguais
    println("r1 == r2 : ${r1 == r2}, r1 === r2 : ${r1 === r2}, equal hashCodes : ${r1.hashCode() == r2.hashCode()}")
    // propriedades val são somente leitura
    // r1.age = 31   // rejeitado: age é uma propriedade val
    // uma cópia modificada, com o método copy e um argumento nomeado
    val r3 = r1.copy(age = 31)
    println(r3)
    println("r1 == r3 : ${r1 == r3}")
    // desestruturação em variáveis, graças às funções component1(), component2()...
    val (firstName, lastName, age) = r1
    println("firstName=$firstName, lastName=$lastName, age=$age")
    println("component2()=${r1.component2()}")

    // a mesma coisa com uma classe comum
    val c1 = PersonC("Jean", "Dupont", 30)
    val c2 = PersonC("Jean", "Dupont", 30)
    println(c1)
    println("c1 == c2 : ${c1 == c2}")

    // duas data classes que implementam a mesma interface
    val e = Teacher("Lucile", "Dumas", 56, 61)
    println(e)
    println(e.identity())
    // a igualdade leva o tipo em conta: uma Person não é igual a um Teacher
    val pe = Person("Lucile", "Dumas", 56)
    println("pe == e : ${pe == e}")
    // o tipo comum: a interface HasIdentity
    val identities = listOf(pe, e)
    for (i in identities) {
        println(i.identity())
    }
}

// uma interface implementada pelas data classes
interface HasIdentity {
    fun identity(): String
}

// uma data class: firstName, lastName, age são suas propriedades
data class Person(val firstName: String, val lastName: String, val age: Int) : HasIdentity {
    // métodos podem ser adicionados
    override fun identity() = "[$firstName, $lastName, $age]"
}

// uma data class não pode ser derivada (ela é final)
data class Teacher(val firstName: String, val lastName: String, val age: Int, val section: Int) : HasIdentity {
    override fun identity() = "Teacher[[$firstName, $lastName, $age],$section]"
}

// uma classe comum equivalente... ou quase
class PersonC(val firstName: String, val lastName: String, val age: Int)
  • linhas 50–52: a classe de dados [Person]. A declaração [data class Person(val firstName: String, val lastName: String, val age: Int)] gera, a partir das propriedades declaradas no construtor primário:
    • três propriedades somente leitura [firstName], [lastName], [age] (o que uma classe comum também faz), acessadas pelos seus nomes: [r1.firstName] (linha 10);
    • um método [toString] que exibe o nome da classe e as suas propriedades (linha 1 dos resultados);
    • os métodos [equals] e [hashCode], que comparam os valores das propriedades em vez das referências;
    • um método [copy], que cria uma cópia do objeto cujas propriedades podem ser modificadas;
    • os métodos [component1], [component2] e [component3], que retornam as propriedades na ordem em que foram declaradas e permitem a desestruturação;
  • o construtor primário de uma classe de dados deve ter pelo menos um parâmetro, e todos os seus parâmetros devem ser propriedades ([val] ou [var]). Podem ser declaradas propriedades do tipo [var]: a classe de dados passa então a ser mutável. Isso é permitido, mas não recomendado, porque um objeto cujo [hashCode] muda se perde em um conjunto ou dicionário que o contém; as classes de dados são reservadas para dados imutáveis;
  • linha 52: uma classe de dados, como uma classe comum, pode ter métodos adicionais e implementar interfaces (linha 50);
  • Linha 12: [r1] e [r2] são dois objetos distintos ([===], em que as referências são iguais, resulta em [false]), mas são iguais no sentido de [==], que chama [equals], porque suas propriedades têm os mesmos valores. Seus códigos hash são, portanto, iguais. Para uma classe comum, [equals] compara as referências (linha 28);
  • linha 14: quando descomentada, esta linha é rejeitada: ['val' cannot be reassigned];
  • linha 16: uma classe de dados imutável não pode ser modificada; cria-se uma cópia modificada. O método gerado [copy] tem um parâmetro por propriedade, cujo valor padrão é o valor da propriedade no objeto copiado; com um argumento nomeado, especificam-se apenas as propriedades que mudam. Esta é a expressão [with] que faltava em Java, onde é preciso escrever manualmente métodos “wither” ([withAge(31)]);
  • Linha 20: desestruturação: as propriedades de *[r1] são extraídas para as variáveis *[firstName]*, *[lastName], e *[age]. O compilador traduz essa declaração para [val firstName = r1.component1()], [val lastName = r1.component2()], etc.: a correspondência se baseia na posição e não no nome (linha 22, o método [component2] é chamado diretamente). Uma propriedade pode ser ignorada usando o caractere [_]: [val (firstName, _, age) = r1]. Isso equivale ao padrão de record do Java 21 ([r1 instanceof Person(String firstName, String lastName, int age)]*); voltaremos à desestruturação com filtragem por padrões;
  • linhas 56–57: uma classe de dados é final; ela não pode ser estendida (a palavra-chave [open] é proibida aqui). Diferentemente de um record do Java, porém, ela mesma pode derivar de uma classe aberta, abstrata ou selada. Para dar às classes [Person] e [Teacher] um tipo comum, fazemos com que implementem a mesma interface, neste caso [HasIdentity] (linhas 45–46). A classe [Teacher] herda, portanto, as propriedades da pessoa;
  • linha 36: a igualdade das classes de dados leva em conta o tipo real dos objetos: um [Person] nunca é igual a um [Teacher], mesmo que as propriedades que eles compartilham sejam iguais;
  • linhas 38–40: a interface comum permite tratar as duas classes de forma polimórfica. O tipo da lista, [List<HasIdentity>], é inferido pelo compilador: é o tipo comum mais específico dos dois elementos;
  • linha 61: uma classe comum que se parece com a classe [Person]. Graças ao construtor primário, ela também cabe em uma única linha… mas a igualdade por valor, [toString], [copy] e a desestruturação não são fornecidos. Em Java, era preciso escrever também os campos, o construtor e os getters e setters.

Resultados:

> gradlew -q run -Pmain=classes22.Classes22Kt
Person(firstName=Jean, lastName=Dupont, age=30)
firstName=Jean, identity=[Jean, Dupont, 30]
r1 == r2 : true, r1 === r2 : false, equal hashCodes : true
Person(firstName=Jean, lastName=Dupont, age=31)
r1 == r3 : false
firstName=Jean, lastName=Dupont, age=30
component2()=Dupont
classes22.PersonC@4554617c
c1 == c2 : false
Teacher(firstName=Lucile, lastName=Dumas, age=56, section=61)
Teacher[[Lucile, Dumas, 56],61]
pe == e : false
[Lucile, Dumas, 56]
Teacher[[Lucile, Dumas, 56],61]

Observe que o método [toString] da classe [PersonC] é o mesmo da classe [Any]: o nome completo da classe seguido de um código hash, que muda de uma execução para outra (linha 8 dos resultados), e que a igualdade dos dois objetos [PersonC] é falsa (linha 9). O formato do [toString] de uma classe de dados, [Person(firstName=Jean, lastName=Dupont, age=30)], difere ligeiramente do de um record do Java, [Person[firstName=Jean, lastName=Dupont, age=30]].

Vamos resumir as diferenças entre uma classe comum e uma classe de dados:

 
Classe
Classe de dados
Igualdade: [==] ([equals])
mesmo objeto (a menos que seja sobrescrito)
mesmos valores das propriedades do construtor primário, mesmo tipo
[toString]
nome da classe e código hash
nome da classe e propriedades
Propriedades, construtor
declarados pelo construtor primário
declarados pelo construtor primário (pelo menos uma propriedade, somente propriedades)
estado
editável ou não
imutável com [val] (recomendado); outras propriedades podem ser declaradas no corpo
cópia modificada
a ser escrita
[copy(prop = value)] gerada
desestruturação
a ser escrita ([operator fun componentN])
gerada
herança
de uma classe, de várias interfaces; aberta com [open]
de uma classe, de várias interfaces; sempre final

Uma classe de dados é usada para dados definidos pelo seu valor (uma pessoa recuperada de um banco de dados, uma mensagem trocada pela rede, uma faixa de imposto), enquanto uma classe comum é usada para um objeto com identidade e comportamento (um serviço de cálculo, uma conexão, uma lista mutável). Veremos no Capítulo 11 que as entidades do Hibernate, que têm identidade, não são classes de dados. Observação: uma classe de dados com propriedades do tipo [val] é imutável apenas “superficialmente”: se uma propriedade referencia um objeto mutável—uma [MutableList], por exemplo—o conteúdo dessa lista continua mutável. Nesse caso, usamos propriedades somente leitura do tipo [List], inicializadas com uma cópia ([list.toList()]). Para os leitores que vêm do Java: uma classe de dados é compilada em uma classe Java comum e final (não em um record); a anotação [@JvmRecord] permite compilá-la em um verdadeiro record Java, se necessário.

4.11. Construtores de classes de dados

O construtor primário de uma classe de dados simplesmente copia seus parâmetros para as propriedades. No entanto, pode ser desejável validar ou normalizar esses parâmetros. O Java oferece para isso o construtor compacto dos records, que pode modificar os parâmetros antes de armazená-los. O Kotlin não tem um equivalente exato: os parâmetros de uma classe de dados são as suas propriedades, armazenadas como estão. Em compensação, dispomos das ferramentas de qualquer classe: o bloco [init] para a validação, os construtores secundários e as fábricas do objeto companheiro para a normalização. O programa [Classes23.kt] ilustra esses recursos:

package classes23

import kotlin.math.sqrt

// construtores de data classes: validação, construtor secundário, factory
fun main() {
    val p = Person.create("  Jean ", "Dupont", 30)
    println(p.identity())
    // uma data class é imutável: growOlder retorna uma nova pessoa
    val p2 = p.growOlder()
    println("${p.identity()} -> ${p2.identity()}")
    // um construtor secundário
    val unknown = Person("Martin")
    println(unknown.identity())
    // as verificações da factory e do bloco init
    try {
        Person.create("Paul", " ", 20)
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    try {
        Person.create("Paul", "Martin", -4)
    } catch (ex: IllegalArgumentException) {
        println(ex.message)
    }
    // uma data class com uma propriedade calculada e um companion object
    val pt = Point(3.0, 4.0)
    println("pt=$pt, distance to the origin: ${pt.distance}, origin=${Point.ORIGIN}")
}

// o construtor primário é privado: uma pessoa é criada com a factory create
// ou com o construtor secundário; copy é privado como ele (@ConsistentCopyVisibility)
@ConsistentCopyVisibility
data class Person private constructor(val firstName: String, val lastName: String, val age: Int) {
    // o bloco init verifica o objeto, qualquer que seja a forma de construção
    init {
        require(age >= 0) { "invalid age ($age)" }
    }

    // um construtor secundário deve chamar o construtor primário
    constructor(lastName: String) : this("?", validate(lastName, "last name"), 0)

    // um método que retorna uma nova pessoa
    fun growOlder() = copy(age = age + 1)

    fun identity() = "[$firstName, $lastName, $age]"

    companion object {
        // a factory: ela verifica e normaliza os parâmetros antes da construção
        fun create(firstName: String, lastName: String, age: Int) =
            Person(validate(firstName, "first name"), validate(lastName, "last name"), age)

        // uma função de validação privada
        private fun validate(value: String, label: String): String {
            require(value.isNotBlank()) { "invalid $label ($value)" }
            return value.trim()
        }
    }
}

data class Point(val x: Double, val y: Double) {
    // uma propriedade declarada no corpo da classe: ela não faz parte
    // das propriedades usadas por toString, equals, hashCode, copy
    val distance: Double
        get() = sqrt(x * x + y * y)

    companion object {
        val ORIGIN = Point(0.0, 0.0)
    }
}
  • linhas 36–37: o bloco [init] é executado a cada construção, depois que as propriedades do construtor primário foram inicializadas. Ele valida o objeto: uma idade negativa é rejeitada. A função [require(condition) { message }] lança uma exceção [IllegalArgumentException] com a mensagem calculada pela lambda se a condição for falsa: é a exceção destinada a um parâmetro inválido. Todos os construtores de uma classe passam pelo construtor primário e, portanto, pelo bloco [init]: não há como criar uma [Person] com idade negativa, nem mesmo com [copy], que também chama o construtor primário;
  • Linha 34: o bloco [init] não pode modificar as propriedades [val] do construtor primário, que já estão inicializadas. Para normalizar os parâmetros (neste caso, removendo os espaços ao redor do nome e do sobrenome), tornamos o construtor primário privado ([private constructor]) e fornecemos em seu lugar um método de fábrica: a função [create] do objeto companheiro (linhas 50–51). Ela valida e normaliza os parâmetros antes de chamar o construtor primário, o que está autorizada a fazer, pois faz parte da classe. Ela é chamada usando o nome da classe: [Person.create(" Jean ", "Dupont", 30)] (linha 7);
  • linha 33: o método gerado [copy] chama o construtor primário; se fosse público, permitiria contornar o método de fábrica ([p.copy(firstName = " x ")]). A anotação [@ConsistentCopyVisibility] instrui o compilador a dar a ele a visibilidade do construtor primário, que aqui é privada. Sem ela, o Kotlin 2.4 emite o aviso [non-public primary constructor is exposed via the generated 'copy()' method of the 'data' class], especificando que a visibilidade do método gerado [copy] mudará em uma versão futura (ele passará então a ter a mesma visibilidade do construtor);
  • linha 41: um construtor secundário, que recebe apenas o nome. Como qualquer construtor secundário de uma classe com construtor primário, ele deve chamar o construtor primário com [: this(...)]; para calcular os parâmetros, ele pode chamar funções do objeto companheiro, até mesmo privadas ([validate]). Um construtor secundário pode ser público quando o construtor primário é privado;
  • linha 44: uma classe de dados é imutável: envelhecer significa criar uma nova instância, o que é feito pelo método [copy] (privado, mas utilizável dentro da classe);
  • linhas 54–56: uma função de validação privada no objeto companheiro. [isNotBlank()] retorna verdadeiro se a cadeia contiver algo além de espaços; [trim()] remove os espaços no início e no fim da cadeia. A mensagem de erro é construída usando um template de string dentro da lambda passada a [require]: ela só é calculada se ocorrer um erro;
  • Linhas 61–68: uma classe de dados pode ter, além das propriedades do seu construtor primário, propriedades declaradas no seu corpo—neste caso, a propriedade calculada [distance]. Estas não contribuem para [toString], [equals], [hashCode] ou [copy]. Ela também pode ter um objeto companheiro, neste caso com a propriedade [ORIGIN], que equivale ao campo estático da versão em Java. (Diferentemente de um record, uma classe de dados pode até ter propriedades armazenadas no corpo, mas isso é pouco útil para dados imutáveis.)

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=classes23.Classes23Kt
[Jean, Dupont, 30]
[Jean, Dupont, 30] -> [Jean, Dupont, 31]
[?, Martin, 0]
invalid last name ( )
invalid age (-4)
pt=Point(x=3.0, y=4.0), distance to the origin: 5.0, origin=Point(x=0.0, y=0.0)

O nome, fornecido com espaços de ambos os lados (linha 7), foi armazenado sem eles (linhas 1 e 2 dos resultados). O bloco [init] é a maneira idiomática de garantir que um objeto seja sempre válido; uma fábrica, com um construtor privado, também permite normalizar os dados.

4.12. Funções de extensão

Como adicionar um método a uma classe que não pode ser modificada, como a classe [String]? O Java não oferece uma solução nativa: escrevem-se métodos estáticos, agrupados em uma classe utilitária ([Arrays], [Collections], [Objects], [Math]…), e os chamamos usando o nome da classe, passando o objeto como parâmetro: [Tools.initials(p)]. O Kotlin, como o C# com seus métodos de extensão, oferece funções de extensão: funções declaradas fora da classe que são usadas como métodos da classe estendida: [p.initials()]. Nós as usamos desde o início deste curso: [toInt], [sumOf], [contentToString], [toMutableList], [repeat], [also]… são funções de extensão da biblioteca do Kotlin, que enriquecem as classes do JDK ([String], arrays, coleções) sem modificá-las. O programa [Classes24.kt] mostra como escrever as suas próprias:

package classes24

import java.time.DayOfWeek
import java.time.LocalDate

// funções e propriedades de extensão
fun main() {
    val p = Person("jean", "dupont", 30)
    // funções de extensão são chamadas como métodos do objeto
    println(p.initials())
    println("jean".firstUpper())
    println("${p.fullName} is an adult: ${p.isAdult}")
    println("\"the weather is fine\" has ${"the weather is fine".nbWords()} words")
    // uma função do companion object da própria classe
    val unknown = Person.unknown()
    println("${unknown.fullName} is an adult: ${unknown.isAdult}")
    // uma extensão de uma classe Java
    val date = LocalDate.of(2026, 10, 4)
    println("$date is a weekend day: ${date.isWeekend}")
    // uma extensão de um tipo anulável: chamável em null
    val absent: Person? = null
    println("${p.description()} / ${absent.description()}")
    // a resolução das extensões é estática: o que conta é o tipo declarado
    val shape: Shape = Square()
    println("shape.name()=${shape.name()}, Square().name()=${Square().name()}")
    // ...enquanto a chamada de um método sobrescrito é polimórfica
    println("shape.category()=${shape.category()}")
}

// uma pessoa
data class Person(val firstName: String, val lastName: String, val age: Int) {
    companion object {
        // factory: uma pessoa desconhecida
        fun unknown() = Person("?", "?", 0)
    }
}

// funções de extensão da classe Person
fun Person.initials() = "${firstName[0].uppercaseChar()}.${lastName[0].uppercaseChar()}."

// propriedades de extensão (calculadas: uma extensão não pode armazenar um valor)
val Person.isAdult: Boolean
    get() = age >= 18

val Person.fullName: String
    get() = "${firstName.firstUpper()} ${lastName.uppercase()}"

// funções de extensão da classe String
fun String.firstUpper() = if (isEmpty()) this else this[0].uppercaseChar() + substring(1)

fun String.nbWords() = if (isBlank()) 0 else trim().split(Regex("\\s+")).size

// uma propriedade de extensão de uma classe do JDK
val LocalDate.isWeekend: Boolean
    get() = dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY

// uma função de extensão de um tipo anulável
fun Person?.description() = if (this == null) "absent person" else "person $firstName"

// resolução estática das extensões
open class Shape {
    open fun category() = "shape"
}

class Square : Shape() {
    override fun category() = "square"
}

fun Shape.name() = "a shape"

fun Square.name() = "a square"
  • linha 39: uma função de extensão para a classe [Person]. O nome da função é prefixado pelo tipo estendido, chamado de tipo receptor ([Person.]). No corpo da função, [this] refere-se ao objeto sobre o qual a função é chamada—o receptor—e seus membros são acessíveis sem prefixo, exatamente como em um método: [firstName], [lastName]. [firstName[0]] retorna o primeiro caractere da cadeia, e [uppercaseChar()] o converte em maiúscula;
  • linhas 42–46: duas propriedades de extensão. Elas são declaradas como funções, com um tipo receptor, e devem ter um acessor [get]: uma extensão não acrescenta nada ao objeto, portanto não pode armazenar um valor (uma propriedade de extensão não tem campo e não pode ter inicializador). Elas são lidas como propriedades: [p.isAdult], [p.fullName] (linha 12);
  • linhas 49–51: duas extensões da classe [String], usadas como métodos de qualquer cadeia: ["jean".firstUpper()]. Em [firstUpper], [this] é a própria cadeia. A função [nbWords] divide a cadeia usando a função [split], à qual se passa uma expressão regular ([Regex]): ["\\s+"] designa uma sequência de um ou mais caracteres de espaço (as expressões regulares são tratadas no Capítulo 5);
  • linhas 54–55: uma propriedade de extensão de uma classe Java, do JDK, [java.time.LocalDate]. Uma extensão se aplica a qualquer tipo, inclusive a uma classe Java ou a uma classe final. Observe que o método [getDayOfWeek] da classe Java é tratado pelo Kotlin como uma propriedade [dayOfWeek];
  • Linha 58: uma extensão de um tipo anulável, [Person?]. Ela pode ser chamada em uma referência a [null] sem o operador [?.] (linha 22): é ela que verifica se [this] é igual a [null]. Após a verificação, o compilador sabe que [this] não é [null] no ramo [else] e permite o acesso a [firstName] (trata-se da conversão inteligente de tipos, que o parágrafo seguinte explica com mais detalhes). A função [toString()] da biblioteca do Kotlin, que pode ser chamada em uma referência nula, é declarada assim: [fun Any?.toString(): String];
  • linhas 8–13: as funções e propriedades de extensão são chamadas como membros: [p.initials()], e não [Tools.initials(p)];
  • linhas 32–34: quando o tipo pode ser modificado, seus métodos são naturalmente colocados nele: a fábrica [unknown] é uma função do objeto companheiro da classe [Person] (linha 15);
  • linhas 61–71: uma classe [Shape] e sua classe derivada [Square], cada uma equipada com um método redefinido [category] e uma função de extensão [name]. Na linha 25, a variável [shape], declarada com o tipo [Shape], referencia um [Square]: no entanto, a chamada a [shape.name()] na verdade executa a extensão de [Shape]. A resolução de extensões é estática: o compilador seleciona a função com base no tipo declarado da variável e não no tipo real do objeto em tempo de execução. Na linha 27, o método [category] é polimórfico: é executado o método da classe [Square].

Resultados:

> gradlew -q run -Pmain=classes24.Classes24Kt
J.D.
Jean
Jean DUPONT is an adult: true
"the weather is fine" has 4 words
? ? is an adult: false
2026-10-04 is a weekend day: true
person jean / absent person
shape.name()=a shape, Square().name()=a square
shape.category()=square

Esse comportamento se explica pela maneira como o compilador traduz uma função de extensão: em um método estático, cujo primeiro parâmetro é o receptor. A função [fun Person.initials()] do arquivo [Classes24.kt] torna-se o método Java [public static final String initials(Person $this$initials)] da classe [classes24.Classes24Kt] (a propriedade de extensão *[isAdult] torna-se igualmente um método estático ***[isAdult(Person)]), e a chamada ***[p.initials()] torna-se ***[Classes24Kt.initials(p)]**. Em outras palavras, o Kotlin escreve por nós a classe utilitária Java e torna o seu uso mais legível. Um programa Java que usa uma biblioteca Kotlin chama as suas extensões dessa forma. Isso leva a várias regras:

  • uma extensão tem acesso apenas aos membros públicos do receptor: ela não enxerga seus membros privados ou protegidos;
  • uma extensão não pode ser sobrescrita em uma classe derivada: ela não é polimórfica;
  • se a classe tiver um membro com a mesma assinatura, esse membro é sempre o chamado, e o compilador avisa que a extensão é desnecessária ([this extension is shadowed by a member: 'fun g(): Int' defined in 'C']);
  • para ser usada em outro pacote, uma extensão deve ser importada, exatamente como uma função de nível superior ([import tools.initials]).

As funções de extensão são uma das características mais marcantes do Kotlin. Elas servem para enriquecer tipos sobre os quais não temos controle, mas também para separar, em nossas próprias classes, o núcleo da classe (seus membros) das funções utilitárias que apenas a acessam por fora. No Capítulo 7, veremos as lambdas com receptor, que se baseiam no mesmo princípio ([buildString { append(...) }]).

4.13. Pattern matching em objetos

A expressão [when] não se limita a valores simples (números, strings, enumerações): ela também se aplica a objetos. É possível verificar o tipo de um objeto, acrescentar uma condição e usar o objeto no tipo correto sem conversão explícita—tudo em uma única expressão. O Kotlin não possui, a rigor, “padrões” como o Java 21: ele obtém essencialmente o mesmo resultado com o operador [is], a conversão inteligente de tipos (smart cast) e a desestruturação. O programa [Classes25.kt] usa uma interface selada e três classes de dados que a implementam:

package classes25

// pattern matching em objetos: is, smart cast, when, desestruturação
fun main() {
    val objects: List<Any?> = listOf(
        Individual("Jean", "Dupont", 30),
        Individual("Lise", "Morel", 12),
        Teacher("Lucile", "Dumas", 56, 61),
        Teacher("Marc", "Petit", 44, 27),
        Student("Paul", "Martin", 19, "computer science"),
        "a string",
        42,
        null,
    )

    // 1 - o teste de tipo is e o smart cast
    for (o in objects) {
        if (o is Person) {
            // aqui o é uma Person
            println("${o.firstName} is of type ${o::class.simpleName}")
        }
    }

    // 2 - o teste de tipo seguido de uma condição
    for (o in objects) {
        if (o is Person && o.age >= 18) {
            println("${o.firstName} is an adult")
        }
    }

    // 3 - when sobre o tipo do objeto, com guards e desestruturação
    for (o in objects) {
        println(describe(o))
    }

    // 4 - um when exaustivo sobre uma interface sealed
    for (o in objects) {
        if (o is Person) {
            println("${o.firstName} : ${category(o)}")
        }
    }

    // 5 - os casts explícitos as e as?
    val first = objects[0] as Person
    val string = objects[0] as? String
    println("first=${first.firstName}, string=$string")
    try {
        val s = objects[0] as String
        println(s)
    } catch (ex: ClassCastException) {
        println("ClassCastException : ${ex.message}")
    }
}

fun describe(o: Any?): String = when (o) {
    is Teacher if o.section == 27 -> "${o.firstName} teaches computer science"
    is Teacher -> "${o.firstName} teaches in section ${o.section}"
    is Student -> {
        val (firstName, _, _, major) = o
        "$firstName studies $major"
    }
    is Person if o.age < 18 -> "${o.firstName} is a minor"
    is Person -> "${o.firstName} is ${o.age} years old"
    is String -> "a string of ${o.length} characters"
    is Int if o > 0 -> "the positive integer $o"
    null -> "the null reference"
    else -> "an unknown object"
}

// sem else: o compilador sabe que os três casos cobrem todas as pessoas
fun category(p: Person) = when (p) {
    is Individual -> "individual"
    is Teacher -> "teacher"
    is Student -> "student"
}

// uma interface sealed e as três data classes que a implementam
sealed interface Person {
    val firstName: String
    val lastName: String
    val age: Int
}

data class Individual(override val firstName: String, override val lastName: String, override val age: Int) : Person

data class Teacher(
    override val firstName: String,
    override val lastName: String,
    override val age: Int,
    val section: Int,
) : Person

data class Student(
    override val firstName: String,
    override val lastName: String,
    override val age: Int,
    val major: String,
) : Person
  • Linhas 78–97: uma interface selada [Person] ([sealed interface]), implementada por três classes de dados: [Individual], [Teacher] e [Student]. Como uma classe selada (veja a seção “Classes final, open e sealed”), uma interface selada só pode ser implementada por classes do mesmo pacote e do mesmo módulo: o compilador conhece, portanto, todas as suas implementações sem precisar que sejam listadas explicitamente, como exige a cláusula [permits] do Java. A interface declara as propriedades abstratas [firstName], [lastName] e [age]; as classes de dados as implementam usando propriedades do seu construtor primário, prefixadas com [override];
  • linhas 5–13: uma lista de objetos de vários tipos, incluindo um inteiro e a referência [null]. Seu tipo é [List<Any?>]: [Any?] é o tipo mais geral do Kotlin, que aceita qualquer objeto e o valor [null];
  • linha 18: a expressão [o is Person] é verdadeira se [o] se referir a um objeto do tipo [Person] (é falsa se [o] for igual a [null]). No bloco seguinte, o compilador sabe que [o] é um [Person]: ele permite [o.firstName] sem conversão. Trata-se da conversão inteligente de tipos (smart cast): o tipo de uma variável é testado, e a própria variável muda de tipo nos locais em que o teste é garantidamente verdadeiro. O Java 16 obtém o mesmo resultado declarando uma nova variável ([o instanceof Person p]); o Kotlin não precisa fazer isso. A conversão inteligente de tipos se aplica a variáveis locais [val], a variáveis [var] que não mudaram entre o teste e o uso, e a propriedades [val] do mesmo módulo sem acessores personalizados: o compilador precisa ter certeza de que o valor não poderia ter mudado entre o teste e o uso;
  • linha 26: a conversão inteligente de tipos também se aplica no restante da condição, após [&&];
  • linhas 55–67: a expressão [when] com um sujeito avalia os ramos em ordem e retorna o valor associado ao primeiro que corresponder:
    • linha 56: um professor da turma 27. Em um ramo [is Type], o sujeito [o] tem o tipo convertido de forma inteligente; a cláusula [if] acrescenta uma condição, chamada de guard (Kotlin 2.2), que equivale ao [when] dos padrões do Java;
    • linha 57: qualquer outro professor. A ordem é importante: se este caso fosse colocado antes do anterior, tornaria o anterior inacessível. O compilador do Kotlin não sinaliza isso (o Java o rejeitaria): o ramo simplesmente nunca seria escolhido;
    • linhas 58–60: um aluno, cujas propriedades são extraídas por desestruturação: [val (firstName, _, _, major) = o] chama [component1()] e [component4()] da classe de dados ([_] ignora uma propriedade). Isso equivale ao padrão de record do Java ([case Student(var firstName, _, _, var major)]), em duas etapas: a verificação do tipo, seguida da desestruturação. Um ramo pode conter um bloco; seu valor é o da última expressão do bloco;
    • linhas 62–63: um menor de idade e, em seguida, qualquer outra pessoa;
    • linha 64: uma string, cuja propriedade [length] pode ser usada;
    • linha 65: um inteiro positivo. Verifica-se o tipo [Int], e não [Integer] como em Java;
    • linha 66: o caso [null], um valor simples, comparado ao sujeito por [==]. Sem esse caso, a referência nula cairia no ramo [else]: um [when] sobre uma referência nula nunca lança uma exceção;
    • linha 67: o ramo [else] cobre todo o resto. Sem ele, o compilador informaria que a expressão [when] não trata todos os casos: uma expressão [when], que retorna um valor, deve ser exaustiva;
  • Linhas 71–74: um [when] sobre uma [Person], sem um [else]. Ainda assim, ele é exaustivo: como a interface é selada, o compilador sabe que uma pessoa é um [Individual], um [Teacher] ou um [Student];
  • linhas 44–51: conversões explícitas de tipo. [o as Person] converte [o] em [Person] e lança uma exceção [ClassCastException] se o objeto não for uma pessoa (linha 48); é o equivalente de [(Person) o] em Java. [o as? String] é a conversão de tipo “segura”: ela retorna [null] em vez de lançar uma exceção, o que combina bem com o operador Elvis ([o as? String ?: "default"]). Com a conversão inteligente de tipos, isso raramente é necessário.

Resultados:

> gradlew -q run -Pmain=classes25.Classes25Kt
Jean is of type Individual
Lise is of type Individual
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference
Jean : individual
Lise : individual
Lucile : teacher
Marc : teacher
Paul : student
first=Jean, string=null
ClassCastException : class classes25.Individual cannot be cast to class java.lang.String (classes25.Individual is in unnamed module of loader 'app'; java.lang.String is in module java.base of loader 'bootstrap')

Se você remover o case [Student] da função [category], o compilador sinaliza o problema:

Classes25.kt:71:27: error: 'when' expression must be exhaustive. Add the 'is Student' branch or an 'else' branch.

Esse é o grande benefício de combinar tipos selados com a expressão [when]: se uma quarta classe for adicionada à hierarquia, o compilador sinaliza todas as ocorrências de [when] que precisam ser completadas. Observe também que o teste [is] corresponde aos tipos que implementam a interface: o laço de verificação de tipos (linhas 16–20) identificou os três tipos de pessoas. O teste [when] sobre tipos é um substituto útil para testes [if (o is ...)] em cascata; no entanto, ele não deve substituir o polimorfismo: quando o comportamento depende do tipo do objeto e você controla a hierarquia de classes, um método redefinido em cada classe costuma ser a solução orientada a objetos. A filtragem com [when] é adequada para hierarquias de dados (classes de dados seladas) sobre as quais você deseja escrever uma lógica de processamento externa a esses dados.

4.14. Tratamento do valor null

Em Java, qualquer variável de tipo referência pode ser null, e o uso de uma referência nula provoca a NullPointerException, o erro de execução mais comum. Vimos no Capítulo 3 como o Kotlin trata esse problema: o compilador distingue os tipos que podem ser [null] ([String?]) dos que não podem ([String]), e só permite o acesso aos membros de uma referência anulável após uma verificação, ou por meio dos operadores [?.], [?:], e [!!]. Onde o Java usa a classe [Optional<T>], os métodos [Objects.requireNonNull] e [Objects.requireNonNullElse] , ou anotações como as da biblioteca JSpecify ([@Nullable], [@NullMarked]), o Kotlin se apoia no próprio sistema de tipos. Aqui, exploramos esses conceitos com mais detalhes no contexto das classes: propriedades anuláveis, propriedades de inicialização tardia e a fronteira com o código Java. O programa [Classes26.kt] usa o exemplo da versão Java:

package classes26

// tratamento do valor nulo em classes: tipos anuláveis, ?., ?:, ?.let, requireNotNull, !!,
// lateinit, tipos de plataforma
fun main() {
    val jean = Person("Jean", "Dupont")
    jean.middleName = "Marie"
    val persons = listOf(jean, Person("Paul", "Martin"))
    for (p in persons) {
        // um valor padrão quando a referência é null: o operador Elvis
        val middle = p.middleName ?: "(none)"
        // a chamada segura ?.: null se a referência for null
        val length = p.middleName?.length
        println("${p.firstName} : middle name=$middle, length=$length")
    }

    // uma função que pode não encontrar nada: ela retorna uma Person?
    var found = find(persons, "Durand")
    println("Durand found: ${found != null}")
    println(found?.firstName ?: "Durand: person not found")
    // a referência é testada antes de ser usada: smart cast
    found = find(persons, "Martin")
    if (found != null) {
        println("Martin : ${found.firstName}")
    }
    // ?.let: o bloco só é executado se a referência não for null
    find(persons, "Dupont")?.let { it.middleName = "Louise" }
    find(persons, "Durand")?.let { it.middleName = "Louise" }
    println(jean.middleName)
    // requireNotNull: afirmamos que a referência não é nula, caso contrário uma exceção é lançada
    val martin = requireNotNull(find(persons, "Martin")) { "Martin cannot be found" }
    println(martin.firstName)
    try {
        requireNotNull(find(persons, "Durand")) { "Durand cannot be found" }
    } catch (ex: IllegalArgumentException) {
        println("Error: ${ex.message}")
    }
    // o operador !!: uma NullPointerException se a referência for null
    try {
        val lise = Person("Lise", "Morel")
        println(lise.middleName!!.length)
    } catch (ex: NullPointerException) {
        println("Error: $ex")
    }

    // uma propriedade lateinit: inicializada após a construção
    val paul = persons[1]
    println("Paul's email initialized: ${paul.hasEmail}")
    try {
        println(paul.email)
    } catch (ex: UninitializedPropertyAccessException) {
        println("Error: ${ex.message}")
    }
    paul.email = "paul.martin@example.com"
    println("Paul's email: ${paul.email}, initialized: ${paul.hasEmail}")

    // tipos de plataforma: um método Java pode retornar null
    val variable = System.getenv("NONEXISTENT_VARIABLE")
    println("variable=$variable, length=${variable?.length}")
    try {
        val value: String = System.getenv("NONEXISTENT_VARIABLE")
        println(value.length)
    } catch (ex: NullPointerException) {
        println("Error: ${ex.message}")
    }
}

// busca de uma pessoa pelo sobrenome: null se não for encontrada
fun find(persons: List<Person>, lastName: String): Person? = persons.firstOrNull { it.lastName == lastName }

class Person(val firstName: String, val lastName: String) {
    // propriedade opcional: null significa "sem nome do meio"
    var middleName: String? = null

    // propriedade obrigatória, mas inicializada após a construção
    lateinit var email: String

    // a propriedade lateinit foi inicializada?
    val hasEmail: Boolean
        get() = this::email.isInitialized
}
  • Linhas 71–80: a classe [Person] tem duas propriedades obrigatórias, do tipo [String], inicializadas pelo construtor primário, e uma propriedade opcional, [middleName], do tipo [String?]: [null] significa “sem nome do meio”. O construtor não precisa validar seus parâmetros como fazia a versão Java com [Objects.requireNonNull]: o compilador rejeita uma chamada a [Person(null, "Morel")] ([null cannot be a value of a non-null type 'String']). O erro é detectado antes mesmo da execução;
  • linha 11: o operador Elvis [?:] retorna o valor à esquerda se ele não for igual a [null], e o valor à direita caso contrário. Isso equivale a [Objects.requireNonNullElse(value, defaultValue)];
  • linha 13: a chamada segura [?.] retorna [null] se a referência for [null], e, caso contrário, o comprimento da string: [length] é do tipo [Int?]. O acesso direto a [p.middleName.length] é rejeitado pelo compilador: [only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'String?'];
  • linha 69: a função [find] retorna a pessoa procurada, ou [null] se não conseguir encontrá-la: seu tipo de retorno, [Person?], avisa o chamador de que o resultado pode estar ausente, e o compilador exige que o chamador trate esse caso para usar a pessoa. Esse é o papel desempenhado por [Optional<Person>] em Java, sem nenhum objeto adicional. A função de extensão [firstOrNull] retorna o primeiro elemento da lista que satisfaz a condição, ou [null];
  • linha 19: a presença de um valor é testada comparando-o a [null] (o equivalente de [isPresent()]);
  • linha 20: a combinação de [?.] seguido de [?:] converte qualquer pessoa presente em seu primeiro nome e fornece um valor padrão. Isso equivale a [found.map(Person::getFirstName).orElse(...)];
  • Linhas 23–24: após o teste [found != null], a conversão inteligente de tipo (smart cast) transforma [found] em [Person] dentro do bloco: [found.firstName] é acessado diretamente. A conversão inteligente de tipo funciona aqui mesmo que [found] seja uma variável do tipo [var], porque ela não é modificada entre o teste e o seu uso;
  • Linhas 27–28: [x?.let { ... }] executa o bloco somente se [x] não for igual a [null]; dentro do bloco, [it] refere-se ao valor, que é de um tipo não anulável. Isso equivale a [ifPresent]. Dupont existe e recebe um novo nome do meio; Durand não existe, e a instrução não faz nada;
  • Linha 31: [requireNotNull(value) { message }] retorna o valor se ele não for [null], como um tipo não anulável, e caso contrário lança uma exceção [IllegalArgumentException] com a mensagem especificada (linhas 34–36). É usada quando a ausência de um valor constitui um erro: é o equivalente de [orElseThrow]. Sua contrapartida, [checkNotNull], lança uma exceção [IllegalStateException];
  • Linhas 40–41: o operador [!!] verifica se a referência é igual a [null] e lança a exceção [NullPointerException] se for. Aqui, a exceção não tem mensagem: preferimos [requireNotNull] ou [checkNotNull], que fornecem uma. O operador [!!] deve ser reservado para os casos em que você tem certeza... e em que o compilador não tem como saber disso;
  • Linha 76: uma propriedade [lateinit] (“inicializada tardiamente”). Uma propriedade não anulável normalmente deve ser inicializada na construção. Mas alguns valores só são conhecidos depois: uma dependência injetada pelo Spring (Capítulo 6), um objeto preparado por um método de inicialização de teste etc. Em vez de declarar a propriedade como anulável — e ter de escrever [?.] ou [!!] a cada uso —, nós a declaramos como [lateinit var]: ela é do tipo [String] e é usada como tal. Uma propriedade [lateinit] deve ser uma [var] de um tipo não anulável e não primitivo ([lateinit var n: Int] é proibido);
  • linhas 50–51: a leitura de uma propriedade [lateinit] antes de ela ser inicializada lança a exceção [UninitializedPropertyAccessException], cuja mensagem indica o nome da propriedade; isso é mais claro do que uma exceção [NullPointerException] ocorrendo mais tarde;
  • linhas 79–80: a expressão [this::email.isInitialized] indica se a propriedade foi inicializada. [this::email] é uma referência de propriedade (Capítulo 7); esse teste só é permitido dentro da classe que declara a propriedade;
  • linhas 58–62: a fronteira com o Java. O método Java [System.getenv(name)] retorna o valor de uma variável de ambiente, ou [null] se ela não existir; no entanto, nada em sua assinatura Java indica isso ao compilador Kotlin. Seu valor de retorno tem um tipo de plataforma, denotado por [String!] nas mensagens do compilador e no IntelliJ IDEA: um tipo para o qual o Kotlin não sabe se é anulável ou não, e que permite ao desenvolvedor usar como *[String] ou como *[String?], por sua conta e risco. Na linha 58, a variável [variable] é do tipo de plataforma, e nós a tratamos com cautela como [?.]. Na linha 61, afirmamos que ela não é nula ao declará-la como [String]: o compilador então insere uma verificação, e a exceção [NullPointerException] é lançada imediatamente na atribuição, com uma mensagem que identifica o método responsável ([getenv(...) must not be null]), em vez de mais tarde, durante o uso. Quando o código Java é anotado ([@Nullable], [@NonNull] do JSpecify ou da JetBrains), o Kotlin leva isso em conta, e o tipo deixa de ser um tipo de plataforma: é o caso de grande parte do Spring Framework 7, que usaremos.

Resultados:

> gradlew -q run -Pmain=classes26.Classes26Kt
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand found: false
Durand: person not found
Martin : Paul
Louise
Paul
Error: Durand cannot be found
Error: java.lang.NullPointerException
Paul's email initialized: false
Error: lateinit property email has not been initialized
Paul's email: paul.martin@example.com, initialized: true
variable=null, length=null
Error: getenv(...) must not be null

A classe Java *[Optional]* continua utilizável em Kotlin quando uma biblioteca Java fornece uma (a função de extensão ***[getOrNull()] do pacote *[kotlin.jvm.optionals] a converte então em um tipo anulável), mas não a usamos no código Kotlin: um tipo anulável faz a mesma coisa — verificada pelo compilador — sem criar um objeto. Neste curso, declaramos como anuláveis apenas os valores opcionais; preferimos objetos sempre completos (construídos com todos os seus valores obrigatórios) a objetos preenchidos de forma incremental; reservamos [lateinit] para propriedades inicializadas por um framework, e tratamos com cautela os valores provenientes do Java.

4.15. Aplicação de exemplo - V2

Retomamos o cálculo do imposto já abordado no capítulo anterior (versão 1) e agora o implementamos usando classes e interfaces. Vamos relembrar o problema. Queremos escrever um programa para calcular o imposto de um contribuinte. Consideraremos o caso simplificado de um contribuinte que tem apenas seu salário a declarar (a tabela de 2004 para os rendimentos de 2003, usada tal como está: trata-se de um exercício):

  • calculamos o número de cotas do funcionário: cotas = nbChildren / 2 + 1 se ele for solteiro, nbChildren / 2 + 2 se for casado, onde nbChildren é o número de filhos;
  • se ele tiver pelo menos três filhos, recebe meia cota adicional;
  • sua renda tributável R é calculada como R = 0,72 × S, onde S é o seu salário anual;
  • seu quociente familiar é calculado como QF = R / cotas;
  • seu imposto I é calculado com base na tabela a seguir:
limite
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada linha tem três campos. Para calcular o imposto I, procure a primeira linha em que QF ≤ limite. Por exemplo, se QF = 5.000, será encontrada a linha (8.382; 0,068; 291,09). O imposto I é então igual a 0,068 × R - 291,09 × cotas. Se QF for tal que a condição QF ≤ limite nunca seja satisfeita, usam-se os coeficientes da última linha, resultando em imposto I = 0,481 × R - 9.505,54 × cotas.

A aplicação cria o pacote [taxv2]. As classes de cálculo são organizadas em um subpacote [taxv2.tax]:

1
2
3
4
5
6
7
src/main/kotlin/taxv2/
  Main.kt                   the dialog program with the user
  tax/
    TaxBracket.kt           a bracket of the tax scale
    ITax.kt                 the tax calculation interface
    AbstractTax.kt          an abstract class implementing ITax
    HardwiredTax.kt         a derived class, with hard-coded data

Primeiro, definimos um tipo capaz de encapsular uma linha da tabela anterior [TaxBracket.kt]:

1
2
3
4
5
6
package taxv2.tax

import java.math.BigDecimal

// uma faixa da tabela de imposto
data class TaxBracket(val limit: BigDecimal, val coeffR: BigDecimal, val coeffN: BigDecimal)

Usamos uma classe de dados:

  • porque uma faixa é um pequeno dado sem identidade, definido unicamente por seu valor, e não há motivo para que seja modificado depois de criado: suas propriedades são [val];
  • porque o compilador gera [toString], o operador de igualdade, [copy], e a desestruturação em uma única linha.

As propriedades são do tipo [BigDecimal] (pacote [java.math], daí o import na linha 3): o Kotlin usa essa classe diretamente do JDK. Os tipos [Float] e [Double] representam números em binário: um número decimal como 0,068 não tem representação exata nesses tipos, e os cálculos acumulam pequenos erros de arredondamento. A classe [BigDecimal] representa números decimais com exatidão: é o tipo a usar para valores monetários. Em Java, sua desvantagem é a ausência de operadores: é preciso escrever [a.add(b)], [a.multiply(b)], [a.compareTo(b)]. A biblioteca Kotlin adiciona os operadores [+], [-], [*], [/], [%], e o operador de menos unário; e, como [BigDecimal] implementa [Comparable], os operadores de comparação [<], [<=]… também se aplicam. Aproveitaremos isso, com uma exceção: a divisão.

Em seguida, definimos uma interface [ITax] capaz de calcular o imposto [ITax.kt]:

1
2
3
4
5
6
package taxv2.tax

interface ITax {
    // cálculo do imposto para um contribuinte
    fun calculate(married: Boolean, nbChildren: Int, salary: Int): Int
}
  • Linha 5: o método de cálculo do imposto com base em três dados: o estado civil do contribuinte, o número de filhos e o salário anual. Ele arredonda o imposto para baixo, para o euro inteiro mais próximo.

Depois, definimos uma classe abstrata que implementa essa interface [AbstractTax.kt]:

package taxv2.tax

import java.math.BigDecimal
import java.math.MathContext

abstract class AbstractTax : ITax {
    // as faixas de imposto necessárias para o cálculo vêm de uma fonte externa
    // que somente as classes derivadas conhecem
    protected abstract val taxBrackets: List<TaxBracket>

    // cálculo do imposto
    override fun calculate(married: Boolean, nbChildren: Int, salary: Int): Int {
        // cálculo do número de cotas
        var shares = nbChildren.toBigDecimal().divide(BigDecimal.TWO) + (if (married) 2 else 1).toBigDecimal()
        if (nbChildren >= 3) {
            shares += BigDecimal("0.5")
        }
        // cálculo da renda tributável e do quociente familiar
        val income = BigDecimal("0.72") * salary.toBigDecimal()
        val quotient = income.divide(shares, MathContext.DECIMAL128)
        // busca da faixa de imposto: a última é usada se nenhum limite servir
        val brackets = taxBrackets
        val bracket = brackets.dropLast(1).firstOrNull { quotient <= it.limit } ?: brackets.last()
        // cálculo do imposto
        return (income * bracket.coeffR - shares * bracket.coeffN).toInt()
    }
}
  • Linha 1: a classe pertence ao pacote [taxv2.tax]; seu arquivo fica na pasta [taxv2/tax];
  • linha 6: a classe [AbstractTax] implementa a interface [ITax];
  • linha 9: os dados da tabela, fornecidos por uma propriedade abstrata protegida (a versão Java usava um método abstrato [getTaxBrackets()]). A classe [AbstractTax] não sabe de onde vêm esses dados (escritos no código, lidos de um arquivo, de um banco de dados etc.). Ela deixa essa tarefa para as classes derivadas. Por isso é declarada abstrata, o que impede sua instanciação. A propriedade abstrata obriga as classes derivadas a fornecer as faixas de imposto: o compilador verifica isso. Seu tipo, [List<TaxBracket>], é o de uma lista somente leitura: a classe não pode modificar a tabela que lhe é fornecida;
  • Linhas 12–25: a implementação do método [calculate] da interface [ITax]. As classes derivadas não precisarão sobrescrever esse método. A classe [AbstractTax] serve assim de classe base para as classes derivadas: ela contém o que é comum a todas elas;
  • linha 14: o número de cotas. A função de extensão [toBigDecimal()] converte um inteiro em [BigDecimal] (como [BigDecimal.valueOf(n)]); a divisão por [BigDecimal.TWO] é exata (3 / 2 = 1,5), ao contrário da divisão inteira por [nbChildren / 2] (3 / 2 = 1). A expressão [if (married) 2 else 1] vale 2 para um contribuinte casado e 1 caso contrário. A adição é escrita com o operador [+]. A divisão, por outro lado, é feita com o método [divide] do Java, e não com o operador [/]: o operador [/] do Kotlin aplicado a [BigDecimal] preserva o número de casas decimais do dividendo e arredonda o resultado; [3.toBigDecimal() / BigDecimal.TWO] é igual a 2, e não a 1,5! Essa é uma armadilha conhecida, que é melhor evitar escrevendo sempre as divisões de [BigDecimal] com [divide], o que obriga a pensar na precisão desejada;
  • Linhas 15–16: a meia cota adicional. Um [BigDecimal] é imutável: [shares += x] é convertido em [shares = shares + x], o que cria um novo objeto atribuído à variável; é por isso que [shares] é uma [var];
  • Linhas 19–20: a renda tributável e o quociente familiar. As constantes decimais são criadas a partir de strings ([BigDecimal("0.72")]) para garantir que sejam exatas. A divisão de um [BigDecimal] pode resultar em um número infinito de casas decimais (1 / 3): especificamos a precisão desejada, neste caso [MathContext.DECIMAL128] (34 dígitos significativos);
  • linha 23: a busca pelo intervalo, em uma única linha. [brackets.dropLast(1)] retorna a lista de faixas, exceto a última; [firstOrNull { quotient <= it.limit }] procura a primeira faixa cujo limite seja maior ou igual ao quociente familiar (o operador [<=] chama [compareTo]), ou retorna [null] se não houver nenhuma; o operador Elvis retorna então a última faixa ([brackets.last()]). A versão Java usava um laço [for] e um [break]; as duas expressões são equivalentes;
  • linha 25: o cálculo do imposto, escrito com os operadores [*] e [-], é muito mais legível do que [income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN()))]. A função [toInt] trunca o resultado para sua parte inteira.

Uma classe que implementa a interface [ITax] pode ser criada derivando-se da classe [AbstractTax]. É o que fazemos agora com [HardwiredTax.kt]:

package taxv2.tax

class HardwiredTax : AbstractTax() {
    // as faixas de imposto, construídas a partir dos dados fixos no código
    override val taxBrackets: List<TaxBracket> = LIMITS.indices.map { i ->
        TaxBracket(LIMITS[i].toBigDecimal(), COEFF_R[i].toBigDecimal(), COEFF_N[i].toBigDecimal())
    }

    companion object {
        // dados para o cálculo do imposto (tabela de 2004 sobre a renda de 2003), "fixos no código" (hard-coded)
        private val LIMITS = doubleArrayOf(4962.0, 8382.0, 14753.0, 23888.0, 38868.0, 47932.0, 0.0)
        private val COEFF_R = doubleArrayOf(0.0, 0.068, 0.191, 0.283, 0.374, 0.426, 0.481)
        private val COEFF_N = doubleArrayOf(0.0, 291.09, 1322.92, 2668.39, 4846.98, 6883.66, 9505.54)
    }
}
  • Linhas 9–13: a classe [HardwiredTax] fixa no código os dados necessários para calcular o imposto. Esses dados ficam no objeto companheiro e são compartilhados por todas as instâncias, de modo semelhante aos campos [static final] da versão Java. São arrays de [Double] ([DoubleArray], criados por [doubleArrayOf]); seus elementos são escritos como [4962.0] e não como [4962], já que não há conversão implícita de [Int] para [Double]. Por convenção, os nomes de constantes são escritos em maiúsculas;
  • Linhas 5–6: a implementação da propriedade abstrata da classe pai, inicializada quando o objeto é construído. [LIMITS.indices] é o intervalo de índices do array (0..6); a função [map] constrói a lista dos resultados da lambda para cada um deles, neste caso uma faixa por índice. A função de extensão [Double.toBigDecimal()] converte um [Double] em um [BigDecimal] por meio de sua representação decimal mais curta: [0.068.toBigDecimal()] é exatamente 0,068, assim como [BigDecimal.valueOf(0.068)] em Java. Não use o construtor [BigDecimal(0.068)], que reproduz todas as casas decimais do valor binário aproximado (0.068000000000000004884981308350688…);
  • a lista retornada por [map] é exposta como o tipo [List<TaxBracket>], somente leitura: nenhuma classe poderá modificar a tabela por meio dessa propriedade (a versão Java criava uma cópia somente leitura com [List.copyOf]). A propriedade redefinida mantém a visibilidade ([protected]) da propriedade abstrata.

O próximo capítulo apresentará outras classes derivadas de [AbstractTax], que lerão as faixas de um arquivo de texto ou JSON: elas só precisarão fornecer a propriedade [taxBrackets].

Um programa de teste poderia ser como o seguinte [Main.kt]:

// programa interativo de cálculo do imposto
// o usuário digita três dados no teclado: married nbChildren salary
// o programa então exibe o imposto a pagar
package taxv2

import taxv2.tax.HardwiredTax
import taxv2.tax.ITax

// a mensagem de ajuda
private val SYNTAX = """
    syntax: Married NbChildren Salary
    Married: y for married, n for not married
    NbChildren: number of children
    Salary: annual salary in euros
""".trimIndent()

fun main() {
    // criação de um objeto ITax
    val tax: ITax = HardwiredTax()

    // laço de entrada
    while (true) {
        // pedimos os parâmetros do cálculo do imposto
        print("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ")
        val parameters = readlnOrNull()
        // fim da entrada padrão ou linha vazia: paramos
        if (parameters.isNullOrBlank()) {
            break
        }
        // verificação do número de campos da linha digitada
        val fields = parameters.trim().split(Regex("\\s+"))
        if (fields.size != 3) {
            println(SYNTAX)
            continue
        }
        // verificação da validade dos parâmetros
        // married
        val married = fields[0].lowercase()
        if (married != "y" && married != "n") {
            println("$SYNTAX\nIncorrect married argument: type y or n")
            continue
        }
        // nbChildren
        val nbChildren = positiveInteger(fields[1])
        if (nbChildren == null) {
            println("$SYNTAX\nIncorrect NbChildren argument: type a positive or zero integer")
            continue
        }
        // salary
        val salary = positiveInteger(fields[2])
        if (salary == null) {
            println("$SYNTAX\nIncorrect salary argument: type a positive or zero integer")
            continue
        }
        // os parâmetros estão corretos: calculamos o imposto
        println("Tax=${tax.calculate(married == "y", nbChildren, salary)} euros")
    }
}

// retorna o inteiro positivo ou zero representado pela string, null se a string não representar um
fun positiveInteger(string: String): Int? = string.toIntOrNull()?.takeIf { it >= 0 }

O programa acima permite ao usuário realizar simulações repetidas de cálculo de imposto.

  • linhas 4–7: o programa principal está no pacote [taxv2]; ele importa os dois tipos de que precisa do subpacote [taxv2.tax]. O comentário de cabeçalho pode preceder a declaração do pacote;
  • Linhas 10–15: a mensagem de ajuda é uma propriedade de nível superior, privada ao arquivo, escrita como uma string bruta (raw string) delimitada por três aspas; a string pode se estender por várias linhas. A função [trimIndent()] remove a indentação comum das linhas, bem como a primeira e a última linhas se estiverem vazias: a string, portanto, não termina com uma quebra de linha. Uma propriedade [const val] não é possível aqui, já que o valor é calculado por uma função;
  • Linha 19: criação de um objeto [tax] que implementa a interface [ITax]. Esse objeto é obtido instanciando-se um tipo [HardwiredTax], um tipo que implementa a interface [ITax]. Observe que não deixamos o compilador inferir o tipo *[HardwiredTax] a partir da variável *[tax]*; em vez disso, atribuímos a ela explicitamente o tipo *[ITax]. Ao escrever isso, indicamos que só nos interessa o método [calculate] do objeto [tax] e não o resto. Para usar dados de um arquivo, basta alterar essa única linha;
  • linhas 22–56: o laço das simulações de cálculo de imposto;
  • linhas 24–25: os três parâmetros necessários ao método [calculate] são digitados em uma única linha no teclado. [print] exibe a mensagem sem passar para a linha seguinte, e então [readlnOrNull()] lê uma linha; ele retorna [null] se a entrada padrão estiver fechada;
  • linha 27: a função de extensão [isNullOrBlank], definida no tipo [String?], é verdadeira se a string for [null] ou contiver apenas espaços; o programa então termina. Após esse teste, o compilador sabe que [parameters] não é [null] (a função indica isso ao compilador por meio de um “contrato”): isso permite a chamada a [parameters.trim()] sem [?.];
  • linha 31: a função [split] divide a linha — sem os espaços iniciais e finais — em palavras separadas por um ou mais caracteres de espaço em branco (expressão regular ["\\s+"]). Ela retorna uma [List<String>], cujo tamanho é testado com [size];
  • Linhas 38–39: a função [lowercase] converte a string para minúsculas; as strings são comparadas com [==] e [!=], que comparam seus conteúdos;
  • linhas 44–51: a função [positiveInteger] (linha 61) verifica se os dois últimos campos são inteiros positivos ou zero. Ela retorna um [Int?]: [null] sinaliza um erro, enquanto a versão Java retornava o valor -1. [toIntOrNull()] retorna [null] se a string não representar um inteiro (em vez de lançar uma exceção como [Integer.parseInt]), e [takeIf { it >= 0 }] retorna o valor se a condição for verdadeira e [null] caso contrário. Após os testes [nbChildren == null] e [salary == null], seguidos de [continue], o compilador sabe que as duas variáveis não são iguais a [null]: elas são do tipo [Int] no restante do laço;
  • linha 56: chamada ao método [calculate] do objeto [tax] que implementa a interface [ITax].

Eis um exemplo de execução do programa, iniciado a partir da pasta do projeto [04-classes]. A entrada, fornecida por redirecionamento da entrada padrão, foi reinserida na exibição nos pontos em que o programa a lê, exatamente como apareceria se fosse digitada no teclado:

> gradlew -q run -Pmain=taxv2.MainKt
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop:

Os valores do cálculo do imposto estão corretos: 4.282 euros para um contribuinte casado com dois filhos e salário anual de 60.000 euros (linha 25 dos resultados), e 2.959 euros com três filhos (linha 27). Um contribuinte solteiro sem filhos paga 11.519 euros pelo mesmo salário (linha 29). Esses são os resultados da versão Java.

Em comparação com a versão 1, o cálculo agora está encapsulado em classes por trás de uma interface: o programa de diálogo conhece apenas a interface [ITax]. As versões seguintes aproveitarão essa separação: a versão 3 (próximo capítulo) mudará a fonte de dados derivando novas classes de [AbstractTax], e depois a aplicação será organizada em camadas (Capítulo 6).