# Tudo sobre os tipos de dados primitivos em Java Em Java, existem oito tipos de dados primitivos que têm um tamanho fixo e um intervalo de valores definido. Eles são usados para criar variáveis e atribuir-lhes números, caracteres ou valores lógicos individuais. Os oito primitivos de Java são boolean, byte, chat, double, float, int, long e short. ## O que são os primitivos Java? Tal como noutras linguagens de programação, também existem diferentes [tipos de dados Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/tipos-de-dados-java/). O Java define dois tipos diferentes: os tipos de referência são objetos que podem ser definidos livremente (como strings, matrizes, classes ou interfaces). Também existem tipos de dados que, em Java, são denominados «primitivos». Estes têm um **tamanho fixo** que é idêntico em todas as plataformas. Todos têm **a** sua **própria classe de encapsulamento**, são **integrados de forma invariável** e têm um **intervalo de valores fixo**. Os primitivos Java são utilizados para criar variáveis que contêm números, caracteres ou valores lógicos individuais. Em Java, existem oito tipos diferentes de dados primitivos, que são tão elementares que a sua representação está firmemente ancorada na linguagem de programação. Eles diferem principalmente nos **valores que podem armazenar**. O que todos têm em comum é que contêm apenas um único valor. Como as suas respetivas áreas de aplicação são parcialmente semelhantes, os primitivos em Java são divididos em quatro categorias: - Tipo de dados lógico (booleano) - Tipo de dados inteiros (byte, short, int e long) - Dados de ponto flutuante (float e double) - Tipo de dados de caracteres (char) Como são armazenados diretamente na pilha, o seu tamanho respectivo pode ter uma importância decisiva. Mais adiante, aprofundaremos este tema. Os tipos de dados primitivos também são muito importantes porque Java é uma linguagem **tipada estaticamente**. Isso significa que, quando se cria um programa, o tipo de dados de uma variável já deve ser conhecido e definido. Só então o código pode ser executado sem mensagens de erro. Estes são os primitivos de Java:
Tipo de dado Tamanho Intervalo de valores Valor predefinido Classe de encapsulamento
boolean 1 bit verdadeiro ou falso falso java.lang.Boolean
byte 8 bits -128 a 127 0 java.lang.Byte
short 16 bits -32768 a 32767 0 java.lang.Short
int 32 bits -2147483648 a 2147483647 0 java.lang.Integer
long 64 bits -9223372036854775808 a 9223372036854775807 0 java.lang.Long
float 32 bits até sete casas decimais 0,0 java.lang.Float
double 64 bits até 16 casas decimais 0,0 java.lang.Double
char 16 bits \*\*’\\u0000’ (também 0) a ‘\\uffff’ (equivalente a 65535) ‘\\u0000’ java.lang.Character
## boolean O [Java Boolean](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-booleano-1/) também é conhecido como valor de verdade. É o mais simples de todos os primitivos em Java, pois reconhece apenas dois valores possíveis: **“true” ou “false”.** É utilizado quando é necessário um operando lógico e, portanto, pertence exclusivamente ao grupo dos tipos de dados lógicos. Nas expressões, os seus dois valores possíveis geralmente representam uma condição que é cumprida (true) ou não (false). Se não for atribuído um valor a um booleano, ele é automaticamente falso. O booleano pode ser utilizado com operadores Java como [AND e OR](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/operadores-java-and-e-or/). A atribuição funciona de acordo com o seguinte princípio: ```java public class Main { public static void main(String[] args) { boolean x = true; System.out.println(x); } } ``` Uma saída com o comando Java `System.out.prinln` é a seguinte: ```java true ``` ## byte O byte é a opção mais pequena dentro da categoria de tipos de dados inteiros. Tem um intervalo de valores muito limitado, que vai de **-128 a 127**. No entanto, também requer apenas 8 bits de memória. Deve o seu nome ao facto de 8 bits corresponderem a um byte. Se precisar apenas de opções de valores muito limitados, pode declarar um byte da seguinte forma: ```java public class Main { public static void main(String[] args) { byte x = 101; System.out.println(x); } } ``` O resultado seria: ```java 101 ``` ## short O short é **duas vezes maior que o byte**, mas também é um dos tipos primitivos Java menos usados. No entanto, se o byte for muito pequeno e o int for muito grande, pode usar este tipo de dado integral. É declarado da seguinte forma: ```java public class Main { public static void main(String[] args) { short x = -27412; System.out.println(x); } } ``` O resultado é o seguinte: ```java -27412 ``` ## int O int é o tipo de dado integral **mais** utilizado. Tem um intervalo de valores muito amplo e, ao mesmo tempo, é relativamente eficiente em termos de espaço ocupado. O valor de complemento a dois é utilizado em muitos casos para aplicações avançadas. Pode utilizá-lo desta forma: ```java public class Main { public static void main(String[] args) { int x = 14; int y = 3; int z = x + y; System.out.println(x + " + " + y + " = " + z); } } ``` Este seria o resultado: ```java 14 + 3 = 17 ``` ## longo O long é uma extensão do int e pode conter **números ainda maiores**. Na maioria dos casos, o int será suficiente, mas se desejar declarar um long, pode fazê-lo da seguinte forma: ```java public class Main { public static void main(String[] args) { long x = 47; System.out.println(x); } } ``` Este seria o resultado: ```java 47 ``` ## float Se quiser representar subconjuntos de números racionais, existem dois primitivos em Java para esse fim. float é o menor dos dois **tipos de dados de ponto flutuante** e requer 32 bits. Pode mostrar até sete casas decimais. No entanto, não é muito preciso e, portanto, é pouco utilizado. Se ainda assim precisar dele, declare-o da seguinte forma: ```java public class Main { public static void main(String[] args) { float x = 7.22f; System.out.println(x); } } ``` Insira um «f» minúsculo ou maiúsculo após o número para indicar ao compilador que se trata de um float e não de um double. A letra não é exibida na saída: ```java 7.22 ``` ## duplo O segundo tipo de dados de ponto flutuante é double. Embora seja muito mais preciso do que float, não fornece resultados totalmente exatos. Uma alternativa é a **classe BigDecimal**. Se double for suficiente para si, aqui está um exemplo de código apropriado: ```java public class Main { public static void main(String[] args) { double x = 7.2252; System.out.println(x); } } ``` Portanto, pode dispensar o dígito adicional. Este é o resultado: ```java 7.2252 ``` ## char O tipo char é utilizado para representar um caractere em Unicode. Este abrange de ‘\\u0000’ a ‘\\uffff’, ou seja, de 0 a 65535. Desta forma, o tipo de dados char pode representar **quase todos os caracteres europeus e asiáticos**. Cada um destes caracteres ocupa 16 bits de memória. Os valores deste tipo primitivo de Java são colocados entre aspas simples. O código ficaria assim: ```java public class Main { public static void main(String[] args) { char x = '&'; System.out.println(x); } } ``` Você obterá este resultado: ```java & ``` This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/) for AI/LLM consumption.