Stephen Samuel

Stefan Bocutiu

Novatec
Copyright © Packt Publishing 2017. First published in the English language under the title ‘Programming Kotlin
(9781787126367)’.
Copyright © Packt Publishing 2017. Publicação original em inglês intitulada ‘Programming Kotlin (9781787126367)’.
Esta tradução é publicada e vendida com a permissão da Packt Publishing.
© Novatec Editora Ltda. 2017.
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra,
mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.
Editor: Rubens Prates OG20170914
Tradução: Lúcia A. Kinoshita
Revisão gramatical: Patrizia Zagni
Editoração eletrônica: Carolina Kuwabata
ISBN: 978-85-7522-605-6
Histórico de impressões:
Setembro/2017 Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Email: novatec@novatec.com.br
Site: www.novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
 Sumário

Prefácio..................................................................................................................................15

Capítulo 1 ■ Introdução à linguagem Kotlin.............................................................................20

Usando a linha de comando para compilar e executar código Kotlin...........................21
Runtime de Kotlin.................................................................................................... 23
REPL........................................................................................................................24
Kotlin para scripting.................................................................................................24
Kotlin com Gradle.................................................................................................... 25
Kotlin com Maven.....................................................................................................28
IntelliJ e Kotlin.........................................................................................................32
Eclipse e Kotlin.........................................................................................................36
Misturando Kotlin e Java em um projeto....................................................................37
Resumo................................................................................................................... 44

Capítulo 2 ■ Básico sobre Kotlin...............................................................................................45

Vals e vars.................................................................................................................45
Inferência de tipo..................................................................................................... 46
Tipos básicos............................................................................................................47
Números.............................................................................................................47
Booleanos............................................................................................................49
Chars..................................................................................................................49
Strings.................................................................................................................49
Arrays.................................................................................................................50
Comentários.............................................................................................................50
Pacotes.....................................................................................................................51
Importações..............................................................................................................51
Importações com caractere-curinga......................................................................51
Renomeando na importação.................................................................................52
Templates de string...................................................................................................52
Intervalos..................................................................................................................53
Laços........................................................................................................................54

5
6 Programando com Kotlin

Tratamento de exceções............................................................................................56
Instanciando classes..................................................................................................57
Igualdade referencial e igualdade estrutural...............................................................57
Expressão this..........................................................................................................58
Escopo................................................................................................................58
Modificadores de visibilidade....................................................................................59
Private.................................................................................................................59
Protected............................................................................................................ 60
Internal.............................................................................................................. 60
Controle de fluxo como expressões........................................................................... 60
Sintaxe de null..........................................................................................................61
Verificação de tipos e casting................................................................................62
Casts inteligentes.................................................................................................62
Casting explícito................................................................................................. 64
Expressão when....................................................................................................... 64
When (valor)........................................................................................................65
When sem argumento..........................................................................................67
Retorno de função...............................................................................................67
Hierarquia de tipos...................................................................................................69
Resumo....................................................................................................................70

Capítulo 3 ■ Programação orientada a objetos em Kotlin..........................................................71

Classes.....................................................................................................................73
Níveis de acesso...................................................................................................76
Classes aninhadas............................................................................................... 77
Classes de dados..................................................................................................79
Classes enum...................................................................................................... 80
Métodos estáticos e objetos companheiros............................................................81
Interfaces..................................................................................................................87
Herança....................................................................................................................91
Modificadores de visibilidade....................................................................................94
Classes abstratas.......................................................................................................96
Interface ou classe abstrata........................................................................................97
Polimorfismo............................................................................................................98
Regras para sobrescrita...........................................................................................104
Herança versus composição.....................................................................................107
Delegação de classe.................................................................................................109
Classes seladas........................................................................................................ 111
Resumo..................................................................................................................112
Sumário 7

Capítulo 4 ■ Funções em Kotlin.............................................................................................. 113

Definindo funções...................................................................................................113
Funções com uma única expressão.......................................................................... 114
Funções-membro....................................................................................................115
Funções locais........................................................................................................ 116
Funções de nível superior........................................................................................119
Parâmetros nomeados.............................................................................................120
Parâmetros default..................................................................................................121
Funções de extensão...............................................................................................123
Precedência para funções de extensão.................................................................125
Funções de extensão em nulls.............................................................................127
Funções-membro de extensão............................................................................127
Sobrescrevendo funções-membro de extensão.....................................................128
Extensões em objetos companheiros...................................................................130
Múltiplos valores de retorno...............................................................................131
Funções infixas..................................................................................................132
Operadores.............................................................................................................134
Sobrecarga de operadores...................................................................................135
Operadores básicos............................................................................................137
in/contains........................................................................................................137
get/set................................................................................................................138
Comparação......................................................................................................140
Atribuição.........................................................................................................140
Interoperabilidade com Java............................................................................... 141
Funções literais....................................................................................................... 142
Funções tail recursive.............................................................................................. 143
varargs.................................................................................................................... 145
Operador de spread............................................................................................146
Funções da biblioteca-padrão..................................................................................146
apply.................................................................................................................146
let...................................................................................................................... 147
with................................................................................................................... 147
run....................................................................................................................148
lazy...................................................................................................................148
use....................................................................................................................149
repeat................................................................................................................149
require/assert/check...........................................................................................149
Funções genéricas...................................................................................................150
Funções puras.........................................................................................................151
8 Programando com Kotlin

Java a partir de Kotlin.............................................................................................153

Getters e setters.................................................................................................153
Métodos abstratos únicos...................................................................................154
Escapando identificadores de Kotlin...................................................................155
Exceções verificadas...........................................................................................155
Métodos void em Java........................................................................................155
Kotlin a partir de Java.............................................................................................156
Funções de nível superior...................................................................................156
Parâmetros default.............................................................................................157
Objetos e métodos estáticos...............................................................................157
Nomes em caso de apagamento (erasure)............................................................158
Captura de exceções verificadas.........................................................................159
Resumo..................................................................................................................159

Capítulo 5 ■ Funções de ordem superior e programação funcional..........................................160

Funções de ordem superior......................................................................................160
Devolvendo uma função.....................................................................................162
Atribuição de função..........................................................................................163
Closures.................................................................................................................164
Funções anônimas..................................................................................................165
Referências a funções..............................................................................................166
Referências a funções de nível superior...............................................................166
Referências a funções-membro e a funções de extensão.......................................166
Referências vinculadas.......................................................................................167
Receptores de funções literais..................................................................................168
Funções na JVM.....................................................................................................169
Bytecode............................................................................................................169
Composição de funções...........................................................................................171
Funções inline........................................................................................................173
Noinline............................................................................................................177
Currying e aplicação parcial....................................................................................178
Currying em ação..............................................................................................179
Acrescentando suporte a currying......................................................................180
Memoização...........................................................................................................181
Implementando a memoização...........................................................................183
Alias de tipo...........................................................................................................184
Either.....................................................................................................................186
fold....................................................................................................................186
Projeção.............................................................................................................187
Outras funções de projeção................................................................................189
Sumário 9

DSLs personalizadas...............................................................................................191
Funções infixas como palavras reservadas..........................................................192
Usando receptores de função em uma DSL.........................................................195
Validação e acúmulo de erros..................................................................................197
Resumo..................................................................................................................200

Capítulo 6 ■ Propriedades......................................................................................................201
Por que usar propriedades?......................................................................................201
Sintaxe e variações..................................................................................................204
Visibilidade.............................................................................................................207
Inicialização tardia..................................................................................................208
Propriedades delegadas...........................................................................................209
Inicializações preguiçosas........................................................................................216
lateinit versus lazy...................................................................................................221
Observáveis............................................................................................................222
Delegação de uma propriedade diferente de null.......................................................223
Propriedades ou métodos?.......................................................................................224
Resumo..................................................................................................................225

Capítulo 7 ■ Null safety, reflexão e anotações.........................................................................226

Tipos nullable.........................................................................................................227
Cast inteligente.......................................................................................................228
Acesso seguro de null..............................................................................................228
Operador force...................................................................................................230
Operador Elvis........................................................................................................231
Casting seguro........................................................................................................232
Opcionais...............................................................................................................232
Criando e devolvendo um Optional....................................................................233
Usando um Optional.........................................................................................233
Reflexão.................................................................................................................234
KClass...............................................................................................................235
Instanciação usando reflexão..............................................................................236
Construtores...........................................................................................................238
Instanciação com callBy.....................................................................................239
Objetos e companheiros.......................................................................................... 241
Propriedades úteis de KClass...................................................................................242
Funções e propriedades reflexivas............................................................................243
Chamando uma função de modo reflexivo..........................................................245
Variantes declaradas e não declaradas.................................................................245
10 Programando com Kotlin

Anotações...............................................................................................................246
Parâmetros de anotações....................................................................................247
Anotações-padrão...................................................................................................248
@JvmName.......................................................................................................248
@JvmStatic........................................................................................................249
@Throws..........................................................................................................249
@JvmOverloads.................................................................................................251
Descoberta de anotações em tempo de execução......................................................252
Resumo..................................................................................................................253

Capítulo 8 ■ Genéricos...........................................................................................................254
Funções parametrizadas..........................................................................................254
Tipos parametrizados..............................................................................................256
Polimorfismo restrito..............................................................................................257
Limites superiores..............................................................................................257
Vários limites.....................................................................................................258
Variância de tipos...................................................................................................259
Invariância........................................................................................................259
Covariância.......................................................................................................261
Tipo de retorno covariante.................................................................................262
Contravariância.................................................................................................263
Visão geral sobre variância.................................................................................266
Tipo Nothing..........................................................................................................267
Projeção de tipos.....................................................................................................268
Apagamento de tipo................................................................................................270
Reificação de tipos.................................................................................................. 274
Limites de tipos recursivos......................................................................................276
Tipos de dados algébricos........................................................................................279
Resumo..................................................................................................................284

Capítulo 9 ■ Classes de dados.................................................................................................285

Criação automática de getters e setters.....................................................................287
Método copy...........................................................................................................288
toString automático.................................................................................................293
Métodos hashCode e equals gerados para você........................................................294
Declarações desestruturadas...................................................................................297
Desestruturando tipos.............................................................................................299
Regras para definição de classe de dados..................................................................300
Limitações..............................................................................................................303
Resumo..................................................................................................................303
Sumário 11

Capítulo 10 ■ Coleções...........................................................................................................304
Hierarquia de classes...............................................................................................304
Arrays.....................................................................................................................313
Listas......................................................................................................................323
Mapas....................................................................................................................328
Conjuntos...............................................................................................................331
Visões somente de leitura........................................................................................334
Acesso indexado.....................................................................................................335
Sequências..............................................................................................................336
Resumo..................................................................................................................341

Capítulo 11 ■ Testes em Kotlin...............................................................................................342

Introdução..............................................................................................................342
Selecionando uma spec...........................................................................................343
Matchers................................................................................................................347
Matchers de string.............................................................................................347
Matchers de coleção...........................................................................................347
Matchers de ponto flutuante...............................................................................348
Esperando exceções...........................................................................................348
Combinando matchers.......................................................................................349
Matchers personalizados....................................................................................350
Inspetores...............................................................................................................353
Interceptadores.......................................................................................................355
Interceptador de caso de teste.............................................................................355
Interceptador de spec.........................................................................................356
Config do projeto....................................................................................................357
Testes de propriedade..............................................................................................358
Especificando um gerador..................................................................................359
Testes orientados a tabela........................................................................................360
Testando um código não determinístico.............................................................361
Tags, condições e config..........................................................................................363
Config...............................................................................................................363
Condições.........................................................................................................364
Tags..................................................................................................................365
Recursos............................................................................................................366
Resumo..................................................................................................................366

Capítulo 12 ■ Microsserviços com Kotlin.................................................................................367

Definição................................................................................................................368
Desvantagens..........................................................................................................372
Por que usar microsserviços?...................................................................................373
12 Programando com Kotlin

Lagom.................................................................................................................... 374
Definindo serviços..................................................................................................384
Implementando um serviço Lagom..........................................................................387
Resumo..................................................................................................................392

Capítulo 13 ■ Concorrência....................................................................................................393
Threads..................................................................................................................394
Bloqueio............................................................................................................395
Deadlocks e livelocks..............................................................................................401
O problema do jantar dos filósofos.....................................................................401
Executores..............................................................................................................403
Condições de concorrência..................................................................................... 404
Monitores......................................................................................................... 406
Locks............................................................................................................... 408
Semáforos.......................................................................................................... 410
Coleções concorrentes........................................................................................ 414
Variáveis atômicas.............................................................................................. 416
CountDownLatch.............................................................................................. 417
Barreira cíclica...................................................................................................419
E/S não bloqueante e programação assíncrona....................................................421
Futures..............................................................................................................422
Resumo..................................................................................................................424