Aprendendo Java do Zero - Parte 4: Operadores

#Java

Este é o quarto artigo da série Aprendendo Java do Zero. Na Parte 1, escrevemos nosso primeiro "Hello World". Na Parte 2, montamos um ambiente de desenvolvimento local completo. E na Parte 3, aprendemos a declarar variáveis e conhecemos os oito tipos primitivos de dados.

Agora que já sabemos guardar valores em variáveis, é hora de fazer alguma coisa com eles. Neste artigo, nós vamos:

entender o que são operadores em Java;
conhecer os operadores aritméticos;
conhecer os operadores de atribuição (o = e suas variações combinadas);
conhecer os operadores relacionais, usados para comparar valores;
conhecer os operadores lógicos, usados para combinar condições;
conhecer os operadores unários, usados para incrementar e decrementar valores.

Como usar operadores em Java

Operadores são símbolos que instruem o compilador a executar operações: aritméticas, relacionais, lógicas, entre outras. Vamos ver cada categoria separadamente.

Operadores aritméticos

São os operadores usados para realizar cálculos matemáticos básicos:

+: soma
-: subtração
*: multiplicação
/: divisão
%: resto da divisão (módulo)

public class Main {
  public static void main(String[] args) {
      int numero1 = 10;
      int numero2 = 5;

      System.out.println(numero1 + numero2); // 15
      System.out.println(numero1 - numero2); // 5
      System.out.println(numero1 * numero2); // 50
      System.out.println(numero1 / numero2); // 2
      System.out.println(numero1 % numero2); // 0
  }
}

Um detalhe importante: o tipo de dado usado afeta o resultado da divisão. Se você divide dois int, o resultado também será um int, e a parte decimal é descartada, não arredondada:

public class Main {
  public static void main(String[] args) {
      int numero1 = 8;
      int numero2 = 5;

      System.out.println(numero1 / numero2); // 1 (e não 1.6)
  }
}

Se pelo menos um dos operandos for double, o resultado preserva a casa decimal:

public class Main {
  public static void main(String[] args) {
      double numero1 = 8;
      double numero2 = 5;

      System.out.println(numero1 / numero2); // 1.6
  }
}

O mesmo princípio vale para a operação de módulo (%).

Operadores de atribuição

Além do = básico, que utilizamos nos artigos anteriores para inicializar variáveis, o Java oferece versões combinadas com os operadores aritméticos:

+=: a += b (equivale a a = a + b)
-=: a -= b (equivale a a = a - b)
*=: a *= b (equivale a a = a * b)
/=: a /= b (equivale a a = a / b)
%=: a %= b (equivale a a = a % b)

public class Main {
  public static void main(String[] args) {
      double numero1 = 10;
      double numero2 = 5;

      numero1 += numero2;

      System.out.println(numero1); // 15
  }
}

Os demais operadores compostos funcionam da mesma forma: operam e atribuem o resultado à variável do lado esquerdo, poupando-nos de escrever numero1 = numero1 + numero2 por extenso.

Operadores relacionais

Comparam dois operandos e retornam sempre um valor boolean: true ou false.

==: igual a (exemplo: 5 == 8 retorna false)
!=: diferente de (exemplo: 5 != 8 retorna true)
>: maior que (exemplo: 5 > 8 retorna false)
<: menor que (exemplo: 5 < 8 retorna true)
>=: maior ou igual a (exemplo: 5 >= 8 retorna false)
<=: menor ou igual a (exemplo: 5 <= 8 retorna true)

public class Main {
  public static void main(String[] args) {
      double numero1 = 10;
      double numero2 = 5;

      System.out.println(numero1 == numero2); // false
      System.out.println(numero1 != numero2); // true
      System.out.println(numero1 > numero2);  // true
      System.out.println(numero1 < numero2);  // false
      System.out.println(numero1 >= numero2); // true
      System.out.println(numero1 <= numero2); // false
  }
}

Esses operadores também funcionam com char, comparando pelos respectivos códigos ASCII/Unicode, que você já aprendemos de relance na Parte 3, quando vimos a conversão de char para int.

Operadores lógicos

Usados para combinar mais de uma condição booleana. Existem três operadores lógicos principais em Java:

E (&&): uso idade >= 18 && idade <= 40. Resulta em true só se ambas as condições forem verdadeiras.
OU (||): uso estudante || associado. Resulta em true se pelo menos uma condição for verdadeira.
NÃO (!): uso !associado. Inverte o valor booleano.

public class Main {
  public static void main(String[] args) {
      int idade = 20;

      System.out.println(idade >= 18 && idade <= 40); // true
  }
}

public class Main {
  public static void main(String[] args) {
      boolean estudante = true;
      boolean associado = false;

      System.out.println(estudante || associado); // true
  }
}

public class Main {
  public static void main(String[] args) {
      boolean associado = true;

      System.out.println(associado);  // true
      System.out.println(!associado); // false
  }
}

Vale notar um detalhe de eficiência: no &&, se a primeira condição já for false, o Java nem avalia a segunda, já que o resultado já está decidido. No ||, se a primeira condição já for true, a segunda também não é avaliada. Esse comportamento é chamado de SHORT-CIRCUIT EVALUATION (avaliação de curto-circuito).

Operadores unários

Operadores que atuam sobre um único operando. Os dois mais comuns são incremento e decremento:

Incremento (++): soma 1 ao valor
Decremento (--): subtrai 1 do valor

public class Main {
  public static void main(String[] args) {
      int pontos = 95;
      int rodadas = 11;

      pontos++;
      rodadas--;

      System.out.println(pontos);  // 96
      System.out.println(rodadas); // 10
  }
}

Existe uma diferença sutil entre usar o operador como prefixo (++pontos) e como sufixo (pontos++). Ela só aparece quando ele é usado dentro de outra expressão, como um println:

public class Main {
  public static void main(String[] args) {
      int pontos = 95;

      System.out.println(pontos++); // imprime 95, depois incrementa
      System.out.println(pontos);   // 96
  }
}

public class Main {
  public static void main(String[] args) {
      int pontos = 95;

      System.out.println(++pontos); // incrementa primeiro, depois imprime 96
      System.out.println(pontos);   // 96
  }
}

No formato sufixo, o valor é usado antes de ser incrementado. No formato prefixo, o incremento acontece antes de o valor ser usado. Por essa razão, muita gente evita usar ++ ou -- diretamente dentro de outras expressões, preferindo fazer isso em uma linha separada. Assim fica claro qual valor está sendo impresso, sem precisar atentar-se à diferença entre prefixo e sufixo.

O que vem a seguir

Neste quarto artigo, aprendemos os cinco grupos de operadores mais usados no dia a dia com Java: aritméticos, de atribuição, relacionais, lógicos e unários. Com variáveis, tipos e operadores, nós já temos o vocabulário básico para começar a escrever expressões e pequenos cálculos em Java.

Na Parte 5 desta série, vamos trabalhar com um dos tipos de referência mais usados na linguagem: String, com o tópico "Como trabalhar com Strings em Java", cobrindo formatação, comparação, divisão e outras operações comuns sobre texto.

Até lá!

Este artigo é parte de uma série de introdução a Java escrita do zero, com progressão didática própria pensada para quem nunca programou na linguagem antes.

Artigos dessa série na DIO: