Arquiteto Android — Lição 1: Introdução à Linguagem Kotlin

Kotlin para Android: Quem quer desenvolver aplicativos Android com qualidade precisa dominar mais do que telas e botões. Antes de discutir Clean Architecture, MVVM, modularização, testes e desempenho, precisamos conhecer profundamente a linguagem com a qual escreveremos boa parte desses aplicativos: Kotlin.

Nesta primeira lição da formação Arquiteto Android, vamos entender a origem do Kotlin, como ele funciona, por que foi adotado no ecossistema Android e quais características o tornam interessante para projetos pequenos e grandes.

Também faremos nosso primeiro experimento com a linguagem. A ideia é conectar a teoria à prática, sem confundir conceitos de Kotlin/JVM com a execução de um aplicativo em um dispositivo Android.

Sobre o material de origem: o conteúdo central desta lição foi elaborado a partir da transcrição fornecida da aula “Kotlin Essencial para Android” (aproximadamente 4 minutos e 26 segundos). A aula apresenta a história e as características da linguagem; não demonstra ainda a instalação nem a execução do Olá Mundo. Os exemplos, exercícios e observações sobre o Android moderno abaixo são ampliações didáticas, com correções históricas e técnicas apoiadas nas referências oficiais ao final.

Table of Contents

Kotlin para Android: 1. O que vamos dominar hoje

Ao terminar a lição, você deverá ser capaz de:

  • explicar o que é Kotlin e quem o criou;
  • identificar a ligação entre JetBrains, IntelliJ IDEA e Android Studio;
  • distinguir o anúncio da linguagem, em 2011, do lançamento estável, em 2016;
  • explicar o que é bytecode e como Kotlin/JVM se relaciona com Java;
  • entender por que, no Android, também precisamos conhecer DEX e ART;
  • reconhecer a concisão, a segurança de nulos e a interoperabilidade como características essenciais do Kotlin;
  • comparar um pequeno programa Java com um programa Kotlin;
  • usar fun main(), println(), val e var em exemplos iniciais;
  • executar um Olá Mundo no navegador ou em um projeto Kotlin/JVM;
  • perceber como decisões simples de linguagem influenciam a qualidade arquitetural de um aplicativo.

2. O que é Kotlin?

Kotlin é uma linguagem de programação moderna, de tipagem estática, que suporta programação orientada a objetos e programação funcional.

Ela procura combinar código legível, expressivo e seguro com a possibilidade de aproveitar sistemas, bibliotecas e ferramentas já existentes.

Em um projeto Android, por exemplo, podemos usar Kotlin para escrever:

  • regras de negócio;
  • classes e objetos;
  • componentes de interface;
  • integração com APIs;
  • persistência de dados;
  • testes automatizados;
  • código organizado em diferentes módulos.

Contudo, Kotlin não é exclusiva do Android. Há projetos Kotlin para servidores, aplicações web e diferentes plataformas.

Isso é importante para quem pretende chegar ao nível de arquiteto: devemos enxergar Kotlin como uma linguagem, e Android como uma plataforma que pode utilizá-la.

3. Quem criou Kotlin?

A linguagem foi criada pela JetBrains, empresa responsável pelo IntelliJ IDEA, um ambiente de desenvolvimento integrado amplamente utilizado no ecossistema Java.

O Android Studio foi construído a partir da plataforma IntelliJ, motivo pelo qual a relação entre essas ferramentas aparece logo na aula original.

Veja a relação:

JetBrains
   |
   +--> IntelliJ IDEA
   |       |
   |       +--> Base tecnológica do Android Studio
   |
   +--> Linguagem Kotlin
           |
           +--> Desenvolvimento Android
           +--> Backend
           +--> Outros alvos e plataformas

A ligação entre essas tecnologias facilita o trabalho do desenvolvedor, mas não significa que o Android Studio seja simplesmente o IntelliJ IDEA com outro nome: ele incorpora ferramentas específicas do Android.

