# Java Data Types: tipos de dados da linguagem de programação

Java oferece oito tipos de dados primitivos, além de muitos outros complexos. Estes determinam quais valores podem ser armazenados e exibidos dentro de uma variável. Certos tipos de dados são atribuídos a todas as variáveis em Java.

## Que tipos de dados existem em Java?

Em todas as linguagens de programação, existem diferentes tipos de dados que contêm determinados objetos e operações definidas. Embora sejam geralmente semelhantes, às vezes existem grandes diferenças nas opções oferecidas por uma linguagem. Se compararmos [Python e Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/python-vs-java/), por exemplo, notaremos inúmeras diferenças além das semelhanças, que predestinam cada linguagem a determinadas tarefas. Java utiliza dois tipos diferentes de dados: **primitivos e complexos** (também conhecidos como «tipos de referência»). Estes tipos de dados individuais de Java diferem em termos de tamanho e determinam quais os valores que podem ser armazenados numa variável.

Enquanto os tipos de dados primitivos só podem **armazenar valores simples**, os tipos de referência são usados para **criar estruturas mais complexas** e **organizar e manipular grandes quantidades de dados**. Se quiser aprender a programar, é importante não só conhecer os diferentes tipos de dados, mas também saber como usá-los. Por um lado, devemos conhecer a gama de funções e, por outro, o espaço de memória que cada tipo ocupa ou economiza.

## Tipos de dados primitivos em Java

Existem oito [tipos](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/) diferentes [de dados primitivos](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/) em Java que contêm intervalos de valores definidos. Eles podem ser divididos em quatro categorias: **tipo de dados lógicos, tipo de dados integrais, tipo de dados de vírgula flutuante e tipo de dados de caracteres**. Eles não têm capacidades especiais adicionais e também são conhecidos como tipos de dados elementares. Cada tipo de dados tem um número fixo de bits. A seguir, apresentamos com mais detalhes esses tipos de dados primitivos:

- boolean
- byte
- short
- int ou inteiro
- long
- float
- duplo
- caractere

### Booleano

O [Java Boolean](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-booleano-1/) não é um tipo numérico. Em vez disso, oferece apenas dois valores possíveis: **true e false**. Portanto, pode ser usado para determinar se uma condição se aplica (true) ou não (false). O seu valor padrão é false e pertence aos tipos de dados lógicos. Consiste em 1 bit e tem a seguinte sintaxe:

```java
boolean booleanVar;
```

### Byte

Byte é um tipo de dados integral e um valor de complemento a dois com um tamanho de 8 bits ou 1 byte. É usado principalmente quando se deseja economizar memória em matrizes maiores. O seu intervalo de valores vai de **-128 a 127** e o seu valor padrão é 0. Esta é a sua sintaxe:

```java
byte byteVar;
```

### Calções

Short também é um dos tipos de dados integrais em Java e é usado principalmente para economizar memória em matrizes maiores. O valor em complemento a dois em si mesmo é de 16 bits ou 2 bytes de tamanho e seu intervalo de valores vai **de -32768 a 32767, inclusive**. Por padrão, seu valor é 0. Short é usado assim:

```java
short shortVar
```

### int ou integer

Int ou integer também é um valor em complemento a dois e um tipo de dado integral com um tamanho de 4 bytes ou 32 bits. O seu intervalo de valores abrange números inteiros **entre -2147483648 e 2147483647**, e o seu valor padrão é 0. A sua sintaxe é a seguinte:

```java
int intVar
```

### longo

O tipo de dado inteiro maior é o long. Isso aplica-se tanto ao seu intervalo de valores, que varia **entre -9223372036854775808 e 9223372036854775807**, quanto ao seu tamanho, que é de 8 bytes ou 64 bits. O valor em complemento a dois é utilizado quando os outros tipos de dados inteiros não são suficientes. No entanto, também requer a maior quantidade de memória. O seu valor padrão é 0. Esta é a sua sintaxe:

```java
lomg longVar
```

### float

Float é um tipo de dado de ponto flutuante utilizado para armazenar números reais. Tem um tamanho de 32 bits e segue a norma IEEE 754, que define a representação padrão de números de ponto flutuante em sistemas informáticos. O valor padrão do float é 0,0 e pode representar **até sete dígitos decimais** no seu intervalo de valores. No entanto, em comparação com o double, o float não é tão preciso e não deve ser utilizado para valores em que a precisão é crucial. Se a precisão não for crítica, o float pode ajudar a economizar espaço. A sintaxe correspondente é a seguinte:

```java
float floatVar;
```

### duplo

Double é aproximadamente duas vezes mais preciso que float e cumpre uma finalidade semelhante. Tem um tamanho de 64 bits e pode representar **até 16 dígitos decimais**. Tal como float, o seu valor padrão é 0,0. Se precisar de valores mais precisos, é recomendável optar por double, embora este tipo de dado também não possa ser completamente exato em todos os casos. Se precisar de valores absolutamente precisos, deve considerar o uso da classe BigDecimal. A sintaxe do double é a seguinte:

```java
double doubleVar;
```

### char

