_Os tipos de dados em java_ são de diferentes tamanhos e valores que podem ser

armazenados na `variável` que é feita de acordo com a `conveniência` e as

`circunstâncias` para encobrir todos os casos de `teste`. Java tem duas
`categorias` nas quais os tipos de dados são segregados.
- _Tipo de dados primitivos_: `boolean, char, int, short, byte, long, float e
double`.
- _Tipos de dados não primitivos ou tipos de dados de objeto_: `String, Array,
etc`.
![[GIF AND PHOTOS/Photo/Data-types-in-Java.jpg]]
## Tipos de dados primitivos em java.
_Os dados primitivos são apenas valores únicos e não têm recursos especiais_.
Existem 8 tipos de `dados primitivos`

| Tipo | Descrição | Default | Tamanho | Exemplos literais | Intervalo de valores |

| :--: | :--: | :--: | :--: | :--: | :--: |
| boolean | verdadeiro ou falso | false | 1 bits | true , false | true , false |
| byte | Inteiros de dois complementos | 0 | 8 bits | ( none ) | -128 a 127 |
| char | Caractere Unicode | \u0000 | 16 bits | ‘a’, ‘\u0041’, ‘\101’, ‘\\’, ‘\’,
‘\n’, ‘β’ | representação de caracteres de valores ASCII: <br><br>0 a 255 anos |
| short | Inteiros de dois complementos | 0 | 16 bits | (none) | -32.768 a 32.767 |
| int | Intger de dois complementos | 0 | 32 bits | -2,-1,0,1,2 | -
2,147,483,648 <br>Para<br>2,147,483,647 |
| long | Inteiros de dois complementos | 0 | 64 bits | -2L,-1L,0L,1L,2L | -
9,223,372,036,854,775,808 <br>Para<br>9,223,372,036,854,775,807 |
| float | Ponto flutuante IEEE 754 | 0.0 | 32 bits | 1.23e100f , -1.23e-
100f , .3f ,3.14F | até 7 dígitos decimais |
| double | Ponto flutuante IEEE 754 | 0.0 | 64 bits | 1.23456e300d , -123456e-
300d , 1e1d | até 16 dígitos decimais |
## Tipo de dado `boolean`.
O tipo de dado `boolean` representa apenas `1 bit` de informação _verdadeiro ou
falso_ que se destina a representar os dois valores _verdade da lógica e da
álgebra_ booleana, mas o tamanho do tipo de dados booleano é `dependente da máquina
virtual`. Os valores do tipo booleano não são convertidos `implícitamente` ou
`explicitamente` para qualquer outro tipo. _Mas o programador pode facilmente
escrever código de conversão_.
```java
boolean indentifyBool;
```
_Tamanho_: Depende da maquina virtual.

## Tipo de dado `byte`.

O tipo de dado de `byte` é um `inteiro` de complemento de dois assinados de `8
bits`. O tipo de dados de byte é _útil para economizar memória em matrizes
grandes_.
```java
byte identifyByte;
```
_Tamanho_: 1 byte ( 8 bits ).

## Tipo de dado `short`.

O tipo de dado `short` é um inteiro complemento de dois assinados de `16 bits`.
Semelhante ao byte, _use o `short` para economizar memória em matrizes grandes_, em
situações em que a economia de memória realmente importa.
```java
short indentifyShort;
```
_Tamanho_: 2 bytes ( 16 bits ).

## Tipo de dado `int`.

É um inteiro de complemento de dois assinados de `32 bits`.
```java
int identifyInt;
```
_Tamanho_: 4 bytes ( 32 bits ).
_Lembre-se_: No Java SE 8 e posterior, podemos usar o tipo de dados int para
representar um inteiro de 32 bits não assinado, que tem um valor no intervalo [0,
232-1]. Use a classe Integer para usar o tipo de dados int como um inteiro não
assinado.

## Tipo de dado `long`.

O alcance do `long` é bastante grande. O tipo de dados `long` é um inteiro de
complemento de dois bits de 64 bits e _é útil para as ocasiões em que um tipo `int`
não é grande o suficiente para manter o valor desejado_.
```java
long identifyLong;
```
_Tamanho_: 8 bytes ( 64 bits );
*Lembre-se:* No Java SE 8 e posterior, é possível utilizar o tipo de dados long
para representar um long de 64 bits não assinado, que tem um valor mínimo de 0 e um
valor máximo de 264-1. A classe Long também contém métodos como comparar Unsigned,
dividir Unsigned, etc para dar suporte a operações aritméticas para longos não
assinados.

## Tipo de dado `float`.

O tipo de dado `float` é um ponto flutuante `IEEE 754` de `precisão única` de 32
bits. _Use um float `( em vez de double )` se precisar economizar memória em
grandes matrizes de números de ponto flutuante_.
```java
float identifyFloat;
```
_Tamanho_: 4 bytes ( 32 bits ).