4. A história do Kotlin: 2011 não é o mesmo que 2016

A transcrição da aula menciona 2011 como o lançamento do Kotlin. Para compreender corretamente a história, precisamos diferenciar apresentação pública de primeira versão estável.

AnoMarco
2010Início do desenvolvimento da linguagem na JetBrains.
2011Apresentação pública do Project Kotlin.
2012Abertura do código-fonte do projeto.
2016Lançamento do Kotlin 1.0, primeira versão oficialmente estável.
2017Google anuncia suporte oficial ao Kotlin para desenvolvimento Android.
2019Google passa a recomendar uma abordagem Kotlin-first para o desenvolvimento Android.

Portanto, a afirmação mais precisa é:

Kotlin foi apresentado publicamente em 2011 e chegou à primeira versão estável em 2016.

A aula também descreve Kotlin como uma linguagem de pouco mais de seis anos. Essa observação refletia a época da gravação, não a situação atual. Uma tecnologia precisa ser estudada considerando a data da fonte.

Lição de arquitetura: decisões sobre plataformas e linguagens não devem se basear apenas em afirmações históricas retiradas do contexto. Devemos verificar as versões, o suporte e o estado atual das ferramentas.

5. Quais linguagens influenciaram Kotlin?

A aula destaca quatro referências:


  • Java;

  • Scala;

  • Groovy (o nome aparece como “Groove” na transcrição);

  • C#.

A proposta foi aprender com soluções desenvolvidas anteriormente e construir uma linguagem que reduzisse problemas comuns de produtividade e segurança.

Isso não significa que Kotlin seja uma cópia dessas linguagens. Ela combina ideias conhecidas e escolhas próprias, como um sistema de tipos que distingue referências anuláveis das não anuláveis.

Quem já programa em Java reconhecerá vários conceitos. No entanto, aprender Kotlin corretamente exige mais do que substituir palavras-chave: devemos aprender a escrever Kotlin idiomático.

6. Como Kotlin funciona?

No caso do Kotlin/JVM, o código-fonte é compilado para bytecode compatível com a Java Virtual Machine (JVM).

Um fluxo simplificado para uma aplicação de console é:

Arquivo Main.kt
      |
      v
Compilador Kotlin/JVM
      |
      v
Bytecode .class
      |
      v
JVM + bibliotecas necessárias
      |
      v
Programa em execução

Bytecode é uma representação intermediária gerada pelo compilador. Ele não é o texto Kotlin original, nem é necessariamente código de máquina executado diretamente pelo processador.

A interoperabilidade com Java se beneficia dessa infraestrutura comum. Porém, precisamos entender uma diferença importante no caso do Android.

7. JVM, DEX e ART: o que muda no Android?

Na transcrição, a execução do Kotlin é explicada pelo bytecode na JVM. Essa explicação é útil para Kotlin/JVM, mas não descreve toda a cadeia de execução de um aplicativo Android.

Em termos simplificados:

Código Kotlin (.kt) + código Java (.java)
                   |
                   v
       Compilação para bytecode
                   |
                   v
     Ferramentas de build Android
       (como D8 e, conforme o build, R8)
                   |
                   v
            Código DEX
                   |
                   v
     Aplicativo instalado no Android
                   |
                   v
       Android Runtime (ART)

O DEX é o formato de bytecode utilizado no Android. O ART é o ambiente de execução do Android.

Assim, não devemos imaginar que o celular simplesmente executa o arquivo Kotlin dentro da mesma JVM de um programa de desktop.

Outro cuidado: um computador utilizado para criar projetos Android precisa de um ambiente de desenvolvimento apropriado, incluindo IDE, JDK e ferramentas Android. Ter apenas Java instalado não equivale a ter todo o ambiente Android preparado.

Resumo: Kotlin/JVM e Kotlin no Android compartilham conceitos e ferramentas, mas a cadeia de build e o ambiente de execução Android têm particularidades.