Char é um tipo de dado de caracteres. Armazena caracteres baseados no conjunto de caracteres Unicode, o que permite a portabilidade para várias plataformas diferentes. Cada caractere ocupa 2 bytes de espaço na memória. O seu intervalo de valores corresponde ao padrão ASCII (American Standard Code for Information Interchange) e situa-se entre **“\\u0000” (equivalente a 0) e “\\uffff” (que é 65535)**. O valor padrão de char é “\\u0000” e a sua sintaxe é a seguinte:

```java
char charVar
```

## Tipos de dados Java: exemplos de tipos de dados complexos

O segundo tipo de dados em Java são os chamados tipos de referência ou tipos de dados complexos. Eles têm esse nome porque **remetem a objetos**. Ao contrário dos tipos de dados primitivos, normalmente não são predefinidos, mas sim determinados pelo programador (uma exceção é string). Podem utilizar métodos e também podem ter o valor 0 (no sentido de vazios). Enquanto os tipos de dados primitivos começam com minúscula, os tipos de referência começam com maiúscula. Apresentamos os tipos de referência mais importantes.

### Strings

String é uma classe que pode ser usada para representar uma **sequência de caracteres**. Isso distingue esse tipo de dados complexo do primitivo char, entre outros. O string existe como um objeto da classe java.lang. Os diferentes métodos da classe string permitem examinar caracteres individuais da cadeia, comparar cadeias entre si, procurar cadeias e copiá-las. O string é caracterizado por ter aspas na parte superior. A sintaxe deste tipo de referência é a seguinte:

```java
<Tipo_String> <Variable_String> = "<SecuenciaString>";
```

As strings funcionam como neste fragmento de código, por exemplo:

```java
// Crear un string sin un nuevo operador 
String a = "Este es tu nuevo string"; 
/ / Crear un string con un nuevo operador 
String a1 = nuevo string ("Este es tu nuevo string");
```

### Matrizes

As matrizes são utilizadas para armazenar **vários valores dentro de uma variável**, em vez de criar variáveis diferentes para cada valor individual. São indicadas por meio de colchetes. Os valores armazenados são colocados novamente entre chaves e separados por vírgulas. Esta é a sintaxe de uma matriz:

```java
tipodedatos[] arrayName = {Valor1, Valor2, Valor3,…};
```

Se quiser criar uma matriz com strings, proceda como neste exemplo:

```java
String[] colores = {"azul", "rojo", "amarillo", "lila"};
```

Se quiser criar uma matriz com números inteiros, pode proceder da seguinte forma:

```java
int[] números = {5, 10, 15, 20};
```

### Aulas

Em Java, as classes são tipos de dados que **servem como modelo** no qual os objetos são criados. Elas contêm vários componentes. Entre eles, o nome da classe, o seu modificador e um corpo, que é colocado entre chaves. Um exemplo seria o seguinte:

```java
public class Main { 
int a = 10; 
}
```

### Interfaces

Em Java, uma interface é uma **classe abstrata**. Ela atua como uma interface através da qual uma classe pode aceder a várias funções. Para isso, no entanto, primeiro é necessário implementá-las. As interfaces contêm apenas constantes e métodos abstratos. Portanto, a sua sintaxe é a seguinte:

```java
interface { 
Métodos abstractos
}
```

Para explicar como funcionam as interfaces, apresentamos um exemplo simples:

```java
interface Pizza { 
public void listadeingredientes(); 
public void preparación(); 
} 
class Funghi implements Pizza { 
public void listadeingredientes() { 
System.out.println("Champiñones, salsa de tomate, orégano, queso"); 
} 
public void prepración() { 
System.out.println("La pizza estará lista después de hornearla un cuarto de hora"); 
} 
} 
class Main { 
public static void main(String[] args) { 
Funghi myFunghi = new Funghi(); 
myFunghi.listadeingredientes(); 
myFunghi.preparación(); 
} 
}
```

O resultado correspondente ao comando Java `System.out.println` terá a seguinte aparência:

```java
Champiñones, salsa de tomate, orégano, queso 
La pizza estará lista después de hornearla un cuarto de hora
```

### Objetos

Em Java, os objetos também pertencem aos tipos de dados mais complexos. Os objetos são **instâncias de classes** que podem interagir entre si por meio de métodos. No exemplo a seguir, criamos vários objetos dentro de uma classe Main:

```java
public class Main { 
int a = 10; 
public static void main(String[] args) { 
Main myObj1 = new Main(); 
Main myObj2 = new Main(); 
System.out.println(myObj1.a); 
System.out.println(myObj2.a); 
} 
}
```

O resultado correspondente é o seguinte:

```java
10 
10
```

### Enums

As [enums](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/enums-em-java/) são uma classe especial que permite incorporar **constantes imutáveis no seu código**. A estas variáveis são atribuídos valores fixos que não podem ser alterados posteriormente. Este tipo de dados é particularmente útil se precisar de variáveis que só devem ter alguns estados possíveis. A sintaxe de uma enum é a seguinte:

```java
enum Nombre_de_la_clase { 
VALOR1, 
VALOR2, 
VALOR3 
}
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/tipos-de-dados-java/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/tipos-de-dados-java/) for AI/LLM consumption.