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:
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:
- a documentação oficial de Kotlin: o site https://kotlinlang.org/docs (guia da linguagem, tutoriais, páginas “What’s New” de cada versão) e a documentação da biblioteca padrão: https://kotlinlang.org/api/core/kotlin-stdlib/;
- o guia das corrotinas: https://kotlinlang.org/docs/coroutines-guide.html;
- as propostas de evolução da linguagem (KEEP): https://github.com/Kotlin/KEEP;
- a documentação de Java sobre a API e o SE 25, para as classes do JDK: https://docs.oracle.com/en/java/javase/25/;
- a documentação do Gradle (https://docs.gradle.org) e a documentação de cada biblioteca: JUnit (https://docs.junit.org), Spring (https://spring.io/projects), Hibernate (https://hibernate.org/orm/documentation/), Jackson (https://github.com/FasterXML/jackson);
- dois livros de referência: “Kotlin in Action”, de Sebastian Aigner, Roman Elizarov, Svetlana Isakova e Dmitry Jemerov (Manning, 2ª edição), e “Effective Kotlin”, de Marcin Moskała; para threads, “Java Concurrency in Practice”, de Brian Goetz et al. (Addison-Wesley), continua sendo uma excelente leitura.