Entendendo as literais em Java

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (3)  (0)

Veja neste artigo os principais conceitos e dicas sobre literais em Java. Serão apresentados os tipos de literal da linguagem Java, como e quando utilizá-los.

Um sistema Java, ao ser desenvolvido, utilizará de várias representações de tipos primitivos e nulos. Essas representações, chamaremos de literais primitivas. Por exemplo, utilizamos números para representar um integer, true ou false para representar boolean e etc.

Listagem 1: Exemplos de literais primitivas

‘a‘      // literal char
12      // literal int
true   // literal boolean
23.4  // litreal double 

Como podemos perceber, são representações “gráficas” de códigos que representarão tipos primitivos da linguagem Java. Essas representações serão utilizadas em todo o sistema, possibilitando o programador a ter uma maior flexibilidade na separação de tipos diferentes e operações específicas para os mesmos.

Literais Integer

É possível representar números do tipo integer de três formas em Java: decimal (base 10), octal (base 8) e hexadecimal (base 16). Raramente serão utilizados os dois últimos tipos em situações “normais” de um ambiente de desenvolvimento. Porém, é interessante que sejam estudados, pois, além de conhecimento nunca ser o suficiente, todos os três serão abordados na prova da certificação OCJP 6. Sendo assim, aqueles que estiverem se preparando para a certificação, precisarão, ao menos, conhecê-los.

Literais Decimais:

É a mais utilizada por todos nós, desde o colegial. Em Java, elas são representadas apenas com números, sem prefixo ou sufixo. Exemplo:

Listagem 2: Exemplificando literais decimais

int idade = 23;   // 23 é uma literal decimal.
int altura = 180  // 180 é uma literal decimal. 

Como podemos notar, é algo que sempre utilizamos e talvez não soubéssemos, ainda, que essa representação poderia ser chamada de literal decimal, ou literal de base 10.

Literal Octal:

Octal, em Java, utiliza números entre 0 e 7. Para representar os números em octais, deve colocar um “0” na frente de qualquer inteiro. Por exemplo:

Listagem 3: Exemplificando literais octais

int x = 06;		
System.out.println("06 = "+ x);
		
x  = 07;
System.out.println("07 = " + x);

Como citado, é necessário o prefixo “0” antes de números entre 1 e 7 para representar um número octal. Resultado do código anterior:

Execução da classe Teste.java com os números octais

Figura 1: Execução da classe Teste.java com os números octais

No entanto, existe uma peculiaridade. E quando eu necessitar representar o número 9 em octal? Uma vez que ele aceita números entre 0 - 7?

É relativamente simples. O prefixo agora irá ser 0 ( padrão ) + 1 (representando que o contador ja passou pelo 7 uma vez e que está sendo zerado para que seja incrementado algo a partir do 7) + o próximo número em octal ( 0 - 7). Existe uma dica para poder saber o número octal fazendo somas entre os números. Exemplo, número 013. 01 = 7 (lembre-se, o 1 servirá para sabermos que já passamos pelo 7 uma vez) 3 = 4 ( já que começamos a contar do 0, 3 será 4). Resultado em 11, pois 7 + 4 = 11. Eis alguns exemplos de números octais:

Listagem 4: Exemplos de números octais

x = 013;
System.out.println("013 = " + x);
		
x = 015;
System.out.println("015 = " + x);

015 = 7 + 6 = 13. Veja o resultado:

Execução da classe Teste.java com valores octais acima de 7

Figura 2: Execução da classe Teste.java com valores octais acima de 7

É possível ter até 21 dígitos com um octal em Java, não incluindo o 0 inicial.

Literal Hexadecimal:

Hexadecimais, ou hex, são números contruídos com 16 símbolos distintos. Ainda não foram inventado símbolos numéricos para representar números de 10 a 15. Sendo assim, para contornar este problema de representação, é utilizado em hex as letras alfabéticas para fazer este trabalho. Para contarmos de 0 a 15 em hex, utilizariamos a seguinte representação:

Listagem 5: Contagem de 0 a 15 utilizando hex

 0 1 2 3 4 5 6 7 8 9 a b c d e f 

Sabendo disto, já temos, basicamente, todas as informações necessárias para se trabalhar com hex, uma vez que o a chave para o entendimento é notar que as letras substituem os números.

Um detalhe importante a ser acrescentado, é que java não é caseSensitive quanto ao reconhecimento das letras em hex. tanto faz você utilizar 123Cafe quando 123CAFE. Todos representarão 12312101514.

Parecidos com os números octais, os números hexadecimais irão utilizar o prefixo “0x” para determinar que aquele conjunto de caracteres estarão representando um número hex. E, claro, existe um limite de dígitos que pode ser utilizado. No caso dos hexadecimais, podem ser utilizados, no máximo, 16 dígitos não contando com o prefixo “0x”. Vejams um exemplo em prática:

Listagem 6: Exemplo de utilização de código hex

public class Tester {
	
	public static void main(String[] args) {

		// Recebe do console um número hex referente ao saldo da conta
		int hex = 0xFacade;
		System.out.println(hex);
		
		// Por algum motivo, o saldo da conta é alterado
		hex = 0x78Cade;
		System.out.println(hex);
		
		// Era um engano, a operação foi desfeita e foi depositado um "pequeno" valor
		hex = 0x9facade;
		System.out.println(hex);
		
		
	}

}

Que vai ter como resultado:

Teste de literais hexadecimais

Figura 3: Teste de literais hexadecimais

Literais inteiras, octais e hexadecimais são, por padrão, consideradas do tipo int. Mas, também podem ser utilizadas como long.

Literais de ponto flutuante:

Literais de ponto flutuante são representadas por números, sendo eles decimais, e outros números representando a fração.

Eis uma dica importante para a certificação Java: as literais de ponto flutuante são, por padrão, do tipo primitivo double. Sendo assim, se for tentado colocá-las em uma variável double do jeito “padrão” de sua representação, acontecerá um erro de compilação:

Ilustração de erro de compilação

Figura 4: Ilustração de erro de compilação

Para consertar isto, é necessário declarar o valor como float. Desta forma, o compilador saberá que aquele número de ponto flutuante é, de fato, um float. Deste jeito:

Listagem 7: Declarando um número como float

 float f = 12.34f; 

Isso mesmo, simples assim. Adiciona-se um “f” ou “F” ao final da literal e o compilador saberá do tipo daquela variável. Assim como, pode-se adicionar um “d” ou “D” para representar que um número é double, mesmo sabendo que não há necessidade.

Um detalhe importante sobre os números de ponto flutuantes é: Não tente utilizar vírgula para separar as frações. Em java, o ponto (.) é utilizado para isto. Caso tente utilizar vírgula, não irá compilar.

Literais booleanas:

Literais booleanas são representações de código para os valores booleanos. Sendo assim, seus valores só poderão ser true ou false. Atenção, repetindo: Só é permitido true ou false para representar um valor booleano. Não se deve tentar utilizar números ou qualquer outro valor pois a linguagem Java, ou melhor, o compilador não “aceitará”.

Sendo assim, segue o exemplo de utilizações válidas de literais booleanas:

Listagem 8: Representações válidas de literais booleanas

public class Tester {
	
	public static void main(String[] args) {

		boolean a = true;    // Ok!
		a = false;			 // Ok!
		
		a = 0;				 // Erro de compilação.
		a = 1; 				 // Erro de compilação.
		
		
	}

}

Literais Char:

São representadas por um único caracter. Por exemplo:

Listagem 9: Represetanção de uma literal char

 char c = ‘a’; 

Perceba que não é utilizado duplas aspas neste caso. Mas sim, aspas simples. Pode-se, também, inserir caracteres através de seus valores Unicode, utilizando a notação Unicode. Exemplo:

Listagem 10: Utilização de notação Unicode

 char n = ‘\u004E’; // Letra E 

Literais String:

Literais strings são representações de representações de código que representam um valor de um objeto String. Existem várias maneiras de se representar um objeto String, em Java. Segue, como exemplo, duas maneiras bastante utilizadas:

Listagem 11: Exemplo de literais String

 String nome = “Tiago Argolo”; System.out.println(“Tiago” + “Argolo”); 

No primeiro caso, um objeto String foi criado contendo o valor “Tiago Argolo”. No segundo caso, dois objetos Strings foram criados, contendo Tiago e Argolo respectivamente.

Com isso, finalizo o meu artigo sobre literais. Espero que todos tenham compreendido este assunto que servirá de base àqueles que decidiram ingressar no mundo Java.

Abraço!

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?