8. Kotlin é somente orientada a objetos?

Não. Kotlin suporta tanto orientação a objetos quanto estilo funcional.

Na orientação a objetos, trabalhamos com classes que representam entidades e comportamentos:

class Usuario(val nome: String) {
    fun apresentar(): String {
        return "Olá, $nome!"
    }
}

Em outro caso, podemos escrever funções independentes de classes:

fun dobro(numero: Int): Int {
    return numero * 2
}

As duas abordagens podem coexistir.

Isso será valioso em nossa formação: algumas funcionalidades pedem objetos com responsabilidades bem definidas, enquanto outras ficam mais simples como funções puras, fáceis de testar.

9. Primeira característica: concisão

A aula aponta a concisão como um dos principais diferenciais do Kotlin.

Em programação, concisão significa expressar uma ideia com menos código desnecessário, sem perder clareza.

Compare um Olá Mundo em Java:

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
    }
}

Agora veja uma versão em Kotlin:

fun main() {
    println("Olá, mundo!")
}

Em Kotlin, não precisamos declarar uma classe apenas para criar esse ponto de entrada de uma aplicação de console.

Entendendo o código:


  • fun declara uma função;

  • main é a função de entrada deste programa de console;

  • println() escreve uma linha na saída;
  • as chaves delimitam o corpo da função.

A diferença é visível. Entretanto, menos linhas não garantem automaticamente um código melhor. O objetivo é manter o programa compreensível, testável e fácil de modificar.

Atenção: a função main() demonstra a linguagem em uma aplicação de console. Em um aplicativo Android, a entrada e o ciclo de vida são coordenados pelo sistema Android, com componentes como atividades e outros elementos do aplicativo.

10. Segunda característica: segurança no tratamento de nulos

Outra característica mencionada na aula é a proteção contra erros associados a referências nulas, como NullPointerException.

Precisamos fazer uma correção importante: Kotlin permite valores nulos, mas obriga o programador a indicar explicitamente quando um tipo aceita null.

Compare:

val nome: String = "Ana"

Aqui, nome é declarado como uma referência não anulável.

Já este exemplo permite nulo:

val apelido: String? = null

O símbolo ? indica que a referência pode não conter um valor.

Se tentarmos acessar diretamente uma propriedade anulável:

val apelido: String? = null

// Não compila:
// println(apelido.length)

o compilador exige um tratamento seguro.

Acesso seguro com ?.

val apelido: String? = null

println(apelido?.length)

Resultado:

null

Quando o valor é nulo, o operador ?. evita o acesso à propriedade.

Valor alternativo com ?:

val apelido: String? = null

val exibicao = apelido ?: "Visitante"
println(exibicao)

Resultado:

Visitante

Esse recurso é conhecido como operador Elvis.

Então NullPointerException nunca acontece?

Pode acontecer, sim. Kotlin reduz diversas situações perigosas, mas não elimina todos os riscos.

Por exemplo, o operador !! força uma afirmação de não nulidade e pode provocar uma exceção:

val apelido: String? = null

// Não execute sem entender o risco:
// println(apelido!!.length)

Também existem situações delicadas na integração com bibliotecas Java e na inicialização de objetos.

Para projetos profissionais, nossa regra inicial será: prefira tratar a ausência de valor explicitamente e evite !! como solução rotineira.

11. Terceira característica: interoperabilidade com Java

Interoperabilidade significa que código Kotlin pode trabalhar junto de código Java, e vice-versa, no ecossistema JVM e em projetos Android compatíveis.

Isso permite uma migração gradual. Uma empresa não precisa reescrever todo o aplicativo de uma vez.

Imagine que um sistema antigo já possua esta classe Java:

public class SaudacaoJava {
    public String mensagem(String nome) {
        return "Olá, " + nome + "!";
    }
}

Um arquivo Kotlin no mesmo projeto, devidamente configurado, pode utilizá-la:

fun main() {
    val servico = SaudacaoJava()
    println(servico.mensagem("Ana"))
}

Resultado:

Olá, Ana!

Também é possível chamar código Kotlin a partir de Java, respeitando detalhes da forma como funções e propriedades são expostas no bytecode.

Por que isso importa para arquitetura? Porque uma equipe pode modernizar módulos isolados, criar testes para as novas partes e manter integrações antigas em funcionamento.

Limitação: a interoperabilidade não torna qualquer biblioteca Java automaticamente adequada a todos os alvos de Kotlin. Uma biblioteca para JVM ou Android não se transforma, por isso, em biblioteca disponível em Kotlin/JS ou Kotlin/Native.

12. Kotlin em diferentes tipos de aplicação

A transcrição observa que Kotlin não se limita a aplicativos móveis. Hoje, podemos organizar os principais contextos assim:

ContextoUtilização
AndroidAplicativos para celulares, tablets e outros dispositivos Android.
Kotlin/JVMServiços, aplicações de console, bibliotecas e backend.
Kotlin/JSProjetos que precisam gerar código para JavaScript.
Kotlin/NativeCompilação nativa para determinados alvos.
Kotlin MultiplatformCompartilhamento planejado de código entre plataformas.

A palavra importante é planejado. Um projeto multiplataforma precisa definir quais módulos, dependências e APIs são compatíveis com cada alvo.

Na formação Arquiteto Android, começaremos pelo Kotlin e pelo Android nativo antes de avaliar arquiteturas multiplataforma.

13. Primeiro passo prático: execute um Olá Mundo

Este laboratório é um complemento à aula transcrita. A transcrição anuncia a intenção de chegar à configuração e ao primeiro programa, mas termina antes de demonstrá-los.

Opção A — Testar no navegador

Abra o Kotlin Playground e substitua o conteúdo do editor por:

fun main() {
    println("Olá, mundo!")
    println("Estou começando minha formação Arquiteto Android.")
}

Execute o código e confira a saída:

Olá, mundo!
Estou começando minha formação Arquiteto Android.

Essa opção é suficiente para praticar sintaxe Kotlin, mas não cria um APK ou um aplicativo Android.

Opção B — Criar um projeto Kotlin/JVM no IntelliJ IDEA

  1. Instale e abra o IntelliJ IDEA.
  2. Acesse New Project e escolha um projeto Kotlin.
  3. Utilize um JDK adequado à configuração sugerida pela IDE.
  4. Selecione um sistema de build, como Gradle, quando a configuração solicitar.
  5. Crie ou abra um arquivo Main.kt.
  6. Insira o mesmo código com fun main().
  7. Execute pelo botão de execução da IDE.

Menus e modelos de projeto podem variar entre versões. Consulte o tutorial oficial de Kotlin/JVM, disponível nas referências.

Não comece criando uma Activity Android apenas para testar println(). Neste primeiro contato, queremos isolar a linguagem. Na etapa seguinte, entraremos no ambiente de aplicativos Android.

14. Entenda val e var desde o começo

Para praticar Kotlin com mais autonomia, vamos introduzir dois elementos que não foram detalhados na legenda.

val declara uma referência que não pode ser reatribuída:

val linguagem = "Kotlin"
println(linguagem)

var declara uma variável que pode receber outro valor:

var quantidadeDeAulas = 1
quantidadeDeAulas = 2

println(quantidadeDeAulas)

Uma variável também pode ter seu tipo escrito explicitamente:

val nome: String = "Ana"
var idade: Int = 25
val ativo: Boolean = true

Quando o tipo pode ser inferido com segurança, a declaração pode ser mais curta.

Regra inicial de projeto

Prefira val quando não precisar reatribuir a referência. Use var quando houver uma necessidade real de alteração.

Entretanto, atenção: val não transforma um objeto mutável em imutável.

val tecnologias = mutableListOf("Kotlin")

tecnologias.add("Java")

println(tecnologias)

