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

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

Expressões[editar | editar código-fonte]

Expressões são sentenças da linguagem Java terminadas pelo símbolo ‘;’. Essas sentenças podem denotar expressões envolvendo uma operação aritmética, uma operação lógica inteira, uma operação lógica booleana, uma avaliação de condições, uma atribuição, um retorno de método, ou ainda operações sobre objetos.

Expressões retornando valores numéricos[editar | editar código-fonte]

Expressões aritméticas envolvem atributos, variáveis e/ou constantes numéricas (inteiras ou reais). Os operadores aritméticos definidos em Java incluem:

soma
operador binário infixo denotado pelo símbolo +;
subtração
operador binário infixo denotado pelo símbolo -. O mesmo símbolo pode ser utilizado como operador unário prefixo, denotando a complementação (subtração de 0) do valor;
multiplicação
operador binário infixo denotado pelo símbolo *;
divisão
operador binário infixo denotado pelo símbolo /;
resto da divisão
operador binário infixo denotado pelo símbolo % e que pode ser aplicado apenas para operandos inteiros;
incremento
operador unário denotado pelo símbolo ++ que é definido apenas para operandos inteiros, podendo ocorrer na forma prefixa (pré-incremento) ou posfixa (pós-incremento); e
decremento
operador unário denotado pelo símbolo -- que também é definido apenas para operandos inteiros, podendo ocorrer na forma prefixa (pré-decremento) ou posfixa (pós-decremento).

Operações lógicas binárias sobre valores inteiros atuam sobre a representação binária do valor armazenado, operando internamente bit a bit. Operadores desse tipo são:

complemento
operador unário prefixo denotado pelo símbolo ~ que complementa cada bit na representação interna do valor;
OR bit-a-bit
operador binário infixo denotado pelo símbolo | que resulta no bit 1 se pelo menos um dos bits na posição correspondente na representação interna dos operandos era 1;
AND bit-a-bit
operador binário infixo denotado pelo símbolo & que resulta no bit 0 se pelo menos um dos bits na posição correspondente na representação interna dos operandos era 0;
XOR bit-a-bit
operador binário infixo denotado pelo símbolo ^ que resulta no bit 1 se os bits na posição correspondente na representação interna dos operandos eram diferentes;
deslocamento à esquerda
operador binário infixo denotado pelo símbolo << que desloca a representação interna do primeiro operando para a esquerda pelo número de posições indicado pelo segundo operando;
deslocamento à direita
operador binário infixo denotado pelo símbolo >> que desloca a representação interna do primeiro operando para a direita pelo número de posições indicado pelo segundo operando. Os bits inseridos à esquerda terão o mesmo valor do bit mais significativo da representação interna;
deslocamento à direita com extensão 0
operador binário infixo denotado pelo símbolo >>> que desloca a representação interna do primeiro operando para a direita pelo número de posições indicado pelo segundo operando. Os bits inseridos à esquerda terão o valor 0.

Expressões retornando valores booleanos[editar | editar código-fonte]

As operações lógicas booleanas operam sobre valores booleanos. Operadores booleanos incluem:

complemento lógico
operador unário prefixo denotado pelo símbolo ! que retorna true se o argumento é false ou retorna false se o argumento é true;
OR lógico booleano
operador binário infixo denotado pelo símbolo | que retorna true se pelo menos um dos dois argumentos é true;
OR lógico condicional
operador binário infixo denotado pelo símbolo || que opera como o correspondente booleano; porém, se o primeiro argumento já é true, o segundo argumento não é nem avaliado;
AND lógico booleano
operador binário infixo denotado pelo símbolo & que retorna false se pelo menos um dos dois argumentos é false;
AND lógico condicional
operador binário infixo denotado pelo símbolo && que opera como o correspondente booleano; porém, se o primeiro argumento já é false, o segundo argumento não é nem avaliado;
XOR booleano
operador binário infixo denotado pelo símbolo ^ que retorna true quando os dois argumentos têm valores lógicos distintos.

Condições permitem realizar testes baseados nas comparações entre valores numéricos. Operadores condicionais incluem:

maior
operador binário infixo denotado pelo símbolo > que retorna true se o primeiro valor for exclusivamente maior que o segundo;
maior ou igual
operador binário infixo denotado pelo símbolo >= que retorna true se o primeiro valor for maior que ou igual ao segundo;
menor
operador binário infixo denotado pelo símbolo < que retorna true se o primeiro valor for exclusivamente menor que o segundo;
menor ou igual
operador binário infixo denotado pelo símbolo <= que retorna true se o primeiro valor for menor que ou igual ao segundo;
igual
operador binário infixo denotado pelo símbolo == que retorna true se o primeiro valor for igual ao segundo;
diferente
operador binário infixo denotado pelo símbolo != que retorna true se o primeiro valor não for igual ao segundo.

Outros tipos de expressões[editar | editar código-fonte]

Assim como C e C++, Java oferece o operador condicional ternário denotado pelos símbolos  ? : . Na expressão

b ? s1 : s2

b é uma expressão que resulta em um valor booleano (variável ou expressão). O resultado da expressão será o resultado da expressão (ou variável) s1 se b for verdadeiro, ou o resultado da expressão (ou variável) s2 se b for falso.

O operador binário = atribui o valor da expressão do lado direito à variável à esquerda do operador. Os tipos da expressão e da variável devem ser compatíveis. O operador de atribuição pode ser combinado com operadores aritméticos e lógicos, como em C e C++. Assim, a expressão

a += b

equivale a

a = a + b

Métodos em Java têm sua execução encerrada de duas maneiras possíveis. A primeira é válida quando um método não tem um valor de retorno (o tipo de retorno é void): a execução é encerrada quando o bloco do corpo do método chega ao final. A segunda alternativa encerra a execução do método através do comando return. Se o método tem tipo de retorno void, então o comando return pode ser omitido ou usado sem argumentos:

return;

Caso o método tenha um valor de retorno especificado, então a expressão de retorno deve assumir a forma

return expressão;

onde o valor de retorno é o resultado da expressão, que deve ser compatível com o tipo de retorno especificado para o método.

Controle do fluxo de execução[editar | editar código-fonte]

A ordem de execução normal de comandos em um método Java é sequencial, ou seja, um comando após o outro na sequência em que foram escritos no código. Comandos de fluxo de controle permitem modificar essa ordem natural de execução através dos mecanismos de escolha (alternativas) ou de iteração (repetição).

Blocos de comandos são sequências de comandos individuais delimitadas por chaves, { e }.

Alternativas[editar | editar código-fonte]

O comando if permite especificar um comando (ou bloco de comandos) que deve apenas ser executado quando uma determinada condição for satisfeita:

if (condição) { 
    bloco_comandos 
}

Quando o bloco de comandos é composto por uma única expressão, as chaves que delimitam o corpo do bloco podem ser omitidas, embora tal prática não seja recomendada. Embora a endentação do código não seja mandatória, é uma recomendação de boa prática de programação que o bloco subordinado a uma expressão de controle de fluxo seja representada com maior endentação que aquela usada no nível da própria expressão.

O comando if...else permite expressar duas alternativas de execução, uma para o caso da condição ser verdadeira e outra para o caso da condição ser falsa:

if (condição) { 
    bloco_comandos_caso_verdade 
} 
else { 
    bloco_comandos_caso_falso 
}

O comando switch...case também expressa alternativas de execução, mas nesse caso as condições estão restritas à comparação de uma variável inteira com valores constantes:

switch (variável) { 
case valor1: 
     bloco_comandos 
     break; 
case valor2: 
     bloco_comandos 
     break;
// Outros casos/valores... 
case valorn: 
     bloco_comandos 
     break; 
default: 
     bloco_comandos 
}

Observe que é necessário concluir os blocos com o comando break; caso contrário, o bloco de comando do caso seguinte ao selecionado também será executado na sequência. O caso default é opcional, sendo selecionado se nenhum dos casos especificados anteriormente ocorre.

Iteração[editar | editar código-fonte]

O comando while permite expressar iterações que devem ser executadas se e enquanto uma condição for verdadeira:

while (condição) { 
    bloco_comandos 
}

Se a condição for avaliada como falsa, o bloco de comandos não será executado.

O comando do...while também permite expressar iterações, mas neste caso pelo menos uma execução do bloco de comandos é garantida, uma vez que a condição é apenas avaliada após o bloco:

do { 
    bloco_comandos 
} while (condição);

O comando for permite expressar iterações combinando uma expressão de inicialização, um teste de condição e uma expressão de incremento:

for (inicialização; condição; incremento) { 
    bloco_comandos 
}

Embora Java não suporte o operador , (vírgula) presente em C e C++, particularmente no comando for múltiplas expressões de inicialização e de incremento podem ser separadas por vírgulas.

Os comandos continue e break permitem expressar a quebra de um fluxo de execução. O comando break já foi utilizado juntamente com switch para delimitar bloco de comandos de cada case. No corpo de uma iteração, a ocorrência do comando break interrompe a iteração, passando o controle para o próximo comando após o comando de iteração.

O comando continue também interrompe a execução da iteração, mas apenas da iteração corrente. Como efeito da execução de continue, a condição de iteração é reavaliada e, se for verdadeira, o bloco de comandos no corpo da iteração volta a ser executado.

Em situações onde há diversos comandos de iteração aninhados, os comandos break e continue transferem o comando de execução para o ponto imediatamente após o bloco onde ocorrem. Se for necessário especificar transferência para o fim de outro bloco de iteração, os comandos break e continue rotulados podem ser utilizados:

label: { 
    for (...; ...; ...) { 
        ... 
        while (...) { 
            ... 
            if (...) 
                break label; 
            ... 
        } 
        ... 
     } 
     ... 
}

Entretanto, tais construções complexas são raras e devem efetivamente ser evitadas por prejudicar a compreensão do código.

Comentários[editar | editar código-fonte]

Comentários em Java podem ser expressos em três formatos distintos.

O primeiro formatp é o comentário no estilo C tradicional, onde o par de símbolos /* marca o início de comentário, que pode se estender por diversas linhas até encontrar o par de símbolos */, que delimita o fim do comentário.

No segundo formato, uma barra dupla // marca o início do comentário, que se estende até o fim da linha. É um estilo de comentário que foi introduzido na linguagem C++.

O terceiro formato de comentário é específico de Java e está associado à geração automática de documentação do software desenvolvido. Nesse caso, o comentário é delimitado pelas sequências de início /** e de término */. O texto entre essas sequências será utilizado pela ferramenta javadoc para gerar a documentação do código em formato hipertexto (HTML).

Para gerar esse tipo de documentação, os comentários devem estar localizados imediatamente antes da definição da classe ou membro (atributo ou método) documentado. Cada comentário pode conter uma descrição textual sobre a classe ou membro, possivelmente incluindo rótulos HTML, e diretrizes para o programa javadoc. As diretrizes para javadoc são sempre precedidas por @, como em

@see nomeClasseOuMembro

que gera na documentação um link para a classe ou membro especificado, precedido pela frase “See also ”. A documentação de uma classe pode incluir as diretrizes @author, que inclui o texto na sequência como informação sobre o autor do código na documentação; e @version, que inclui na documentação informação sobre a versão do código. A documentação de um método pode incluir as diretrizes @param, que apresenta o nome e uma descrição de cada argumento do método; @return, que apresenta uma descrição sobre o valor de retorno; e @exception, que indica as exceções que podem ser lançadas pelo método.

Para maiores informações, veja o texto How to Write Doc Comments for Javadoc.