---
title: "Projetos Kotlin para Iniciantes: Ideias Práticas | Kotlin Brasil"
url: "https://kotlin.dev.br/perguntas/kotlin-projetos-iniciantes/"
markdown_url: "https://kotlin.dev.br/perguntas/kotlin-projetos-iniciantes.MD"
description: "Descubra os melhores projetos para praticar Kotlin como iniciante. Lista com 15 ideias progressivas, do básico ao intermediário, com exemplos."
date: "2025-10-13"
author: "Karina Melo"
---

# Projetos Kotlin para Iniciantes: Ideias Práticas | Kotlin Brasil

Descubra os melhores projetos para praticar Kotlin como iniciante. Lista com 15 ideias progressivas, do básico ao intermediário, com exemplos.


## Projetos Kotlin para iniciantes: ideias práticas

A melhor forma de aprender qualquer linguagem de programação e construindo coisas reais. Nao adianta ficar só lendo tutoriais e assistindo videos -- você precisa **escrever código, errar, debugar e resolver problemas**. Este guia traz uma lista progressiva de projetos para você praticar Kotlin desde o básico até o intermediário.

### Por que projetos são tao importantes?

Projetos pessoais ensinam habilidades que nenhum tutorial consegue cobrir:
- Como planejar e estruturar código do zero
- Como lidar com problemas inesperados
- Como pesquisar solucoes quando você trava
- Como manter a motivacao ao ver resultados concretos
- Como construir um portfolio que impressiona recrutadores

### Nível 1: Projetos de console (terminal)

Comece com projetos simples que rodam no terminal. Eles focam nos fundamentos da linguagem sem a complexidade de frameworks.

**Projeto 1: Calculadora interativa**

```kotlin
fun main() {
    println("=== Calculadora Kotlin ===")
    println("Operações: +, -, *, /")

    print("Primeiro numero: ")
    val num1 = readLine()?.toDoubleOrNull() ?: run {
        println("Numero invalido")
        return
    }

    print("Operação: ")
    val operacao = readLine() ?: return

    print("Segundo numero: ")
    val num2 = readLine()?.toDoubleOrNull() ?: run {
        println("Numero invalido")
        return
    }

    val resultado = when (operacao) {
        "+" -> num1 + num2
        "-" -> num1 - num2
        "*" -> num1 * num2
        "/" -> if (num2 != 0.0) num1 / num2 else {
            println("Erro: divisao por zero")
            return
        }
        else -> {
            println("Operação invalida")
            return
        }
    }

    println("Resultado: $num1 $operacao $num2 = $resultado")
}
```

**Projeto 2: Jogo de adivinhacao**

Crie um jogo onde o programa escolhe um número aleatorio e o jogador tenta adivinhar, recebendo dicas de "maior" ou "menor". Conceitos praticados: loops, condicionais, Random.

**Projeto 3: Gerenciador de contatos**

Um sistema de CRUD simples para gerenciar contatos no terminal. Conceitos praticados: listas mutaveis, data classes, funções, entrada do usuário.

```kotlin
data class Contato(val nome: String, val telefone: String, val email: String)

class GerenciadorContatos {
    private val contatos = mutableListOf<Contato>()

    fun adicionar(contato: Contato) {
        contatos.add(contato)
        println("Contato '${contato.nome}' adicionado com sucesso!")
    }

    fun listar() {
        if (contatos.isEmpty()) {
            println("Nenhum contato cadastrado.")
            return
        }
        contatos.forEachIndexed { indice, contato ->
            println("${indice + 1}. ${contato.nome} | ${contato.telefone} | ${contato.email}")
        }
    }

    fun buscar(termo: String): List<Contato> =
        contatos.filter {
            it.nome.contains(termo, ignoreCase = true) ||
            it.email.contains(termo, ignoreCase = true)
        }

    fun remover(indice: Int): Boolean {
        if (indice in contatos.indices) {
            val removido = contatos.removeAt(indice)
            println("Contato '${removido.nome}' removido.")
            return true
        }
        return false
    }

    fun totalContatos(): Int = contatos.size
}
```

**Projeto 4: Conversor de unidades**

Converta entre diferentes unidades de medida (temperatura, peso, distancia, moedas). Conceitos praticados: funções, when expressions, formatação de números.

**Projeto 5: Quiz interativo**

Um jogo de perguntas e respostas com pontuacao, categorias e feedback imediato. Conceitos praticados: coleções, aleatoriedade, controle de fluxo.

### Nível 2: Projetos com persistencia de dados

Apos dominar o básico, evolua para projetos que salvam e carregam dados.

**Projeto 6: Diario pessoal com arquivos**

Um diario que salva entradas em arquivos de texto, permitindo consultar entradas por data.

```kotlin
import java.io.File
import java.time.LocalDate
import java.time.format.DateTimeFormatter

class DiarioPessoal(private val diretorio: String) {

    init {
        File(diretorio).mkdirs()
    }

    fun novaEntrada(texto: String) {
        val hoje = LocalDate.now()
        val arquivo = File("$diretorio/${hoje}.txt")

        arquivo.appendText("--- ${hoje.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"))} ---\n")
        arquivo.appendText("$texto\n\n")

        println("Entrada salva com sucesso!")
    }

    fun lerEntrada(data: LocalDate): String? {
        val arquivo = File("$diretorio/${data}.txt")
        return if (arquivo.exists()) arquivo.readText() else null
    }

    fun listarDatas(): List<String> =
        File(diretorio).listFiles()
            ?.filter { it.extension == "txt" }
            ?.map { it.nameWithoutExtension }
            ?.sorted()
            ?: emptyList()
}
```

**Projeto 7: Sistema de notas escolares**

Cadastre alunos, disciplinas e notas. Calcule medias, identifique aprovados e reprovados, gere relatorios. Conceitos praticados: mapas, agrupamento, calculos com coleções.

**Projeto 8: Rastreador de habitos**

Registre habitos diarios e visualize estatisticas no terminal (dias seguidos, porcentagem de conclusão, gráficos simples com caracteres ASCII).

### Nível 3: Projetos com APIs e rede

**Projeto 9: Consulta de CEP**

Use a API dos Correios (ViaCEP) para buscar enderecos a partir de um CEP. Conceitos praticados: HTTP clients, JSON parsing, coroutines.

```kotlin
import kotlinx.coroutines.runBlocking
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.request.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.Serializable

@Serializable
data class Endereco(
    val cep: String,
    val logradouro: String,
    val bairro: String,
    val localidade: String,
    val uf: String
)

suspend fun buscarCEP(cep: String): Endereco? {
    val client = HttpClient {
        install(ContentNegotiation) { json() }
    }

    return try {
        client.get("https://viacep.com.br/ws/$cep/json/").body<Endereco>()
    } catch (e: Exception) {
        println("Erro ao buscar CEP: ${e.message}")
        null
    } finally {
        client.close()
    }
}

fun main() = runBlocking {
    print("Digite o CEP: ")
    val cep = readLine()?.replace("-", "") ?: return@runBlocking

    val endereco = buscarCEP(cep)
    if (endereco != null) {
        println("Logradouro: ${endereco.logradouro}")
        println("Bairro: ${endereco.bairro}")
        println("Cidade: ${endereco.localidade} - ${endereco.uf}")
    } else {
        println("CEP nao encontrado.")
    }
}
```

**Projeto 10: Bot do clima**

Consulte APIs de previsao do tempo e exiba informações formatadas no terminal.

### Nível 4: Projetos Android com Jetpack Compose

**Projeto 11: App de lista de compras**

Um aplicativo Android simples onde você adiciona, marca como comprado e remove itens. Conceitos praticados: Composables, state management, listas.

**Projeto 12: Cronometro e timer**

App com funcionalidade de cronometro e timer com alarme. Conceitos praticados: LaunchedEffect, coroutines no Compose, notificacoes.

**Projeto 13: App de anotações**

Um app de notas com persistencia local usando Room. Conceitos praticados: Room Database, ViewModel, navegação entre telas.

### Nível 5: Projetos backend

**Projeto 14: API de encurtador de URL**

Crie uma API que recebe URLs longas e retorna versões encurtadas. Conceitos praticados: Ktor/Spring Boot, banco de dados, APIs REST.

**Projeto 15: Sistema de votacao**

Uma API para criar enquetes e registrar votos, com resultados em tempo real. Conceitos praticados: WebSockets, concorrência, válidação de dados.

### Dicas para maximizar o aprendizado com projetos

1. **Comece pequeno e evolua**: não tente criar algo complexo de cara. Comece com o minimo viável e va adicionando funcionalidades.

2. **Use Git desde o primeiro projeto**: aprenda a versionar seu código. Isso também constroi seu portfolio no GitHub.

3. **Escreva testes**: mesmo para projetos simples, tente escrever pelo menos alguns testes. Isso desenvolve uma habilidade essencial.

4. **Refatore sem medo**: depois que o projeto funciona, volte e melhore o código. Compare a versão inicial com a refatorada.

5. **Documente suas decisoes**: escreva comentarios explicando por que você fez determinadas escolhas. Isso ajuda na revisao futura.

### Pros e contras de diferentes tipos de projetos

**Projetos de terminal:**
- Pro: foco nos fundamentos sem distracao de UI
- Pro: rápidos para implementar
- Contra: menos motivadores visualmente

**Projetos Android:**
- Pro: resultado visual imediato e motivador
- Pro: habilidade diretamente aplicavel no mercado
- Contra: curva de aprendizado maior (precisa aprender Compose)

**Projetos backend:**
- Pro: habilidade muito valorizada no mercado
- Pro: fundamentos transferiveis para qualquer tecnologia
- Contra: resultado menos visivel para mostrar a outros

### Perguntas relacionadas

- [Como praticar Kotlin?](/perguntas/como-praticar-kotlin/)
- [Como aprender Kotlin em 2026?](/perguntas/como-aprender-kotlin/)
- [Quanto tempo leva para aprender Kotlin?](/perguntas/quanto-tempo-aprender-kotlin/)
- [Kotlin e difícil de aprender?](/perguntas/kotlin-e-difícil/)
- [Melhor IDE para Kotlin](/perguntas/melhor-ide-kotlin/)