Embora não seja possível reatribuir tecnologias a outra lista, seu conteúdo pode mudar.

A diferença entre referência não reatribuível e estado imutável será fundamental quando estudarmos gerenciamento de estado no Android.

15. Um pequeno programa para consolidar os conceitos

Agora reuniremos concisão, funções, tipos, valores anuláveis e interpolação de strings.

fun apresentarDesenvolvedor(
    nome: String,
    tecnologiaFavorita: String?
): String {
    val tecnologia = tecnologiaFavorita ?: "Kotlin"

    return "Olá, $nome! Vamos estudar $tecnologia."
}

fun main() {
    println(apresentarDesenvolvedor("Ana", "Kotlin"))
    println(apresentarDesenvolvedor("Carlos", null))
}

Saída esperada:

Olá, Ana! Vamos estudar Kotlin.
Olá, Carlos! Vamos estudar Kotlin.

Observe com atenção:

  1. A função apresentarDesenvolvedor recebe dois parâmetros.

  2. nome: String não aceita null em chamadas Kotlin comuns.

  3. tecnologiaFavorita: String? pode receber null.

  4. ?: define um valor alternativo.

  5. String após os parênteses indica o tipo de retorno da função.

  6. $nome e $tecnologia inserem valores dentro do texto.

Esse código não cria uma interface Android. Ele demonstra lógica que, no futuro, poderemos testar e reutilizar em componentes de um aplicativo.

16. O olhar do Arquiteto Android

É possível aprender a sintaxe de Kotlin e ainda escrever aplicativos difíceis de manter.

Por isso, começaremos a formar hábitos de arquitetura desde a primeira lição.

DecisãoBenefício esperado
Preferir nomes clarosFacilita manutenção e revisões.
Usar val quando possívelReduz reatribuições acidentais.
Tratar valores anuláveisTorna a ausência de dados explícita.
Isolar regras em funções pequenasFacilita testes e reutilização.
Respeitar limites entre Java e KotlinViabiliza modernização gradual.
Distinguir Kotlin/JVM e AndroidEvita erros sobre build e execução.

Uma boa arquitetura não surge apenas ao escolher um padrão sofisticado. Ela começa com decisões cotidianas sobre tipos, dependências, responsabilidades e testes.

17. Erros comuns de iniciantes

Erro 1 — Achar que Kotlin nasceu em 2016

A linguagem foi apresentada em 2011; 2016 é o marco da primeira versão estável.

Erro 2 — Dizer que Kotlin proíbe qualquer variável nula

Kotlin distingue tipos anuláveis e não anuláveis. É possível declarar, por exemplo, String?.

Erro 3 — Acreditar que !! resolve o problema de nulos

Esse operador apenas afirma que o valor não é nulo. Se estiver errado, a execução poderá falhar.

Erro 4 — Confundir uma aplicação Kotlin de console com um app Android

A função main() é apropriada para nosso experimento inicial. Um aplicativo Android tem uma estrutura própria e um ciclo de vida controlado pela plataforma.

Erro 5 — Reescrever todo o Java de uma vez

A interoperabilidade permite migrar por partes. Em sistemas existentes, uma estratégia gradual costuma reduzir riscos operacionais.

Erro 6 — Achar que menos código sempre significa melhor arquitetura

A concisão é útil quando preserva a intenção. Código excessivamente comprimido também pode prejudicar o entendimento.

18. Exercícios práticos

Tente resolver antes de consultar respostas prontas.

Exercício 1 — Seu primeiro Olá Mundo

Crie um programa Kotlin que exiba:

Olá, Android!
Minha jornada como Arquiteto Android começou.

Exercício 2 — Trabalhando com val e var

Crie uma variável nomeCurso com o valor "Arquiteto Android" e um contador aulasConcluidas que comece em 0. Depois, atualize o contador para 1 e imprima os dois valores.

Escolha val ou var de acordo com o comportamento desejado.

Exercício 3 — Tratando um nome opcional

