Kotlin para iniciantes: classes, funções e strings dinâmicas

Rocketseat

Rocketseat

6 min de leitura
Kotlin
Se você está em busca de Kotlin para iniciantes, pode preparar os motores porque este guia vai te ajudar a decolar! O Kotlin é uma linguagem moderna, concisa e poderosa, criada para tornar o desenvolvimento mais produtivo e acessível. Muito utilizada no desenvolvimento Android (e até em multiplataforma), ela é perfeita para aprender Kotlin do zero e dar seus primeiros passos em programação.
Na Rocketseat, acreditamos que todo iniciante merece uma abordagem didática e motivadora. Por isso, vamos conduzir seu aprendizado de Kotlin usando a analogia de um foguete prestes a decolar. Cada conceito será como uma peça essencial desse foguete – desde a planta (as classes), passando pelo combustível e comandos (as funções), até os painéis de controle com informações dinâmicas (strings com valores interpolados). Pronto para embarcar nessa jornada? Então ajuste o capacete, porque vamos decolar rumo aos fundamentos do Kotlin.

O que são classes em Kotlin? A planta do nosso foguete!

Vamos começar pela base da programação orientada a objetos (POO) em Kotlin: as classes. Em termos simples, uma classe é como a planta ou projeto de um objeto. Ela define as características (propriedades) e comportamentos (funções) que os objetos daquele tipo terão, mas não é um objeto em si – assim como a planta de um foguete não é o foguete real, apenas sua definição.
  • Classe: pense em uma classe como a planta de um foguete ou uma receita de bolo. Ela descreve como algo deve ser (quais atributos terá) e o que poderá fazer, mas por si só é apenas um modelo.
  • Objeto: é o resultado concreto da classe – ou seja, o foguete construído de verdade a partir da planta. Quando você cria um objeto, dizemos que instanciou uma classe, dando vida real àquele modelo.
Em Kotlin, declarar uma classe é simples: usamos a palavra-chave class seguida do nome. O corpo da classe, contendo métodos ou inicializadores, é definido entre chaves {}. Vamos ver um exemplo Kotlin prático de uma classe Foguete com algumas propriedades:
// Definição de uma classe simples em Kotlin class Foguete(val nome: String, val cor: String) // Instanciando (criando) objetos da classe Foguete val foguete1 = Foguete("Apollo 11", "Branco") val foguete2 = Foguete("Falcon 9", "Preto") println(foguete1.nome) // Saída: Apollo 11 println(foguete2.cor) // Saída: Preto
No código acima, definimos a classe Foguete com duas propriedades: nome e cor. Em seguida, criamos dois objetos (foguetes específicos) usando essa classe: um foguete de nome "Apollo 11" e cor branca, e outro "Falcon 9" de cor preta. Cada objeto criado a partir da classe tem seus próprios valores para as propriedades definidas. Ou seja, a classe é o molde, e o objeto é o foguete em si com um nome e uma cor particulares.

Funções em Kotlin: dando poder de fogo aos nossos foguetes!

