Avalie expressões Java com operadores

Neste tutorial, você aprenderá como escrever expressões para seus programas Java. Em muitos casos, você usará operadores para escrever suas expressões Java, e há muitos tipos de operador saber como usar. Apresentarei brevemente os tipos de operadores Java, incluindo os tipos aditivo, bit a bit, lógico, condicional, shift e igualdade e seus operandos. Você também aprenderá sobre sobrecarga e precedência de operadores e verá uma demonstração de conversão de tipo primitivo. Concluirei com um pequeno programa Java que você pode usar para praticar conversões de tipo primitivo por conta própria.

O que você aprenderá neste tutorial Java

O que é uma expressão Java?
Como escrever expressões simples
Como escrever expressões compostas
Sobre operadores e operandos Java
Todos os tipos de operadores em Java, com exemplos
Sobre precedência e associatividade do operador
Como trabalhar com conversões de tipo primitivo

download

Baixe o código-fonte de aplicativos de exemplo neste tutorial. Criado por Jeff Friesen.

O que é uma expressão Java?

Expressões são combinações de literais, chamadas de métodos, nomes de variáveis e operadores. Os aplicativos Java avaliam expressões. Avaliar uma expressão produz um novo valor que pode ser armazenado em uma variável, usado para tomar uma decisão e muito mais.

Como escrever expressões simples

A expressão simples é um literal, nome de variável ou chamada de método. Nenhum operador está envolvido. Aqui estão alguns exemplos de expressões simples:


52                         // integer literal
age                        // variable name
System.out.println("ABC"); // method call
"Java"                     // string literal
98.6D                      // double precision floating-point literal
89L                        // long integer literal

Uma expressão simples tem um tipo, que é um tipo primitivo ou um tipo de referência. Nestes exemplos, 52 é um número inteiro de 32 bits (int); System.out.println("ABC"); é nulo (void) porque não retorna nenhum valor; "Java" é uma string (String); 98.6D é um valor de ponto flutuante de precisão dupla de 64 bits (double); e 89L é um número inteiro longo de 64 bits (long). Nós não sabemos agetipo.

Use jshell para experimentar

Você pode experimentar facilmente essas e outras expressões simples usando jshell. Por exemplo, digite 52 no jshell> prompt e você receberá algo como a seguinte saída:

$1 ==> 52

$1 é o nome de um variável de rascunho que jshell cria para armazenar 52. (Variáveis scratch são criadas sempre que literais são inseridos.) Execute System.out.println($1) e você verá 52 como saída.

Você pode correr jshell com o -v argumento de linha de comando (jshell -v) para gerar feedback detalhado. Neste caso, entrar 52 resultaria na seguinte mensagem, revelando aquela variável scratch $1 tem int (número inteiro de 32 bits) tipo:

|  created scratch variable $1 : int

Em seguida, tente inserir age. Nesse caso, você provavelmente receberá uma mensagem de erro informando que o símbolo não foi encontrado. O Java Shell assume que age é uma variável, mas não conhece seu tipo. Você teria que incluir um tipo; por exemplo, veja o que acontece se você inserir int age.

Como escrever expressões compostas

A expressão composta consiste em uma ou mais expressões simples integradas em uma expressão maior por meio de um operador, que é uma sequência de instruções representadas simbolicamente no código-fonte. O operador transforma sua expressão operando(s) em outro valor. Por exemplo, em 6 * 5o operador de multiplicação (*) transforma operandos 6 e 5 em 30.

Expressões compostas podem ser combinadas em expressões maiores. Por exemplo, 6 * 5 + 10 apresenta expressão composta 6 * 5 e uma expressão composta que consiste em seu produto, operador de adição +e o número 10. A ordem de avaliação (multiplicar primeiro e depois adicionar) é ditada pelo Java regra de precedênciaque abordaremos em breve.

Sobre operadores e operandos Java

Os operadores Java são classificados pelo número de operandos:

A operador unário tem um operando, por exemplo, unário menos (por exemplo, -5).
A operador binário tem dois operandos, exemplos são multiplicação e adição.
A operador ternário possui três operandos; um exemplo é o operador condicional (?:).

Os operadores Java também são classificados por posição:

A operador de prefixo é um operador unário que precede seu operando (por exemplo, -5).
A operador postfix é um operador unário que segue seu operando (por exemplo, age++; – adicione 1 a agevalor numérico).
Um operador infixo é um operador binário ou ternário entre os operandos do operador (por exemplo, age + 5).

Outro exemplo de jshell

Apresentarei mais operadores nas seções seguintes, onde apresento exemplos na forma de aplicações. Você também pode experimentar esses operadores com jshelligual a:

jshell> 6 + 2
$1 ==> 8

jshell> 7 * $1
$2 ==> 56

Neste caso, primeiro inserimos a expressão 6 + 2qual jshell avalia, atribuindo o 8 resultante à variável scratch $1. A seguir, multiplicamos $1 por 7que armazena 56 na variável scratch $2. Este exemplo demonstra que é possível usar variáveis temporárias em expressões Java.

Tipos de operadores em Java

A seguir, faremos um tour por todos os tipos de operadores em Java. Após apresentar cada tipo de operador, apresentarei um exemplo que mostra como ele é usado em expressões Java.

Operadores aditivos

O operadores aditivos aumentar ou diminuir um valor numérico por meio de adição e subtração. Os operadores aditivos incluem adição (+), subtração (-), pós-decremento (--), pós-incremento (++), pré-decremento (--) e pré-incremento (++). Concatenação de strings (+) também é considerado aditivo. Aqui está uma definição formal para cada um desses operadores:

Adição: Dado operand1 + operand2onde cada operando deve ser do tipo caractere ou numérico, adicione operand2 para operand1 e devolva a soma. Exemplo: 4 + 6.
Subtração: Dado operand1 - operand2onde cada operando deve ser do tipo caractere ou numérico, subtraia operand2 de operand1 e devolva a diferença. Exemplo: 4 - 6.
Pós-decremento: Dado variable--onde variable deve ser do tipo caractere ou numérico, subtraia 1 de variablevalor de (armazenando o resultado em variable) e retorne o valor original. Exemplo: x--;.
Pós-incremento: Dado variable++onde variable deve ser do tipo caractere ou numérico, adicione 1 a variablevalor de (armazenando o resultado em variable) e retorne o valor original. Exemplo: x++;.
Pré-decremento: Dado --variableonde variable deve ser do tipo caractere ou numérico, subtraia 1 do seu valor, armazene o resultado em variablee retorne o novo valor decrementado. Exemplo: --x;.
Pré-incremento: Dado ++variableonde variable deve ser do tipo caractere ou numérico, adicione 1 ao seu valor, armazene o resultado em variablee retorne o novo valor incrementado. Exemplo: ++x;.
Concatenação de strings: Dado operand1 + operand2onde pelo menos um operando é de String digite, anexe operand2representação de string para operand1representação de string e retornar o resultado. Exemplo: "A" + "B".

Os operadores de adição, subtração, pós-decremento, pós-incremento, pré-decremento e pré-incremento podem gerar valores que ultrapassam os limites do tipo de resultado. Por exemplo, adicionar dois valores inteiros positivos grandes de 64 bits pode produzir um valor que não pode ser representado em 64 bits. O overflow resultante não é detectado ou relatado pelos operadores aditivos do Java.

Exemplo de aplicação: operadores aditivos

A Listagem 1 apresenta uma pequena aplicação para brincar com os operadores aditivos do Java.

Listagem 1. Operadores aditivos em Java (AddOp.java)

class AddOp
{
   public static void main(String() args)
   {
      System.out.println(125 + 463);
      System.out.println(2.0 - 6.3);
      int age = 65;
      System.out.println(age);
      System.out.println(age--);
      System.out.println(age++);
      System.out.println(--age);
      System.out.println(++age);
      System.out.println("A" + "B");
   }
}

Consulte Recursos da linguagem Elementary Java para obter uma introdução ao uso do JDK javac ferramenta para compilar o código-fonte Java e o java ferramenta para executar o aplicativo resultante. Execute o seguinte comando para compilar a Listagem 1:

javac AddOp.java

Supondo uma compilação bem-sucedida, você deve observar um AddOp.class arquivo no diretório atual. Execute o seguinte comando para executá-lo:

java AddOp

AddOp responde produzindo a seguinte saída:

O estudo dessa saída oferece insights sobre os operadores pós-incremento, pós-decremento, pré-incremento e pré-decremento. Para pós-incremento/pós-decremento, ageO valor atual de é gerado antes da operação de incremento/decremento. Para pré-incremento/pré-decremento, a operação é executada e seu resultado é armazenado em agee então ageO novo valor de é produzido.

Operador de índice de array

O operador de índice de array (()) acessa um elemento de array fornecendo o nome do elemento índice (posição). Este operador é colocado após o nome da variável array, como em grades(0) (acesse o primeiro elemento do array atribuído a grades; o primeiro elemento é armazenado no índice 0). Aqui está uma definição formal:

Dado variable(index)onde index deve ser inteiro (int) digite, leia um valor ou armazene um valor em variableelemento de armazenamento no local index. Exemplo: temperatures(1)

O valor passado para index é um número inteiro de 32 bits que é 0 ou um valor positivo variando até um a menos que o comprimento da matriz, que é indicado anexando .length ao nome da matriz. Por exemplo, grades.length retorna o número de elementos no array atribuído a grades.

Exemplo de aplicação: operador de índice de array

A Listagem 2 apresenta o código-fonte de um aplicativo de exemplo que permite brincar com o operador de índice de array.

Listagem 2. Operador de índice de array em Java (ArrayIndexOp.java)

class ArrayIndexOp
{
   public static void main(String() args)
   {
      int() grades = { 89, 90, 68, 73, 79 };
      System.out.println(grades(1));
      grades(1) = 91;
      System.out.println(grades(1));
      int index = 4;
      System.out.println(grades(index));
      System.out.println(grades('C' - 'A'));
//      System.out.println(grades(1D));
   }
}

A Listagem 2 é um pouco mais interessante que a Listagem 1. Depois de criar um array unidimensional de cinco elementos de inteiros (por meio de um inicializador de array) e atribuir a referência do array a grades, main() passa a acessar vários elementos. Dois itens são de especial interesse:

O índice do operador de índice de matriz deve ser um número inteiro de 32 bits (0 ou um valor positivo). Você pode especificar o nome de uma variável inteira (por exemplo, index), que contém o valor do índice, como o índice.
Você pode especificar um cálculo envolvendo literais de caracteres. (Mais adiante neste tutorial apresentarei as conversões de tipo e você descobrirá por que 'C' - 'A' produz um número inteiro (2), que serve como um índice válido.)

O exemplo final, que passa 1D como um índice para o operador de índice de array, é comentado porque não será compilado. Se você descomentar a linha e tentar compilar a Listagem 2, receberá uma mensagem de erro sobre tipos incompatíveis: “possível conversão com perdas de double para int..”

Compilar Listagem 2 (javac ArrayIndexOp.java) e execute o aplicativo (java ArrayIndexOp). Você deve observar a seguinte saída:

Operadores de atribuição

O operador de atribuição (=) atribui o valor de uma expressão a uma variável (por exemplo, i = 6;), incluindo um elemento de matriz (por exemplo, x(0) = 15;). A expressão e a variável devem ser atribuição compatível, o que significa que seus tipos devem concordar. Por exemplo, você não pode atribuir uma string literal a uma variável inteira. Explicarei mais sobre isso quando discutirmos conversões de tipo.