Crie uma função que receba String?. Quando o nome for null, ela deve devolver "Visitante". Caso contrário, deve devolver o próprio nome.

Exercício 4 — Comparação Java e Kotlin

Escreva um programa que mostra uma mensagem em Java e depois reproduza o comportamento em Kotlin.

Responda: qual versão necessita de mais estrutura para esse exemplo específico? Isso prova que toda solução Kotlin será melhor?

Exercício 5 — Explique a cadeia Android

Sem olhar o conteúdo acima, desenhe:

Kotlin / Java --> bytecode --> DEX --> ART

Depois, explique em uma frase a função de DEX e de ART.

Desafio extra — Regra de negócio reutilizável

Crie uma função Kotlin chamada mensagemBoasVindas, recebendo um nome anulável e devolvendo uma saudação.

Exemplos esperados:

mensagemBoasVindas("Ana") -> "Bem-vinda, Ana!"
mensagemBoasVindas(null)  -> "Bem-vinda, visitante!"

Se desejar, use uma saudação neutra, adequada a qualquer nome. Não precisa criar interface gráfica.

19. Questões de revisão

Questão 1. Qual organização criou Kotlin?

A) Oracle
B) JetBrains
C) Microsoft
D) Mozilla

Questão 2. Qual acontecimento está relacionado ao ano de 2011?

A) Primeira versão estável Kotlin 1.0
B) Kotlin substituiu Java no Android
C) Apresentação pública do Project Kotlin
D) Lançamento do Android Studio

Questão 3. Em Kotlin, o tipo String? significa:

A) Uma String obrigatoriamente vazia
B) Uma String que pode ser nula
C) Um tipo que nunca aceita null
D) Uma String automaticamente convertida para número

Questão 4. O operador ?. é usado principalmente para:

A) Realizar uma chamada segura em referência anulável
B) Concatenar arquivos
C) Declarar um pacote
D) Compilar Android para DEX

Questão 5. Qual alternativa descreve melhor a relação Kotlin e Java em projetos JVM e Android?

A) É proibido misturar as linguagens
B) Projetos Kotlin sempre precisam ser reescritos em Java
C) As linguagens podem interagir, permitindo migração gradual
D) Kotlin executa qualquer biblioteca Java em qualquer plataforma nativa

Questão 6. No Android, o bytecode dos projetos é convertido em qual formato de execução da plataforma?

A) HTML
B) SQL
C) DEX
D) CSS

Questão 7. Sobre val, a afirmação correta é:

A) É impossível modificar qualquer objeto referenciado por val
B) A referência não pode ser reatribuída, mas o objeto pode ser mutável
C) Só aceita valores numéricos
D) É idêntico a var

Questão 8. Qual é a interpretação mais adequada da concisão em Kotlin?

A) Apagar testes para escrever menos código
B) Concentrar todas as regras em uma função
C) Escrever menos código desnecessário sem prejudicar a clareza
D) Evitar nomes descritivos para reduzir linhas

Gabarito comentado

QuestãoRespostaExplicação
1BKotlin foi criado pela JetBrains.
2CO projeto foi apresentado em 2011; Kotlin 1.0 chegou em 2016.
3BO ? marca a referência como anulável.
4AO operador permite um acesso seguro, retornando nulo quando necessário.
5CA interoperabilidade viabiliza a coexistência e a migração gradual.
6CO Android usa bytecode DEX, executado pelo ART.
7B val impede reatribuir a referência; não garante imutabilidade do objeto.
8CConcilie concisão com legibilidade e manutenção.

20. Checklist de conclusão