Agora que já temos a "planta" do nosso foguete, é hora de dar poderes a ele. É aqui que entram as funções. Em Kotlin, funções são blocos de código que executam uma tarefa específica e podem ser reutilizadas sempre que necessário. Elas são como os sistemas e comandos do nosso foguete – por exemplo, ligar os motores ou verificar o nível de combustível são ações representadas por funções.
A sintaxe para criar função em Kotlin é bem direta: usamos a palavra-chave fun, definimos o nome da função, os parâmetros (se houver) entre parênteses e, se a função retornar algo, declaramos o tipo de retorno após os parênteses. Em seguida, abrimos chaves {} para o corpo da função, onde vão as instruções.
Vamos ampliar nossa classe Foguete adicionando duas funções: uma para ligar os motores e outra para verificar o combustível:
class Foguete(val nome: String, val cor: String) { // Função sem retorno (retorna Unit implicitamente) fun ligarMotores() { println("Motores do foguete $nome ligados! Pronto para o lançamento.") } // Função que retorna um valor Boolean fun verificarCombustivel(): Boolean { println("Verificando combustível do foguete $nome...") // Aqui poderíamos ter uma lógica para checar o nível de combustível return true // Por enquanto, vamos supor que sempre há combustível suficiente } } // Criando um foguete e usando suas funções val foguete1 = Foguete("Saturno V", "Branco") foguete1.ligarMotores() // Chama a função ligarMotores() desse objeto val combustivelOk = foguete1.verificarCombustivel() // Chama verificarCombustivel() e obtém true
No exemplo acima, a classe Foguete ganhou comportamentos:
  • A função ligarMotores() simplesmente imprime uma mensagem indicando que os motores daquele foguete foram ligados.
  • A função verificarCombustivel() imprime uma mensagem de verificação e retorna um valor booleano (true ou false) dizendo se há combustível suficiente. (Aqui, retornamos true para simplificar, mas poderíamos ter uma lógica real, como verificar um atributo de nível de combustível.)
Ao chamar uma função (como foguete1.ligarMotores()), nosso objeto executa aquele bloco de código. Perceba como isso ajuda a organizar a lógica: podemos ligar os motores ou verificar o combustível quantas vezes quisermos, sem repetir código, apenas chamando a função correspondente. As funções tornam o código mais modular e fácil de entender, já que cada ação tem um nome descritivo e está encapsulada dentro da classe certa.

String interpolation: mensagens dinâmicas e legíveis!

Temos nosso foguete com dados (propriedades) e ações (funções). Agora, vamos falar de mensagens dinâmicas, ou seja, como exibir informações variáveis de forma fácil e legível. Em Kotlin, contamos com a string interpolation (interpolação de strings) para montar textos que incluem valores de variáveis sem complicação.
Normalmente, em outras linguagens ou mesmo em Kotlin sem usar essa funcionalidade, você poderia concatenar strings com o operador +. Por exemplo:
val nivelCombustivel = 70 println("Nível de combustível: " + nivelCombustivel + "%")
O resultado seria imprimir "Nível de combustível: 70%", mas repare como a sintaxe fica cheia de sinais de adição e não tão fácil de ler. Com string interpolation do Kotlin, podemos deixar isso muito mais claro:
val nivelCombustivel = 70 println("Nível de combustível: ${nivelCombustivel}%")
Notou a diferença? Usamos o símbolo $ dentro da string para referenciar diretamente a variável nivelCombustivel. As chaves {} são usadas ao redor da variável (formando ${nivelCombustivel}) principalmente quando precisamos inserir expressões mais complexas (como ${objeto.propriedade} ou ${2025 - 1969}) ou para evitar ambiguidade, separando o nome da variável de caracteres subsequentes que poderiam ser confundidos como parte dela. No caso de ${nivelCombustivel}%, as chaves garantem que apenas nivelCombustivel seja interpretado como a variável, tornando o código mais claro e seguro. O resultado impresso é o mesmo (70%), porém o código fica muito mais limpo e fácil de escrever. Podemos interpolar tanto variáveis simples quanto expressões inteiras dentro de uma string. Por exemplo:
val nome = "Foguete" println("$nome pronto para decolar em ${2025 - 1969}?") // Isso vai imprimir: Foguete pronto para decolar em 56?
No exemplo acima, $nome foi substituído pelo valor da variável ("Foguete"), e a expressão ${2025 - 1969} foi avaliada dentro da string (o resultado de 2025 - 1969, que é 56). Essa é a magia da string interpolation: inserir valores e cálculos diretamente nas mensagens de forma elegante, sem precisar concatenar manualmente.

Juntando tudo: modelando um aluno da Rocketseat!

Hora de combinar classes, funções e strings dinâmicas em um único exemplo prático. Vamos modelar um caso real simples: a classe de um aluno em um curso da Rocketseat. Imaginemos uma classe AlunoRocketseat que tenha algumas propriedades e funções:
  • Propriedades: nome (nome do aluno), trilhaAtual (a trilha ou curso que ele está fazendo, por exemplo Android Kotlin), e modulosConcluidos (quantos módulos já foram concluídos).
  • Funções: progredirModulo() (para simular a conclusão de um novo módulo, incrementando modulosConcluidos) e mostrarProgresso() (para exibir uma mensagem amigável com os dados atuais do aluno).
Vamos ver como ficaria essa classe em Kotlin:
class AlunoRocketseat(val nome: String, var trilhaAtual: String, var modulosConcluidos: Int) { fun progredirModulo() { modulosConcluidos++ // incrementa a quantidade de módulos concluídos println("Parabéns, $nome! Você concluiu mais um módulo na trilha $trilhaAtual.") } fun mostrarProgresso() { println("O aluno $nome está na trilha $trilhaAtual e já concluiu $modulosConcluidos módulo(s).") } } // Utilizando a classe AlunoRocketseat val aluno = AlunoRocketseat("Mayk", "Android Kotlin", 0) aluno.mostrarProgresso() // O aluno Mayk está na trilha Android Kotlin e já concluiu 0 módulo(s). aluno.progredirModulo() // Parabéns, Mayk! Você concluiu mais um módulo na trilha Android Kotlin. aluno.mostrarProgresso() // O aluno Mayk está na trilha Android Kotlin e já concluiu 1 módulo(s).
No código acima, definimos a classe AlunoRocketseat com as propriedades e funções descritas. Usamos string interpolation nas mensagens para inserir o nome do aluno, a trilha e a quantidade de módulos diretamente no texto, tornando a saída mais informativa e personalizada. Ao instanciar AlunoRocketseat("Mayk", "Android Kotlin", 0), criamos um aluno chamado Mayk que está iniciando na trilha Android Kotlin com 0 módulos concluídos. Em seguida:
  • aluno.mostrarProgresso() exibe o status inicial do aluno (nome, trilha e 0 módulos).
  • aluno.progredirModulo() simula a conclusão de um módulo, incrementando o contador e mostrando uma mensagem de parabéns ao aluno.
  • Ao chamar aluno.mostrarProgresso() novamente, vemos a informação atualizada, agora com 1 módulo concluído.
Com esse exemplo, fica claro como classes (estrutura de dados), funções (comportamentos) e string interpolation (exibição dinâmica de informação) trabalham juntos em Kotlin para criar programas organizados e eficientes. É assim que construímos desde pequenos projetos até aplicações Android completas: começando pelos fundamentos e juntando as peças!

Conclusão: sua jornada em Kotlin está só começando!

Parabéns por chegar até aqui! Hoje você decolou pelos fundamentos do Kotlin, aprendendo sobre classes, funções e string interpolation de forma prática e descomplicada. Essas são peças iniciais de uma base sólida em Kotlin – com elas, você já pode começar a criar seus próprios projetos simples e explorar mais da linguagem.
Recapitulando rapidamente os pontos-chave:
  • Classes: são os modelos/planos (blueprints) que definem atributos e comportamentos. Objetos são instâncias concretas dessas classes.
  • Funções: são ações ou blocos reutilizáveis de lógica que dão vida e funcionalidades aos objetos (e ao programa em geral).
  • String interpolation: é a maneira fácil e legível de montar strings dinâmicas exibindo variáveis e resultados de expressões dentro do texto.
Agora é hora de praticar! Que tal criar suas próprias classes e funções, ou modificar os exemplos acima, para fixar o conhecimento? A programação é melhor aprendida fazendo, então não tenha medo de experimentar.
Se você quiser ir além dos conceitos básicos e se aprofundar na criação de apps Android profissionais com Kotlin, a Rocketseat tem uma formação sob medida para você.
👉
Conheça a Formação Android com Kotlin da Rocketseat! – uma formação Kotlin Android completa, onde você irá do básico ao avançado com o suporte de uma comunidade incrível.
Continue programando, continue evoluindo e conte com a Rocketseat para ser sua parceira nessa jornada.

FAQs

  • O que são classes em Kotlin?
    • R: São moldes que definem as características e comportamentos dos objetos em programação orientada a objetos.
  • Como criar uma função em Kotlin?
    • R: Use a palavra-chave fun, seguida do nome da função, parâmetros (opcionais) e o corpo da função com as instruções.
  • O que é string interpolation em Kotlin?
    • R: É a técnica que permite inserir variáveis e expressões diretamente em uma string usando ${} para tornar o código mais limpo e dinâmico.
Artigos_

Explore conteúdos relacionados

Descubra mais artigos que complementam seu aprendizado e expandem seu conhecimento.

Aprenda programação do zero e DE GRAÇA

No Discover você vai descomplicar a programação, aprender a criar seu primeiro site com a mão na massa e iniciar sua transição de carreira.

COMECE A ESTUDAR AGORA