Skip to content

1. Introdução

O PDF do documento está AQUI.

O código deste documento está AQUI.

Este documento é um produto da IA Claude, da Anthropic. É a adaptação para Kotlin do curso “Aprendendo a linguagem Java 25 por meio de exemplos” (outubro de 2026), que por sua vez é uma adaptação do curso “Aprendendo a linguagem C# 14 com .NET 10 (outubro de 2026), uma reescrita do curso “Aprendendo a linguagem C#, versão 3.0, com o framework .NET 3.5” escrito por Serge Tahé em maio de 2008. Ele mantém o roteiro, os exemplos e o fio condutor desse curso e os reescreve no Kotlin de hoje:

  • O documento usa Kotlin 2.4 (versão 2.4.20, setembro de 2026), com o JDK 25, a mais recente versão de suporte de longo prazo (LTS) do Java. Kotlin é uma linguagem para a Máquina Virtual Java: ela produz o mesmo código intermediário que Java e usa diretamente todas as suas bibliotecas. Os leitores do curso de Java encontrarão, portanto, as mesmas classes do JDK (arquivos, rede, threads, datas etc.) e os mesmos frameworks (JUnit, Spring, Jackson, Hibernate, Spring Boot), usados a partir de outra linguagem;
  • onde as duas linguagens diferem, este documento faz mais do que simplesmente traduzir. Kotlin oferece soluções próprias para questões que Java trata de outra forma: a segurança contra nulos (null safety) incorporada ao sistema de tipos, as propriedades, as classes de dados, as funções de extensão, a sobrecarga de operadores, os tipos funcionais, os valores padrão de parâmetros e os argumentos nomeados, e a expressão [when]. Em contrapartida, Kotlin não possui exceções verificadas nem membros [static]. Essas diferenças são apresentadas em detalhe, muitas vezes comparando o código Kotlin com o código Java;
  • o capítulo sobre programação assíncrona tem outro caráter: enquanto Java usa as classes [CompletableFuture] e as threads virtuais, Kotlin oferece as corrotinas, junto com as funções [suspend], os construtores [launch] e [async] e a concorrência estruturada. Essa é a resposta de Kotlin ao [async] / [await] de C# do curso original;
  • as bibliotecas são as usadas atualmente na JVM: [JUnit 6] e [kotlin.test] para testes, [Spring Framework 7] para injeção de dependência, [Jackson 3] para JSON, [kotlinx.coroutines] para corrotinas, o driver [MySQL Connector/J] para JDBC, [Hibernate 7] para o mapeamento objeto-relacional e [Spring Boot 4] para serviços web; os projetos são construídos com [Gradle], cujos scripts são eles próprios escritos em Kotlin.

Este documento não é um curso exaustivo. Como os materiais dos quais deriva, destina-se a leitores que já conhecem programação e desejam aprender o básico de Kotlin. Ele se baseia em exemplos: mais de duzentos programas (mais de trezentos arquivos Kotlin), a maioria curtos, com comentários linha a linha.

1.1. Kotlin de 2011 a 2026

Kotlin foi apresentada em julho de 2011 pela empresa JetBrains, fabricante do IDE IntelliJ IDEA, que buscava uma linguagem mais concisa e mais segura que Java para escrever suas próprias ferramentas, mas compatível com ela: um programa Kotlin é compilado em bytecode, executado pela Máquina Virtual Java (a JVM), e pode chamar código Java, assim como ser chamado por ele. O nome vem de uma ilha do Golfo da Finlândia, perto de São Petersburgo, onde trabalhava a equipe que a concebeu.

