Tipos Básicos em Kotlin
Tags: kotlin, programação, tipodedados
Published: 2024-06-08 01:23:11

---
title: Tipos Básicos em Kotlin
published: true
description: 
tags: kotlin, programação, tipodedados
# cover_image: https://kotlinlang.org/_next/static/chunks/images/hero-cover-6dd34ed75729683235a4f47d714a604e.png
# Use a ratio of 100:42 for best results.
# published_at: 2024-06-07 23:34 +0000
---

## Introdução 

Recentemente mudei de equipe na empresa onde estou trabalhando atualmente. Nessa equipe trabalhamos com **Android Nativo** com **Java** e **Flutter**. Como eu não tinha muito conhecimento em desenvolvimento nativo, comecei a estudar e comecei a utilizar **Kotlin** para ter acesso ao mundo do desenvolvimento de aplicativos Android. 

Apesar de eu gostar de desenvolvimento backend, volta e meia estou inserido no desenvolvimento de aplicativos, comecei com React Native, e após algumas escolhas próprias decidi mudar para Flutter e fui seguindo.  

Agora com o estudo de Kotlin, pensei e registrar o meu desenvolvimento conforme eu vou estudando. Então hoje vou começar falando sobre tipos de variáveis.  

Apesar de ter desenvolvido bastante em JavaScript, pessoalmente eu prefiro linguagens fortemente tipadas e por esse motivo eu migrei para TypeScript e venho desenvolvendo em NestJS com TypeScript desde então.

Para quem está começando no mundo da programação, variável é um nome exclusivo que a identifica dentro do programa. O valor salvo que pode mudar durante a execução do programa. [Ebac](https://ebaconline.com.br/blog/variaveis-na-programacao-seo#:~:text=Uma%20vari%C3%A1vel%20na%20programa%C3%A7%C3%A3o%20%C3%A9,booleanos%20e%20assim%20por%20diante.)

No Kotlin variáveis são estaticamente tipadas, o que significa que uma vez que você declarou o seu tipo, isso não pode ser mais alterado. E dentre os tipos básicos podemos ter os seguintes:

 * Numbers (Números)
 * Booleans (Booleanos)
 * Characters (Caracteres)
 * Strings (Sequência de Caracteres)

Hoje eu falarei apenas do tipo Number, onde podemos ter valores inteiros e de ponto flutuante.

### Números Inteiros

De acordo com Rafael C. Asth professor de matemática, os números inteiros são os números positivos e negativos, que não apresentam parte decimal e, o zero. [Toda Matéria] (https://www.todamateria.com.br/numeros-inteiros/)

Entre os números inteiros, temos os seguintes tipos:

| Tipo | Tamanho (bits) | Valor Mínimo | Valor Máximo | 
| --- | -------------- | ------------ | ------------ |
| Byte | 8              | -128         | 127          | 
| Short| 16             | -32768       | 32767        | 
| Int  | 32             | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1)
| Long | 64             | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) |

Em Kotlin quando você inicializa uma variável sem especificar o tipo, o compilador automaticamente infere o tipo com a menor tamanho à partir do tipo inteiro. Dependendo do tamanho do número o compilador pode inferir como Long.

As variáveis podem começar com as palavras chaves **val** e **var**, sendo **val** para variáveis que não irão mudar seus valores durante a execução do programa e **var** para aquelas que poderão ter seus valores alterados.

Segue um exemplo de tipagens com números inteiros:

```kotlin
val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
```

No exemplo acima, todos os tipos foram inferidos pelo compilador. Agora segue um exemplo onde você pode definir o tipo:

```kotlin
val one: Byte = 1
val valueShort: Short = -25000
val valueInt: Int = 600000
val valueLong: Long = 3000000000
```

Temos que ter um certo cuidado quando vamos definir o tipo da variável, pois o seu valor pode ultrapassar o seu limite máximo gerando um erro de tipagem.

### Números de Ponto Flutuante

De acordo com Rafael C. Asth professor de matemática, os números reais podem ser representados de diversas formas, como: inteiros positivos e negativos, frações, decimais, notação científica, raízes, etc. [Toda Matéria](https://www.todamateria.com.br/numeros-reais/)

Na computação definimos como números reais números que possuem casas decimais. Ex: 2.50 ou 3.14 ou 300000.85. Note que ao contrário do que estamos acostumados usamos ponto ao invés de vírgula.

Kotlin provê dois tipos de ponto flutuantes, utilizando o padrão [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754):

| Tipo | Tamanho (bits) | Bits Significativos | Bits Expoentes | Digitos Decimais |
| --- | -------------- | ------------ | ------------ | ---------- |
| Float | 32 | 24 | 8 | 6-7 | 
| Double | 64 | 53 | 11 | 15-16 | 

Como ocorre com os números inteiros, quando você não específica um tipo para variável, o compilador por padrão infere o tipo Double. Sempre que você quiser definir o tipo Float, você deve colocar um f ao final número. Caso você defina um tipo como Float e não adicione o f ao final do número isso irá gerar um erro de tipagem.

```kotlin
val pi = 3.14 // Double
val oneDouble = 1.0 // Double
val floatValue = 328.25f // Float 
```

Você também pode decidir qual o tipo você quer utilizar:

```kotlin
val e: Double = 2.7182818284 // Double
val eFloat: Float = 2.7182818284f
```

O tipo Double é o mais utilizado quando se trata de números com pontos flutuantes.

Vou ficando por aqui e espero que tenha dado uma noção sobre os tipos numéricos em Kotlin.