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
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.
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.
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.
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
Comece pequeno e evolua: não tente criar algo complexo de cara. Comece com o minimo viável e va adicionando funcionalidades.
Use Git desde o primeiro projeto: aprenda a versionar seu código. Isso também constroi seu portfolio no GitHub.
Escreva testes: mesmo para projetos simples, tente escrever pelo menos alguns testes. Isso desenvolve uma habilidade essencial.
Refatore sem medo: depois que o projeto funciona, volte e melhore o código. Compare a versão inicial com a refatorada.
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