Marcos principais:

  • 2016: Kotlin 1.0, a primeira versão estável, com o compromisso de compatibilidade que a acompanha;
  • 2017: o Google anunciou o suporte oficial a Kotlin para o desenvolvimento de aplicativos Android; em 2019, o Android passou a ser “Kotlin first”: Kotlin é a linguagem recomendada para novos aplicativos Android;
  • 2018: Kotlin 1.3, que estabilizou as corrotinas, a resposta de Kotlin à programação assíncrona (Capítulo 9);
  • A linguagem é desenvolvida pela JetBrains; a Kotlin Foundation, fundada em 2017 pela JetBrains e pelo Google, supervisiona sua evolução, e cada etapa é submetida a propostas públicas (os “KEEP”, Kotlin Evolution and Enhancement Process);
  • 2024: Kotlin 2.0, com um novo compilador chamado K2, mais rápido e melhor no acompanhamento dos tipos no código (conversões inteligentes de tipo, ou smart casts);
  • Kotlin também tem como alvo outras plataformas além da JVM: JavaScript, WebAssembly e código nativo (Kotlin/Native, iOS). Este documento trata apenas de Kotlin na JVM;
  • desde a versão 2.0, uma nova versão da linguagem (2.1.0, 2.2.0, 2.3.0, 2.4.0…) é lançada aproximadamente a cada seis meses; entre elas, uma versão de ferramentas (2.x.20) traz melhorias às ferramentas e à biblioteca padrão sem alterar a linguagem. Este documento usa a versão 2.4.20, lançada em setembro de 2026. Os novos recursos costumam ser introduzidos primeiro como experimentais; é preciso então ativá-los explicitamente (por uma opção do compilador ou pela anotação [@OptIn]) antes que se tornem estáveis em uma versão posterior.

A tabela a seguir resume os principais recursos novos da linguagem apresentados neste documento e indica o capítulo em que aparecem:

Versão
Ano
Principais novidades
Capítulo
Kotlin 1.0
2016
segurança contra nulos (null safety), propriedades, classes de dados, funções de extensão, lambdas, [when], sobrecarga de operadores
3, 4, 7
Kotlin 1.1
2017
apelidos de tipo [typealias], referências vinculadas [object::function], corrotinas (experimentais)
4, 7
Kotlin 1.3
2018
Corrotinas estáveis, função [main] sem parâmetros
2, 3, 9
Kotlin 1.4
2020
Interfaces funcionais [fun interface], conversões SAM de interfaces Kotlin
7
Kotlin 1.5
2021
Tipos sem sinal ([UInt]…) e classes [value class] estáveis, interfaces seladas
3, 4
Kotlin 1.9
2023
[..<] operador, [entries] propriedade dos enums, [data object]
3, 12
Kotlin 2.0
2024
Compilador K2: conversões inteligentes de tipo mais precisas
4
Kotlin 2.2
2025
Condições de guarda em [when] ([is Int if x > 0 ->]), interpolação com vários [$]
3, 5
Kotlin 2.3
2025
Suporte ao Java 25
2
Kotlin 2.4
2026
Na versão 2.4.20, o launcher [kotlinr] substitui o comando [kotlin].
2

Quanto às bibliotecas e ferramentas, as novidades incluem: a ferramenta de build [Gradle] e seus scripts Kotlin ([build.gradle.kts]), as coleções da biblioteca padrão de Kotlin e suas funções de ordem superior, as sequências, as corrotinas e os fluxos ([Flow]), além dos principais frameworks do ecossistema Java usados a partir de Kotlin: JUnit, Spring, Jackson, Hibernate e Spring Boot.

1.2. Conteúdo do documento

O documento inclui os seguintes capítulos:

  • Capítulo 2: configuração do ambiente de desenvolvimento (JDK 25, IntelliJ IDEA, o compilador [kotlinc], Gradle);
  • Capítulo 3: fundamentos da linguagem (tipos, segurança contra nulos, operadores, [if] e [when], laços, exceções, enumerações, parâmetros de funções);
  • Capítulo 4: classes, propriedades, herança, classes seladas, sobrecarga de operadores, interfaces, genéricos, classes de dados, funções de extensão;
  • Capítulo 5: classes Kotlin de uso corrente: strings, arrays, coleções, sequências, arquivos de texto e binários, JSON com Jackson, expressões regulares;
  • Capítulo 6: arquiteturas em camadas, testes unitários com JUnit 6 e injeção de dependência com Spring;
  • Capítulo 7: tipos funcionais, expressões lambda e eventos;
  • Capítulo 8: threads de execução, sincronização e threads virtuais;
  • Capítulo 9: programação assíncrona com corrotinas;
  • Capítulo 10: acesso a bancos de dados com JDBC;
  • Capítulo 11: Hibernate;
  • Capítulo 12: programação web (TCP/IP, clientes e servidores TCP, HTTP com [HttpClient], SMTP);
  • Capítulo 13: serviços web com Spring Boot;
  • Capítulo 14: indo além;
  • Apêndices: instalação do Laragon e do MySQL, dependências usadas pelos projetos Gradle.

1.3. O fio condutor: o cálculo do imposto