## Tipo de dado `double`.

O tipo de dado `double` é um ponto flutuante `IEEE 754` de 64 bits de `precisão
dupla`. _Para valores decimais, esse tipo de dado geralmente é a opção padrão_.
```java
double identifyDouble;
```
_Tamanho_: 8 bytes ou 64 bits.
**Nota:** Ambos os tipos de dados flutuantes e duplos foram projetados
especialmente para cálculos científicos, onde erros de aproximação são aceitáveis.
Se a precisão for a preocupação mais prévia, recomenda-se não usar esses tipos de
dados e usar a classe BigDecimal.
###### Recomenda-se passar por [__erros de arredondamento em
java.__](https://www.geeksforgeeks.org/rounding-off-errors-java/).

## Tipo de dado `char`.

O tipo de dados `char` é um único caractere `Unicode` de 16 bits.
```java
char identifyChar;
```
_Tamanho_: 2 bytes ( 16 bits );

## Por que o tamanho do `char` é de `2 Bytes` em java?

Assim , outras linguagens como `C/C++` usam apenas caracteres _ASCII_, e para
representar todos os caracteres _ASCII_ 8 bits é suficiente. Java usa o sistema
`Unicode` não o sistema de código _ASCII_ , para representar o sistema `Unicode` 8
bits não é o suficiente para representar todos os caracteres, então java usa `2
bytes` para caracteres. _O `Unicode` define um conjunto de caracteres totalmente
internacional que pode representar a maioria dos idiomas escritos no mundo_.
```java
class App {
public static void main(String[] args) {
// Criando e inicializando caractere personalizado
char caracterePersonalizado = 'G';

// O tipo de dado inteiro é geralmente

// usado para valores numéricos
int numeroInteiro = 89;

// Use byte e short

// se a memória for uma restrição
byte valorByte = 4;

// Isso dará erro, pois o número é

// maior que o intervalo de byte
// byte valorByte1 = 7888888955;

short valorCurto = 56;

// Isso dará erro, pois o número é

// maior que o intervalo de short
// short valorCurto1 = 87878787878;

// Por padrão, o valor fracionário

// é do tipo double em Java
double valorDouble = 4.355453532;

// Para float, use 'f' como sufixo conforme padrão

float valorFloat = 4.7333434f;

// Se precisarmos armazenar um grande intervalo de números, então

precisamos
// deste tipo de dado
long valorLongo = 12121;

System.out.println("char: " + caracterePersonalizado);

System.out.println("inteiro: " + numeroInteiro);
System.out.println("byte: " + valorByte);
System.out.println("short: " + valorCurto);
System.out.println("float: " + valorFloat);
System.out.println("double: " + valorDouble);
System.out.println("long: " + valorLongo);
};
};
```
#### Saída:
```text/plain
char: G
integer: 89
byte: 4
short: 56
float: 4.7333436
double: 4.355453532
long: 12121
```
## Tipos de dados não primitivos.
Os ***Tipos de Dados de Referência*** conterão um endereço de memória de valores de
variáveis porque os tipos de referência não armazenarão o valor da variável
diretamente na memória. São strings, objetos, matrizes, etc.

**1. Strings:**
As strings são definidas como uma matriz de caracteres em Java. Diferentemente de
C/C++, as strings em Java não são terminadas com um caractere nulo. A sintaxe para
declarar uma string é:

```java
String stringExemplo = "SequenciaDeCaracteres";
```

**2. Classe:**
Uma classe em Java é um protótipo definido pelo usuário para criar objetos. A
declaração de classe inclui modificadores, nome da classe, superclasse (se houver)
e interfaces (se houver), além do corpo da classe. Exemplo:

```java
public class ExemploClasse extends SuperClasse implements Interface1, Interface2 {
// Corpo da classe
}
```

**3. Objeto:**
Um objeto é a unidade básica da Programação Orientada a Objetos em Java. Ele
representa entidades da vida real e consiste em estado, comportamento e identidade.
Exemplo:

```java
ExemploClasse meuObjeto = new ExemploClasse();
```

**4. Interface:**
Uma interface em Java especifica métodos e variáveis, sendo os métodos por padrão
abstratos. Ela descreve o que uma classe deve fazer, não como fazer. Exemplo:

```java
public interface ExemploInterface {
void metodoAbstrato();
}
```

**5. Matriz:**
Uma matriz em Java é um grupo de variáveis do mesmo tipo referidas por um nome
comum. As matrizes em Java são alocadas dinamicamente, e seu tamanho é especificado
por um valor int. Exemplo:

```java
int[] arrayExemplo = new int[5];
```

Esses são conceitos fundamentais em Java que abrangem strings, classes, objetos,
interfaces e matrizes.

=> [[Variáveis]]