3.2. Literais. Memória. Variáveis. Instrução de atribuição

Os valores que usamos num programa podem ser representados de formas variadas. Já vimos que uma expressão representa um valor. Uma expressão é composta por sub-expressões unidas por um operador. Por exemplo, (245 + 455) * (17 + 3) é uma expressão que se pode decompor nas sub-expressões 245 + 455 e 17 + 3 unidas pelo operador *. Por sua vez, cada uma destas sub-expressões pode decompor-se em duas sub-expressões mais simples unidas pelo operador + (245 e 455 na primeira, e 17 e 3 na segunda).

A expressão mais simples, que não se pode decompor, pode ter duas formas: um literal ou uma variável.

3.2.1. Literais

Chamamos literal a um valor que representamos explicitamente em instruções do nosso programa (por ex., 245, 455, 17 e 3 no exemplo acima). Qualquer literal tem um tipo e, por isso, o conjunto de operações em que pode participar como operando está bem definido.

3.2.2. Memória

À medida que o computador avalia uma expressão, os valores das sub-expressões intermédias têm que ser guardados nalgum sítio para poderem ser recuperados quando forem precisos, para o cálculo do valor da expressão global. O programa

​x
public class Literals1 {
​
    public static void main (String [] args) {
​
        System.out.println((245 + 455) * (17 + 3));
​
    }
}

vai ter que ser capaz de guardar valores intermédios quando avalia a expressão, passo a passo, antes de imprimir o seu valor no ecrã. Por exemplo, antes de avaliar o resultado da multiplicação, as somas 245 + 455 e 17 + 3 têm que ser calculadas e os seus valores têm que ser guardados até serem usados na multiplicação. A forma como isso é feito é transparente para o programador que escreveu o programa, ou seja, ele não se apercebe de que isso acontece.

Para isso é usada a memória, que podemos imaginar dividida em células que conseguem guardar valores. O número de células de memória que é necessário usar para guardar um valor depende do tipo desse valor – uma única letra ocupa menos espaço de memória que um valor representando a distância da Terra à Lua, por exemplo.

3.2.3. Variáveis

Independentemente da forma como o computador avalia as expressões e usa a memória, o programador pode ter que guardar explicitamente um valor a certa altura do programa para o poder usar nalguma instrução mais à frente.

Por exemplo, no programa seguinte, que escreve os valores 700, 20, 14000, 28000 e 56000 no ecrã, precisamos de usar o valor de algumas expressões mais do que uma vez.

xxxxxxxxxx
public class Literals2 {
​
    public static void main (String [] args) {
​
        System.out.println("Valor do operando esquerdo da multiplicacao: ");
        System.out.println(245 + 455);
        System.out.println("Valor do operando direito da multiplicacao: ");
        System.out.println(17 + 3);
        System.out.println("Valor da multiplicacao: ");
        System.out.println((245 + 455) * (17 + 3));
        System.out.println("E agora o dobro do valor da multiplicacao: ");
        System.out.println(2 * (245 + 455) * (17 + 3));
        System.out.println("E agora o quadruplo do valor da multiplicacao: ");
        System.out.println(4 * (245 + 455) * (17 + 3));
​
    }
}

O ideal era podermos guardar o valor das expressões que precisamos de usar mais do que uma vez para não termos que estar sempre a repeti-las. Vamos fazer isso usando variáveis.

Uma variável é um nome que damos, no contexto de um programa, a uma ou várias células de memória.

Podemos escrever um valor nessas células e ler o valor que têm.

O programa seguinte faz exatamente o mesmo que o anterior, mas usa variáveis. Desse modo evita a repetição de cálculos. Não se preocupe se não percebe ainda as instruções do programa; é natural, pois só as abordaremos mais à frente.

xxxxxxxxxx
public class Variables1 {
​
    public static void main (String [] args) {
​
        int leftOperand;
        leftOperand = 245 + 455;
​
        int rightOperand = 17 + 3;
​
        System.out.println("Valor do operando esquerdo da multiplicacao: ");
        System.out.println(leftOperand);
​
        System.out.println("Valor do operando direito da multiplicacao: ");
        System.out.println(rightOperand);
​
        int completeExpression = leftOperand * rightOperand;
​
        System.out.println("Valor da multiplicacao: ");
        System.out.println(completeExpression);
​
        System.out.println("E agora o dobro do valor da multiplicacao: ");
        System.out.println(2 * completeExpression);
        System.out.println("E agora o quadruplo do valor da multiplicacao: ");
        System.out.println(4 * completeExpression);
​
    }
}

3.2.4. Declaração de variáveis

Sempre que usamos uma variável num programa temos que a declarar.

A declaração de uma variável

• reserva espaço em memória e
• dá um nome a esse espaço.

A instrução int leftOperand é uma declaração de variável; tem o efeito de reservar espaço em memória para guardar um valor do tipo inteiro (int – mais adiante neste texto) e dar-lhe o nome de leftOperand.

3.2.5. Escrever um valor na memória – Instrução de atribuição

Para escrever um valor em memória temos que indicar qual o valor que queremos escrever e onde o queremos escrever.

O sinal = representa a instrução de atribuição. O efeito da instrução var = expr é:

• a expressão expr que está à direita de = é avaliada e
• o valor resultante é escrito na célula de memória representada pela variável var.

A instrução leftOperand = 245 + 455 faz o computador calcular o valor da expressão 245 + 455 e de seguida escrever esse valor (700) na posição de memória representada por leftOperand.

A instrução int rightOperand = 17 + 3 exemplifica uma declaração de variável com inicialização.

Faz a declaração da variável rightOperand, de seguida avalia a expressão 17 + 3 e finalmente atribui esse valor (20) à variável rightOperand.

O efeito é exatamente o mesmo que se obteria com uma declaração de variável seguida de uma instrução de atribuição, como feito no caso de leftOperand.

NOTA: O lado esquerdo de uma instrução de atribuição tem que ser uma expressão que representa um sítio na memória. Na maior parte dos casos, essa expressão será somente o nome de uma variável. Isto entende-se bem: o lado esquerdo da atribuição deve indicar o sítio na memória onde queremos que seja escrito o resultado da expressão que está à direita da atribuição. A instrução seguinte é ilegal: leftOperand + 3 = 200; pois a expressão leftOperand + 3 não representa um sítio de memória, mas sim um valor.

Uma forma sugestiva de representarmos uma variável e o seu conteúdo, para efeitos de aprendizagem, é a seguinte:

3.2.6. Ler um valor da memória

Se declaramos uma variável e lhe atribuímos um valor é porque, mais cedo ou mais tarde, vamos querer utilizar esse valor. Para isso, temos que conseguir aceder ao valor contido na variável, ou seja, "ler" o seu valor.

Para ler o valor contido numa variável basta utilizar o seu nome.

Para que a instrução int completeExpression = leftOperand * rightOperand; seja executada, a expressão leftOperand * rightOperand tem que ser avaliada. As sub-expressões leftOperand e rightOperand representam os valores contidos nas variáveis correspondentes.

A instrução reserva espaço em memória para a variável completeExpression, de seguida avalia a expressão leftOperand * rightOperand fazendo a multiplicação dos conteúdos das variáveis leftOperand e rightOperand (700 e 20, respetivamente), e finalmente escreve o resultado (14000) na variável completeExpression.

3.2.7. Imprimir o valor de uma variável

Já sabemos escrever no standard output (o ecrã, normalmente) – usamos System.out.println(expr); em que expr é uma expressão (mais à frente nestas páginas falaremos mais sobre isto).

A expressão expr é avaliada e de seguida o seu valor é apresentado no standard output.

A expressão leftOperand é formada somente pelo nome de uma variável; logo, o seu valor é o valor que a variável tem no momento dessa avaliação. A instrução System.out.println(leftOperand); escreve no standard output o valor 700, que é o valor que foi escrito na posição de memória representada por essa variável.

Já a instrução System.out.println(2 * completeExpression); escreve no standard output o valor 28000, que é o valor que resulta da avaliação da expressão 2 * completeExpression.

Anterior: 3.1. Expressoes

Seguinte: 3.3. Tipos de dados primitivos e (um cheirinho de) String