Marque os itens quando conseguir realizá-los sem consultar a explicação:

  • [ ] Sei quem criou Kotlin e sua relação com IntelliJ IDEA.
  • [ ] Diferencio o anúncio de 2011 da versão estável de 2016.
  • [ ] Sei explicar as influências citadas na aula original.
  • [ ] Consigo distinguir Kotlin/JVM de Kotlin executado no Android.
  • [ ] Entendo a função de bytecode, DEX e ART em alto nível.
  • [ ] Consigo explicar por que Kotlin é considerada concisa.
  • [ ] Sei usar val e var.
  • [ ] Sei declarar um valor String?.
  • [ ] Sei utilizar os operadores ?. e ?: em exemplos básicos.
  • [ ] Entendo o que significa interoperabilidade com Java.
  • [ ] Executei o primeiro programa fun main().
  • [ ] Resolvi os exercícios e conferi as oito questões.

21. Nossa trilha para chegar a Arquiteto Android

Esta lição inicia uma sequência progressiva. O planejamento poderá ser refinado de acordo com os projetos práticos e as versões do ecossistema Android.

EtapaTemaCompetência central
1Kotlin essencialSintaxe, tipos, funções e null safety.
2Kotlin intermediárioClasses, coleções, lambdas e extensões.
3Android StudioProjetos, Gradle, emulador e depuração.
4Fundamentos AndroidComponentes, ciclo de vida e navegação.
5Jetpack ComposeInterfaces declarativas e estado.
6Coroutines e FlowAssincronismo e fluxos de dados.
7Room, DataStore e APIsPersistência e comunicação externa.
8MVVM e Clean ArchitectureCamadas, responsabilidades e dependências.
9Hilt e modularizaçãoEvolução de aplicações maiores.
10Testes e observabilidadeQualidade, diagnósticos e manutenção.
11Segurança e desempenhoAplicações confiáveis e eficientes.
12CI/CD e decisões arquiteturaisEntrega, governança e evolução do produto.

O objetivo final não é apenas saber programar em Kotlin: é justificar escolhas arquiteturais, comparar alternativas e construir aplicativos Android sustentáveis.

22. O que vem na Lição 2?

Na Lição 2 — Variáveis, Tipos de Dados e Operadores em Kotlin, aprofundaremos:


  • val e var;
  • inferência e declaração explícita de tipos;

  • Int, Long, Double, Boolean, Char e String;
  • interpolação de strings;
  • operadores aritméticos e de comparação;
  • conversões de valores;
  • exercícios progressivos;
  • erros comuns de compilação e lógica.

Meta antes de avançar: execute o Olá Mundo, explique a diferença entre String e String? e seja capaz de contar, com suas palavras, por que Kotlin e Java podem coexistir no mesmo projeto.


Fontes e materiais de apoio

Material-base da aula


  • Transcrição fornecida pelo estudante: “Kotlin Essencial para Android”, capítulo introdutório, duração aproximada de 4min26s. Aborda origem, inspirações, bytecode/JVM, concisão, null safety e interoperabilidade.

Documentação oficial e complementos atualizados

Nota editorial: esta publicação preserva os temas efetivamente presentes na transcrição, distingue práticas adicionais de conteúdo originalmente ministrado e atualiza explicações históricas e técnicas conforme a documentação oficial. Interfaces de ferramentas e versões de SDKs podem mudar; consulte as instruções vigentes ao executar os laboratórios.

Metadescrição: Aprenda Kotlin para Android do zero: origem, JVM e ART, Java, null safety, val e var, primeiro Olá Mundo, exemplos e exercícios práticos.

Tags: Android, Kotlin, Arquiteto Android, JetBrains, IntelliJ IDEA, Android Studio, Java, JVM, DEX, ART, null safety, interoperabilidade, programação mobile.

Veja também: mais conteúdos sobre Android.

Kotlin for Android Beginners: Build Modern Apps Without Confusing Theory (English Edition)

Kotlin for Android Beginners: Build Modern Apps Without Confusing Theory (English Edition)

⭐ 5.0/5

Kotlin for Android Beginners: Build Modern Apps Without Confusing Theory (English Edition). Produto recomendado para estudos, programação e produtividade.

R$ 15,28
Ver na Amazon Como afiliado, posso receber comissão por compras qualificadas.