Tipos de dados

Os tipos de dados guardados por variáveis e constantes são separados entre "primitivos" e "compostos".

Primitivos

Os tipos primitivos são os que guardam a menor unidade possível de dado. São eles:

TipoSignificadoTamanhoValores possíveis
byteNúmero inteiro1 byte-128 a 127
shortNúmero inteiro2 bytes-65536 a 65535
intNúmero inteiro4 bytes-2³² a 2³² - 1
longNúmero inteiro8 bytes-2⁶⁴ a 2⁶⁴ - 1
-----------------------------------------------------------
floatNúmero real4 bytes[1]
doubleNúmero real8 bytes[1]
-----------------------------------------------------------
booleanValor lógico1 byteFalso e Verdadeiro
-----------------------------------------------------------
charUm caractere2 bytes[2]

[1]: Definir os valores possíveis para números reais não é uma tarefa tão simples à primeira vista. Números reais utilizam um padrão de armazenamento chamado Ponto Flutuante (por isso o nome float), em que temos uma mantissa, uma base e um expoente, e o valor de um número nesse padrão é dado por mantissa * base ^ expoente. Por conta disso (aliado ao fato de que, em computadores, a base e o número de bits da mantissa e do expoente são fixos), floats conseguem maior precisão em valores entre -1 e 1, porém a medida em que os valores ficam mais distantes de 0, os números representados com esse padrão começam a ficar mais esparços (mantendo-se o mesmo tamanho para a mantissa).

Quanto ao nome double, a ideia vem de "Double Precision", pelo fato de que ocupa o dobro de espaço em memória (e portanto diz-se ter o dobro de precisão). Quanto a quais variáveis utilizar, recomenda-se double (salvo raras exceções, como ambientes em que o consumo de memória por floats seja o gargalo -- por exemplo, ambientes com objetos 3D compostos de absurdamente muitos vértices --).

(OBS: NÃO utilize float nem double para armazenar dados sensíveis (como, por exemplo, dinheiro). Veja na recomendação de leitura #4 o porquê disso.)

[2]: Textos, dentro do mundo da computação, possuem codificações específicas para indicar o que é cada caractere. Essencialmente, um caractere não passa de um número inteiro. Por exemplo:

char a = 97;
char b = 98;
char c = 65;
char d = 33;

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

O código acima mostrará:

a
b
A
!

Pois, pelo padrão de codificação Unicode, que é o que Java também utiliza (especificamente, Java utiliza o formato UTF-16, que engloba caracteres não-ocidentais, e, como o nome diz: ocupa 16 bits por caractere), 97 é o valor que simboliza a letra "a" (minúsculo), enquanto 98 simboliza "b", 65 a letra "A" (maiúsculo) e 33 simboliza "!". Porém, texto em computação não necessariamente é apenas letras (a-z, A-Z), acentos e pontuações ("!", "`", "~", ...), mas também elementos especiais como quebra de linha. Por exemplo:

char lineBreak = 13;

System.out.print("Hello, ");
System.out.print(lineBreak);
System.out.print("World!");

Perceba que executando o código acima, mesmo não tendo um println (e sim apenas print, que não pula linha), aparecerá:

Hello,
World!

Pois "13" é o código que simboliza quebra de linha (em SO's baseados em Unix; em Windows, uma quebra de linha é o caractere 13 seguido do caractere 10).

Compostos

Os tipos compostos são, em resumo, todos os que não são primitivos. Por exemplo:

  • String;
  • Object;
  • ArrayList;
  • Arrays (demarcados com um [], visto mais à frente).

Em uma aula mais a frente, aprenderemos a criar nossos próprios tipos compostos.