Um único problema é retomado ao longo deste documento: o cálculo do imposto de renda de um contribuinte que tem apenas o salário a declarar. A tabela de alíquotas usada é a original (rendimentos de 2003): ela não está mais em vigor, mas basta para nosso propósito, que é escrever a mesma aplicação de várias maneiras diferentes. Ela é implementada em nove versões:

Versão
Capítulo
Conteúdo
1
3
Um único programa: entrada validada, cálculo, exibição
2
4
Classes e interfaces: [TaxBracket], [ITax], [AbstractTax], [HardwiredTax]
3
5
dados de cálculo lidos de um arquivo de texto ou de um arquivo JSON
4
6
Uma arquitetura em camadas ([dao], [business], [ui]) dentro de um único programa
5
6
Um subprojeto Gradle por camada, testes unitários e integração das camadas por injeção de dependência
6
10
Uma camada [dao] que lê os dados de um banco de dados MySQL com JDBC
7
11
uma camada [dao] escrita com Hibernate
8
12
Um servidor TCP de cálculo do imposto e seu cliente
9
13
um serviço web REST de cálculo do imposto, um cliente de console e um cliente web

A partir da versão 5, as versões seguintes reutilizam as camadas da versão 5 e substituem apenas a camada que muda: esse é todo o interesse da arquitetura em camadas apresentada no Capítulo 6.

1.4. Exemplos

O código deste documento está organizado em uma única pasta chamada [kotlin-oct-2026], com uma subpasta por capítulo. Cada subpasta é um projeto Gradle (ou um build Gradle composto de vários projetos) que pode ser aberto como está no IntelliJ IDEA:

kotlin-oct-2026/
├── 02-installation/       Hello.kt, first Gradle projects
├── 03-basics/             Basics01.kt to Basics31.kt, Tax1.kt
├── 04-classes/            Classes01.kt to Classes26.kt, multi-file programs, TaxV2
├── 05-classes-kotlin/     strings, arrays, collections, sequences, files, JSON, regex, TaxV3
├── 06-architectures/      DemoTests, TaxV4, TaxV5 (layers, tests, dependency injection)
├── 07-lambdas/            Lambdas01.kt to Lambdas13.kt
├── 08-threads/            Threads01.kt to Threads31.kt
├── 09-async/              Async01.kt to Async33.kt (coroutines)
├── 10-jdbc/               SQL scripts, jdbc subproject (Jdbc01 to Jdbc10), TaxV6
├── 11-hibernate/          Hibernate subprojects, TaxV7
├── 12-internet/           Internet01.kt to Internet19.kt, TaxV8
└── 13-web-services/       Spring Boot web services and their clients (WsTax, ClientWsTax: version 9)

Cada programa pequeno é um arquivo Kotlin, armazenado em um pacote que leva o seu nome ([src/main/kotlin/basics04/Basics04.kt], package [basics04]). Você pode executá-lo no IntelliJ IDEA clicando no triângulo verde ao lado de sua função [main], ou pela linha de comando com o Gradle ([gradlew -q run -Pmain=basics04.Basics04Kt], Capítulo 2). Os programas que exigem uma biblioteca externa (Jackson, JUnit, Spring, o driver MySQL, Hibernate, Spring Boot) devem declará-la no arquivo [build.gradle.kts] de seu projeto: o Gradle a baixa do repositório Maven Central durante o primeiro build.

Todos os programas deste documento foram compilados sem erros nem avisos pelo compilador Kotlin 2.4.20, com a opção que trata todos os avisos como erros ([allWarningsAsErrors]), e em seguida executados no JDK 25. Os resultados reproduzidos neste documento são os dessas execuções. Os dos Capítulos 2 a 4 foram obtidos com as configurações de idioma e país da França (fr-FR), como em uma máquina Windows francesa: os números de ponto flutuante formatados são exibidos com vírgula decimal e as datas aparecem em francês; os dos capítulos seguintes foram obtidos com configurações em inglês. Duas observações:

  • as mensagens de erro do compilador Kotlin e do JDK (mensagens de exceção) estão em inglês: elas não têm tradução para o francês;
  • os exemplos foram executados em Linux. Na maior parte, isso não faz diferença: Kotlin na JVM é multiplataforma. As poucas diferenças (caminhos de arquivo com / em vez de \, comandos de terminal, [./gradlew] em vez de [gradlew]) são indicadas onde aparecem.

Os resultados de programas multithread, assíncronos ou de rede, assim como as durações medidas, podem variar de uma execução para outra: os comentários concentram-se no que é reproduzível.

1.5. Fontes

As fontes principais deste documento são: