Pílula K #04 — Tipos de Dados

Iaí, tudo tranquilo?! Na dose de hoje vamos falar sobre um assunto importante para programação: tipos de dados (em Kotlin… óbvio)!

Você sabe que em programação, dados são informações que precisam ser armazenadas e manipuladas. E os dados podem ser de vários tipos, como números, caracteres, textos, booleans, entre outros.

Para resolver um problema matemático, por exemplo, é necessário escrever uma expressão, como 5.9 + 6. Mas você sabe que a soma desses números produz outro número. E o Kotlin também sabe disso! Ele reconhece que um é um número fracionário (5,9), que ele chama de Double, e o outro é um número inteiro (6), que ele carinhosamente chama de Int. E o resultado é um número fracionário.

Mas o que isso significa para o seu código Kotlin? Significa que você pode usar o tipo Double para armazenar números fracionários e o tipo Int para armazenar números inteiros (basicamente um Ctrl+C/Ctrl+V do parágrafo anterior, pra você entender melhor…). O Kotlin se preocupa em garantir que os tipos de dados sejam usados da maneira correta.

Um tipo de dados em Kotlin é como uma etiqueta que você coloca em um valor para informar ao Kotlin como esse valor será usado. Por exemplo, se você tem um valor que representa a idade de alguém, você pode querer que o Kotlin saiba que esse valor é um número decimal (ou seja, um número que pode ter casas decimais). Ou se você tem um valor que representa o nome de alguém, você pode querer que o Kotlin saiba que esse valor é uma String (ou seja, uma sequência de caracteres).

Pausa… você pode querer que o Kotlin saiba que… essa locução parece tão errada… mas não estou ensinando a fazer redação, então, bora continuar…

Cada tipo de dados em Kotlin tem um conjunto de valores que uma expressão desse tipo pode produzir. Além disso, cada tipo define as operações que podem ser realizadas nos dados, o significado dos dados e como os valores desse tipo podem ser armazenados.

Quando você escreve um código Kotlin, ele usa os tipos de dados para verificar se suas expressões estão corretas. Se você pedir para ele fazer algo que viole as regras do tipo, ele produzirá uma mensagem de erro. Por exemplo, tente adicionar uma String e um número:

fun main() {
    println("Klaus" + 1.86)
}

/* Saída:
    Klaus1.86
*/

Aqui, o Kotlin sabe como adicionar um número a uma String: anexando os dois valores e criando uma String maior para armazenar o resultado.

Mas se você tentar multiplicar uma String e um Double, mudando o operador ‘+’ para um ‘*’, o Kotlin não vai entender o que você quer fazer e vai dar um erro, porque combinar tipos dessa maneira não faz sentido para ele.

Vimos na dose anterior (#03), que em Val e Var, armazenamos vários tipos. O Kotlin descobriu os tipos para nós, com base em como os usamos. Isso é chamado de inferência de tipo (veremos outra importância desse carinha mais adiante). Por exemplo:

val X = 1 // Kotlin irá inferir que X é um Int
var Y = 1.2 // Kotlin irá inferir que Y é um Double

Mas você também pode ser mais detalhado e especificar o tipo: (pessoalmente, prefiro codificar assim, acho que deixa o código mais “claro e legível”)

val X: Int = 1
var Y: Double = 1.2

Aqui estão alguns dos tipos básicos de dados em Kotlin:

• Int: número inteiro, que só pode conter números inteiros.

... 
val inteiro: Int = 27 
println(inteiro)
...

/* Saída:
     27 
*/

• Double: número fracionário, que pode conter números com casas decimais.

... 
val fracionario: Double = 31.59 
println(fracionario) 
...  

/* Saída:
     31.59 
*/

• Boolean: contém apenas os dois valores especiais true e false. (verdadeiro e falso, respectivamente)

... 
val verdadeiroOuFalso: Boolean = true 
println(verdadeiroOuFalso) 
...  

/* Saída:
     true 
*/

• Char: armazena um único caractere. (perceba que usamos aspas simples)

... 
val caractere: Char = 'X' 
println(caractere) 
...  

/* Saída:
     X 
*/

• String: armazena uma sequência de caracteres. (e aqui… aspas duplas)

... 
val palavras: String = "Uma informação aqui." 
println(palavras) 
...  

/* Saída:
     Uma informação aqui. 
*/

• Triple-quoted String: se você tiver muitas linhas e/ou caracteres especiais, coloque-os entre três aspas duplas.

val linhas: String = """Três aspas duplas permitem 
      		    que você tenha muitas linhas 
		    em seu texto"""
println(linhas)

/* Saída:
    ???
*/

Iaí? Como você acha que irá mostrar na tela?

//Dessa forma?
Três aspas duplas permitem 
que você tenha muitas linhas 
em seu texto

//Ou dessa?
Três aspas duplas permitem 
          que você tenha muitas linhas 
          em seu texto

//Comenta aí...

O Kotlin usa a inferência de tipo (olha o biru-biru de novo…) para determinar o significado de tipos mistos. Ao misturar Ints e Doubles durante a adição, por exemplo, o Kotlin decide o tipo para você.

fun main() {
    val n = 1 + 1.2
    println(n)
}

/* Saída:
    2.2
*/

Quando você adiciona um Int a um Double usando a inferência de tipo, o Kotlin determina que o resultado n é um Double e garante que ele siga todas as regras para Doubles.

E aí, gostou de aprender um pouco mais sobre tipos de dados em Kotlin? Com essas informações, você pode escrever um código mais limpo, seguro e eficiente! Na próxima dose, veremos um pouco sobre funções, então… até logo. 😄