Variáveis e literais


Em diversas linguagens de programação existe o conceito de variável. Uma variável corresponde a uma posição de memória. Uma declaração de variável define seu tipo e o identificador (nome) e também outros atributos. Uma das coisas que podemos fazer com uma variável é usa-la como alvo de uma operação de atribuição (assignment).
A sintaxe simplificada de um comando  de atribuição é:
<identificador da variável> = <expressão>;
Neste comando o valor correspondente à expressão é copiado para a posição de memória correspondente à variável. Note que o antigo valor é perdido. A sintaxe e semântica de uma <expressão> serão definidas mais tarde; nos programas abaixo apresentamos expressões simples e bem intuitivas.

O tipo restringe os valores que podem ser atribuidos a uma variável. A restrição de tipo para uma variável acarreta maior disciplina por parte do programador e permite programas mais eficientes e com menor probabilidade de erros. A associação de um tipo a uma variável é similar à amarração de uma variável a um domínio como ocorre na Matemática. No entanto deve ser ressaltado que o conceito de variável em Computação e o conceito de variável em Matemática são bastante distintos. Uma das distinções mais notáveis é que uma variável na Matemática, usualmente, não tem um valor específico. Considere a  expressão da Matemática
y=x+3
A variável x não tem um valor, esta expressão, usualmente, designa o lugar geométrico dos pontos de um plano que formam uma reta. A variável x pode tomar qualquer valor real. As vezes os autores cuidadosos explicitam que x pertence ao domínio dos números Reais, outros autores assumem que o leitor irá deduzir isso.  Na Computação, uma variável, no escopo onde ela é válida, sempre tem um determinado valor associado a ela, este valor possivelmente muda ao longo do tempo, mas a cada momento o valor de uma variável é único. Na Matemática, uma expressão envolvendo uma variável, deve sempre considerar que aquela variável, em todo ponto que ela aparece, tem sempre um mesmo valor. Na Computação, em particular na linguagem Java, isto não é verdade, considere o trecho de programa abaixo:
int x;
x=(x=((x=1)+1)+1);
Na expressão acima a variável x aparece três vezes. Em cada uma das vezes x tem um valor distinto associado a ela. (A expressão acima não tem muito sentido (melhor escrever x=3;) mas, mais a frente na disciplina, veremos o conceito de função e teremos oportunidade de construir expressões onde este aspecto faça mais sentido)

A linguagem Java tem oito tipos primitivos:

  1. byte
  2. short
  3. int
  4. long
  5. char
  6. float
  7. double
  8. boolean
É interessante que não exista o mnemonico integer ao invés  int, ou real ao invés de float, afinal o computador representa apenas um subconjunto finito dos domínios infinitos correspondentes encontrados na Matemática. Cada tipo tem literais que são as cadeias de caracteres que representam os valores constantes disponíveis. O tipo boolean tem somente dois literais: (1) true e (2) false. Cada valor inteiro (ou mais apropriadamente cada valor do tipo int) pode ter vários literais,  um literal decimal, um literal hexadecimal ou um literal octal (base oito!).

O trecho de programa Java correspondente a System.out.println(<argumento>) ou System.out.print(<argumento>) corresponde a invocar a impressão do argumento no video do sistema. O argumento deve ser do tipo String (o tipo String será visto mais a frente no curso). A linguagem Java permite que o programador use como argumento uma variável ou expressão de um tipo que não seja String, e neste caso é feita uma conversão do argumento para o tipo String.

class VariavelTipoInt{
  public static void main(String args[]){
    int i; // declaração
    i=3;   // comando de atribuição
    System.out.println(i);
  }
}

class VariavelTipoDouble{
  public static void main(String args[]){
    double d;  //declaração
    d=3.1415;  //comando de atribuição
    System.out.println(d);
  }
}

class VariavelTipoBoolean{
  public static void main(String args[]){
    boolean b;  // declaração
    b=true;     //comando de atribuição
    System.out.println(b);
  }
}

class DuasVariaveisTipoInt{
  public static void main(String args[]){
    int i; // declaração
    int j; // declaração
    i=5;   // comando de atribuição: expressão simples
    j=i/2; // comando de atribuição: expressão envolvendo divisão
    System.out.println(j);
  }
}

Literais

Um literal é a forma de representar no texto de um programa um valor de um certo tipo. A linguagem Java apresenta 6 tipos de literais:
IntegerLiteral
FloatingPointLiteral
BooleanLiteral
CharacterLiteral
StringLiteral
NullLiteral

Os literais String  (cadeias de caracteres) consistem de sequências de caracteres delimitadas por aspas (p.ex. "A", "AB", "ABC", "ABCD"). Existem também expressões do tipo String. O operador + (adição) além de representar a soma de inteiros ou soma de ponto flutuante pode representar a concatenação de cadeias de caracteres. A cadeia "ABCD" é equivalente à expressão "AB" + "CD" ou à expressão "A" + "BCD".

Os literais inteiros podem ser expressos por sequencias de caracteres em decimal (p.ex. 1, 23, 456), sequencias de caracteres em hexadecimal precedidas port 0x ou 0X (0x1, 0xA, 0xFF02) ou sequencias de caracteres em octal precedidas por 0 (sim! um zero à esquerda! p.ex. 01, 023, 0456). Os literais inteiros podem apresentar como sufixo a letra L maiúscula ou minúscula, neste caso o literal inteiro passa a ser do tipo long (p. ex. 23L, OXAL, 026L). Os literais inteiros podem designar valores para variáveis do tipo int, long, short, byte e char.

A linguagem Java tem regras sobre quais literais com quais valores podem ser atribuidos a variáveis inteiras. O compilador faz as conversões necessárias e internamente todos valores são representados através de zeros e uns. O trecho de programa abaixo mostra uma atribuição e a impressão deste valor em diferentes bases:


int x=14;
System.out.println(x); /* conversão padrão: base 10 */
System.out.println("base 3: "+x/(3*3)%3+x/3%3+x%3);
System.out.println("base 2: "+x/(2*2*2*2)%2+x/(2*2*2)%2+x/(2*2)%2+x/2%2+x%2);

O trecho acima imprime:
14
base 3: 112
base 2: 1110
É um exercício interessante imprimir os valores em diferentes bases. Não é preciso iterar para saber a quantidade de dígitos necessários uma vez que, para cada base, o maior número possível de dígitos é fixo. No caso da base 10 uma variável int pode conter um máximo de 10 dígitos decimais. No caso de uma variável long, ela pode guardar valores com 64 digitos binários.

Os literais de ponto flutuante tem as seguintes partes: parte inteira, ponto decimal, parte fracionária, expoente e sufixo. O expoente, se presente, é indicado pela letra e ou E seguido de um inteiro. Os literais de ponto flutuante podem designar valores para variáveis do tipo float e double. O maior literal do tipo float é 3.40282347E+38F, o menor positivo finito diferente de zero é 1.40239846E-45F. O maior literal double positivo é 1.79769313486231570E+308, o menor positivo diferente de zero é 4.94065645841246544E-324

Os tipos float e double, segundo a recomendação do padrão IEEE 754 podem representar infinito. Não existem literais para infinito devem ser usadas expressões do tipo 1f/0f ou -1d/0d
Os literais float e double somente podem ser expressos na base dez.

Os literais de caracteres são sequências de caracteres entre apóstrofos. O literal correspondente à letra a minúscula é 'a', este é um exemplo de literal de um só caractere mas existe também a Seqüência de Escape. A representação da barra invertida: '\\', a representação de aspas '\"' e a representação do apostrofo: '\''. Alguns literais de caracteres representam caracteres que podem ser tratados de forma especial por alguns dispositivos de entrada e saída: '\n' (newline), '\t' (tabulation), '\b' (backspace), '\r' (return), '\f' (form feed).

Complete a tabela  de compatibilidade de atribuição de literais e variáveis (faça os programas e verifique!) As colunas são os tipos de literais e as linhas representam os tipos de variáveis.
 
   literal
tipo var		 Integer Floating Boolean Character String Null
byte ok x x
short ok x x
int ok x x
long ok x x
char ok x x
float ok x x
double ok x x
boolean ok x x
referência x x x x (*) ok

(*) um literal String para poder ser  atribuído a uma variável exige que a classe desta variável seja do tipo String ou descendente desta classe.

A linguagem Java permite algumas atribuições entre variáveis de tipos diferentes. Considere o trecho de programa abaixo:
int i=3;
long j=2;
j=i; /* permitido: valor de um tipo mais restrito para um menos restrito */

Mas neste outro trecho há um problema:
int i=3;
long j=2;
i=j; /* erro!! */

A linguagem Java exige que, na atribuição de um valor de tipo menos restrito para uma variável de tipo mais restrito, seja usado, de forma explícita, um mecanismo denominado "elencamento" (cast). O "elenco" de valores em uma variável do tipo long é maior que o "elenco" de valores do tipo int. A linguagem Java exige que o programador explicite o elencamento do valor long para um valor int. Grosseiramente é como se a linguagem obrigasse o programador a declarar que ele sabe que aquela atribuição pode resultar em problemas.
int i=3;
long j=2;
i= (int) j; /* ok */
j=9999999999L;
i= (int) j; /* permitido mas o valor em j não e' preservado */

A conversão em um elencamento envolve, em geral, abandonar alguns bits de mais alta ordem. No trecho abaixo a variável b é iniciada com um valor que no contexto do tipo short é negativo, mas que ao ser elencado perde alguns bits e passa a ser, no contexto do tipo byte, um valor positivo! No trecho abaixo o conteúdo de s é -134 e o conteúdo de b é 122.
short s= -134;
byte b = (byte) s;
System.out.println(s);
System.out.println(b);

Uma outra tabela trata da questão da atribuição entre variáveis de tipos primitivos diferentes. Considere a atribuição A=B; O tipo de A corresponde às linhas e o tipo de B corresponde às colunas. Complete a tabela abaixo, onde inválido significa que a linguagem não permite a atribuiçao nem mesmo com o uso de elencamento (cast), auto significa que a conversão é feito de forma implícita e elencar significa que a atribuição só é possível através do uso de elencamento.
 
 
A  B-> long int short char byte double float boolean
long
-
 auto auto auto auto elencar elencar invalido
int elencar
- 
 invalido
short elencar elencar
-
 invalido
char elencar elencar
-
 invalido
byte elencar elencar
-
 invalido
double auto auto
-
 invalido
float auto auto
-
 invalido
boolean inválido inválido inválido inválido inválido inválido inválido
-

Observe que a linguagem Java não permite a mistura do tipo boolean com nenhum outro tipo. Em algumas linguagens, como por exemplo C e C++ é permitido tratar valores booleanos como sendo inteiro e vice-versa. Nestas linguagens o valor false corresponde ao valor zero (zero inteiro) e o valor true a valores diferentes de zero.