Programação Orientada a Objetos: Uma Abordagem com Java/Princípios da programação na linguagem Java/Tipos primitivos

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Tipos primitivos[editar | editar código-fonte]

Em Java, são oferecidos tipos literais primitivos (não objetos) para representar valores booleanos, caracteres, numéricos inteiros e numéricos em ponto flutuante.

Boolean[editar | editar código-fonte]

Variáveis do tipo boolean podem assumir os valores true ou false. O valor inicial padrão para um atributo booleano de uma classe, se não especificado, é false.

Variáveis booleanas e variáveis inteiras, ao contrário do que ocorre em C e C++, não são compatíveis em Java. Assim, não faz sentido atribuir uma variável booleana a uma variável inteira ou usar um valor inteiro no contexto de uma condição de teste.

Exemplo de declaração e uso:

boolean deuCerto; 
deuCerto = true;

Combinando definição e inicialização,

boolean deuCerto = true;

Char[editar | editar código-fonte]

Uma variável do tipo char contém um caractere Unicode, ocupando 16 bits de armazenamento em memória. O valor inicial padrão de um atributo de classe do tipo char, se não especificado, é o caractere NUL (código hexadecimal 0000).

Um valor literal do tipo caractere é representado entre aspas simples (apóstrofes), como em:

char umCaracter = 'A';

Nesse caso, a variável ou atributo umCaracter recebe o caractere A, correspondente ao código hexadecimal 0041 ou valor decimal 65. Valores literais de caracteres podem também ser representados por sequências de escape, como em '\n' (o caractere newline, ou nova linha). Outras sequências de escape incluem '\t' (tabulação) e '\\' (para a barra invertida simples). Para representar um caractere qualquer do padrão Unicode, a sequência de escape é '\uXXXX', onde XXXX é uma sequência hexadecimal que pode assumir valores entre 0000 e FFFF. Sequências Unicode são processadas antes das anteriores, podendo aparecer não apenas em variáveis caracteres ou strings (como as outras sequências) mas também em identificadores da linguagem Java.

Números inteiros[editar | editar código-fonte]

Valores numéricos inteiros em Java podem ser representados por variáveis do tipo byte, short, int ou long. Todos os tipos contém valores inteiros com sinal, com representação interna em complemento de dois. O valor default para atributos desses tipos é 0.

Cada um desses tipos de dados tem seu espaço de armazenamento definido na especificação da linguagem, não sendo dependente de diferentes implementações. Variáveis do tipo byte ocupam 8 bits de armazenamento interno. Com esse número de bits, é possível representar valores na faixa de 128 a +127. Variáveis do tipo short ocupam 16 bits, podendo assumir valores na faixa de -32.768 a +32.767. Variáveis do tipo int ocupam 32 bits, podendo assumir valores na faixa de -2.147.483.648 a +2.147.483.647. Finalmente, variáveis do tipo long ocupam 64 bits, podendo assumir valores na faixa de -9.223.372.036.854.775.808 a +9.223.372.036.854.775.807.

Constantes literais do tipo long podem ser identificadas em código Java através do sufixo l ou L, como em

long valorQuePodeCrescer = 100L;

Ao contrário do que ocorre em C, não há valores inteiros sem sinal (unsigned) em Java. Adicionalmente, as combinações da forma long int ou short int são inválidas em Java.

Números reais[editar | editar código-fonte]

Valores reais, com representação em ponto flutuante, podem ser representados por variáveis de tipo float ou double. Em qualquer situação, a representação interna desses valores segue o padrão de representação IEEE 754, sendo 0.0 o valor default para tais atributos.

Como para valores inteiros, o espaço de armazenamento e consequentemente a precisão de valores associados a esses tipos de dados são definidos na especificação da linguagem. Variáveis do tipo float ocupam 32 bits, podendo assumir valores na faixa de 1,40239846 x 10-45 a 3,40282347 x 1038, com nove dígitos significativos de precisão.

Variáveis do tipo double ocupam 64 bits de armazenamento, podendo assumir valores de 4,94065645841246544 x 10-324 a 1,79769313486231570 x 10308, com 18 dígitos significativos de precisão.

Constantes literais do tipo float podem ser identificadas no código Java pelo sufixo f ou F; do tipo double, pelo sufixo d ou D.

Arranjos[editar | editar código-fonte]

Arranjos são agregados homogêneos de valores que podem agrupar literais ou objetos. A declaração de um arranjo, como

int array1[];

apenas cria uma referência para um arranjo de inteiros — porém o arranjo não foi criado.

A área de memória para armazenar os elementos de um arranjo é criada com o operador new:

array1 = new int[100];

Essa expressão cria espaço para armazenar 100 inteiros em um arranjo, que será referenciado pelo nome array1.

As duas expressões poderiam ter sido combinadas em uma sentença incluindo a declaração e a criação de espaço:

int array1[] = new int[100];

Arranjos podem ser alternativamente criados com a especificação de algum conteúdo:

int array2[] = {2, 4, 5, 7, 9, 11, 13};

O acesso a elementos individuais de um arranjo é especificado através de um índice inteiro. O elemento inicial, assim como em C e C++, tem índice 0. Assim, do exemplo acima, a expressão

int x = array2[3];

faz com que a variável x receba o valor 7, o conteúdo da quarta posição.

O acesso a elementos do arranjo além do último índice permitido — por exemplo, a array2[7] — gera um erro em tempo de execução, ou uma exceção. A dimensão de um arranjo pode ser obtida através da propriedade length presente em todos os arranjos. Assim, a expressão

int y = array2.length;

faz com que y receba o valor 7, o número de elementos no arranjo array2.