Tipos de dados em Java

Java é uma linguagem fortemente tipada, o que significa que cada variável e constante deve ter um tipo de dado bem definido. O tipo determina os valores que podem ser armazenados e as operações permitidas.

Os tipos de dados em Java são classificados em duas categorias principais:

1. Tipos Primitivos: representam valores simples, como números inteiros, decimais, caracteres e valores lógicos.
2. Tipos de Referência: representam objetos complexos, como strings, arrays e classes personalizadas.

Tipos Numéricos Inteiros

Java fornece diferentes tipos numéricos inteiros, que variam em tamanho e intervalo de valores armazenáveis:

byte a = 3;      // Ocupa 1 byte, intervalo de -128 a 127
short b = 8;     // Ocupa 2 bytes, intervalo de -32.768 a 32.767
int c = 9;       // Ocupa 4 bytes, intervalo de -2.147.483.648 a 2.147.483.647
long d = 10L;    // Ocupa 8 bytes, intervalo de -9 quintilhões a 9 quintilhões

O sufixo L ou l deve ser adicionado a números muito grandes para indicar que são do tipo long.

Notação de Números Literais

Valores inteiros podem ser declarados em diferentes sistemas numéricos:

int numHex = 0x6F;   // Hexadecimal (111 em decimal)
int numOct = 0144;   // Octal (100 em decimal)
int numBin = 0b1101; // Binário (13 em decimal)

Para melhorar a legibilidade, os números podem conter separadores de milhar (_), que são ignorados na compilação:

int x = 123_456;
int y = 234_567_789;
System.out.println(x);  // 123456
System.out.println(y);  // 234567789

Tipos Numéricos de Ponto Flutuante

Os números de ponto flutuante armazenam valores decimais e são representados pelos tipos float e double:

float x = 8.5F;    // Ocupa 4 bytes, precisa do sufixo 'F' ou 'f'
double y = 2.7;    // Ocupa 8 bytes, maior precisão, sufixo opcional

O ponto . é usado como separador decimal.

Conversão de Tipos

O Java permite a conversão automática entre tipos numéricos em algumas situações. Esse processo é chamado de conversão implícita de tipos e ocorre quando um valor de um tipo menor é atribuído a uma variável de um tipo maior.

int a = 10;
double b = a;  // Conversão automática de int para double

System.out.println(b);  // 10.0

Nesse exemplo, o valor inteiro 10 foi atribuído a uma variável double. O Java converte int para double automaticamente, pois double tem uma capacidade maior de armazenamento e pode conter números inteiros e decimais.

Se uma variável for declarada com var, o tipo será inferido automaticamente com base no valor atribuído:

var x = 20;   // Tipo inferido como int
var y = 3.14; // Tipo inferido como double

System.out.println(x);  // 20
System.out.println(y);  // 3.14

Aqui, x recebe um valor inteiro, então o compilador entende que ele é do tipo int. Já y recebe um número decimal, sendo inferido como double.

No entanto, a conversão automática não funciona para reduzir o tamanho de um tipo, como de double para int. Isso exige uma conversão explícita (casting), pois pode resultar em perda de precisão:

double pi = 3.14159;
int inteiro = (int) pi;  // Conversão explícita (perde a parte decimal)

System.out.println(inteiro);  // 3

A conversão automática ocorre apenas de um tipo menor para um tipo maior, garantindo que não haja perda de informação.

Tipo Booleano

O tipo boolean pode armazenar apenas dois valores: true ou false:

boolean isActive = false;
boolean isAlive = true;

Tipo char

O tipo char representa um único caractere e ocupa 2 bytes (16 bits), pois utiliza a codificação UTF-16. Isso permite armazenar qualquer caractere Unicode, incluindo letras, números, símbolos e caracteres especiais.

Exemplo de declaração e uso de char

char letter = 'A';
char symbol = '?';
char number = '7;

System.out.println(letter);   // A
System.out.println(symbol); // ?
System.out.println(number);  // 5

⚠️ Os valores de char devem ser colocados entre aspas simples ('). Se forem usadas aspas duplas ("), ocorrerá um erro de compilação, pois aspas duplas são reservadas para String.

Uso de Códigos Unicode

Além de armazenar caracteres diretamente, um char pode receber um valor numérico correspondente a um caractere Unicode.

O intervalo de valores que um char pode armazenar vai de 0 a 65535, pois cada número representa um caractere específico na tabela Unicode.

char ch1 = 65;      // 65 representa 'A' na tabela Unicode
char ch2 = '\u0066'; // '\u0066' representa 'f'
char ch3 = 102;     // 102 também representa 'f'

System.out.println(ch1);  // A
System.out.println(ch2);  // f
System.out.println(ch3);  // f

Isso significa que qualquer caractere Unicode pode ser armazenado em um char, desde que seu código esteja dentro do intervalo 0 a 65535.

⚠️ Importante: Apesar de char armazenar um número internamente, ele não deve ser tratado como um tipo numérico (int, byte, etc.), pois sua função é representar símbolos e caracteres, e não valores matemáticos.

String

Exemplo de declaração e uso de String

String message = "Olá, mundo!";
System.out.println(message);

⚠️ Strings devem ser escritas entre aspas duplas ("). Se forem usadas aspas simples ('), ocorrerá um erro, pois aspas simples são reservadas para char.

Diferença entre char e String

Caracteres Especiais e Quebra de Linha

Strings podem conter caracteres especiais, como \n, que representa quebra de linha:

String text = "Olá,\nJava!";
System.out.println(text);

Saída no console:

Olá,
Java!

A partir do Java 15, foi introduzido o conceito de text blocks, que permitem definir strings multilinhas sem precisar de \n ou concatenação:

String text = """
    Olá,
    Java!
    """;
System.out.println(text);

Isso facilita a escrita de textos longos sem precisar adicionar \n manualmente ou usar + para quebrar linhas.

Resumo

• Java é fortemente tipado, o que significa que cada variável ou constante deve ter um tipo de dado bem definido.

• Os tipos primitivos em Java são:

  • Tipos numéricos inteiros: byte, short, int, long.
  • Tipos numéricos de ponto flutuante: float, double.
  • Tipo booleano: boolean, que armazena true ou false.
  • char pode armazenar valores Unicode numéricos, como 65 para 'A', e deve ser usado com aspas simples (').
• String representa sequências de caracteres, usa aspas duplas (") e oferece diversas funcionalidades para manipulação de texto.
• Números literais podem ser escritos em diferentes bases, como decimal, binária (0b), octal (0) e hexadecimal (0x).
• Conversão automática de tipos ocorre quando um valor menor é promovido para um tipo maior, como int → double.
• Conversões explícitas (casting) são necessárias para reduzir o tamanho de um tipo, como double → int.
• Caracteres especiais, como \n, podem ser usados em String para formatar texto.
• Desde o Java 15, text blocks (""") permitem definir strings multilinhas sem precisar de \n ou concatenação.

Nos próximos artigos, exploraremos cada um desses tipos com mais detalhes, além de aprender a manipulá-los e utilizá-los em diferentes situações.

📝 Exercícios

Tarefa 1: Adivinhando o Tipo de var

O código abaixo declara quatro variáveis usando var. Tente prever qual tipo será inferido para cada uma delas.

var x = 10;
var y = 3.14;
var z = "Java";
var w = 'A';

Pergunta: Quais são os tipos inferidos pelo Java para x, y, z e w?

Tarefa 2: Testando Conversão Automática de Tipos

Leia o código abaixo e tente prever a saída antes de executá-lo.

int a = 5;
double b = a;
char c = 66;
double d = c;

System.out.println(b);
System.out.println(c);
System.out.println(d);

Pergunta: O que será impresso no console?

5.0
B
66.0

Tarefa 3: Corrigindo o Código

O código abaixo contém erros de declaração. Leia atentamente e corrija os erros para que o programa compile e funcione corretamente.

char letra = "J";
String word = 'Java';
int number = 2.5;
double value = 10,5;

System.out.println(letra);
System.out.println(word);
System.out.println(number);
System.out.println(value);

Pergunta: Quais erros existem no código e como corrigi-los?

char letra = 'J';         // char usa aspas simples
String word = "Java";   // String usa aspas duplas
int number = 2;           // int não pode armazenar valores decimais
double value = 10.5;      // O separador decimal deve ser ponto, não vírgula