AFF Education Construa seu Futuro

Aula 25 - Operadores Relacionais

Operadores Relacionais

Os operadores relacionais são utilizados para comparar valores e retornar resultados booleanos (verdadeiro ou falso). São fundamentais para construir estruturas de decisão e controle de fluxo em programas.

Os principais operadores relacionais em Java são:

Exemplos Visuais de Comparações

Árvore A maior que Árvore B Homem B maior que Homem A Mulher B diferente de Mulher A

Exemplos de comparações:

Operadores Relacionais (maior que e menor que)

O Java tem operadores que comparam os números e fornecem resultados verdadeiro/falso. Podemos fazer a operação relacional dentro da atribuição de uma variável como mostrado abaixo.

public class OperadoresRelacionais {
    public static void main(String[] args) {
        // Declaração de variáveis
        int a = 10;
        int b = 5;
        
        // Comparações com operadores relacionais
        boolean maior = a > b;      // a é maior que b?
        boolean menor = a < b;      // a é menor que b?
        boolean maiorIgual = a >= b;// a é maior ou igual a b?
        boolean menorIgual = a <= b;// a é menor ou igual a b?
        
        // Exibindo resultados
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("a > b: " + maior);
        System.out.println("a < b: " + menor);
        System.out.println("a >= b: " + maiorIgual);
        System.out.println("a <= b: " + menorIgual);
        
        // Comparando com valores diretamente
        System.out.println("\nComparações diretas:");
        System.out.println("15 > 7: " + (15 > 7));
        System.out.println("15 < 7: " + (15 < 7));
        System.out.println("15 >= 15: " + (15 >= 15));
        System.out.println("15 <= 7: " + (15 <= 7));
    }
}

a = 10

b = 5

a > b: true

a < b: false

a >= b: true

a <= b: false


Comparações diretas:

15 > 7: true

15 < 7: false

15 >= 15: true

15 <= 7: false

Operadores Relacionais (atribuição fora da variável)

Também podemos fazer operações relacionais sem atribuir diretamente a uma variável, usando-as dentro de estruturas condicionais:

public class OperadoresRelacionaisFora {
    public static void main(String[] args) {
        // Declaração de variáveis
        int idade = 18;
        double altura = 1.75;
        
        // Usando operadores relacionais em estruturas condicionais
        if (idade >= 18) {
            System.out.println("É maior de idade");
        } else {
            System.out.println("É menor de idade");
        }
        
        if (altura > 1.80) {
            System.out.println("É alto");
        } else {
            System.out.println("Não é considerado alto");
        }
        
        // Operações relacionais com diferentes tipos de dados
        int numero1 = 100;
        long numero2 = 100L;
        
        // Comparando tipos diferentes (int e long)
        System.out.println("\nComparação de tipos diferentes:");
        System.out.println("numero1 == numero2: " + (numero1 == numero2));
        
        // Comparando ponto flutuante (tenha cuidado com precisão)
        double d1 = 0.1;
        double d2 = 0.1;
        double d3 = 0.1 + 0.1 + 0.1;
        double d4 = 0.3;
        
        System.out.println("\nComparação de ponto flutuante:");
        System.out.println("d1 == d2: " + (d1 == d2));           // true
        System.out.println("d3: " + d3);                         // 0.30000000000000004 (problema de precisão)
        System.out.println("d4: " + d4);                         // 0.3
        System.out.println("d3 == d4: " + (d3 == d4));           // false (devido à precisão)
        
        // Uma forma mais segura de comparar números de ponto flutuante
        final double EPSILON = 0.0001;  // Margem de erro aceitável
        boolean aproximadamenteIgual = Math.abs(d3 - d4) < EPSILON;
        System.out.println("d3 é aproximadamente igual a d4: " + aproximadamenteIgual);
    }
}

É maior de idade

Não é considerado alto


Comparação de tipos diferentes:

numero1 == numero2: true


Comparação de ponto flutuante:

d1 == d2: true

d3: 0.30000000000000004

d4: 0.3

d3 == d4: false

d3 é aproximadamente igual a d4: true

Dica importante: Ao comparar números de ponto flutuante (float ou double), evite usar o operador == diretamente. Devido a problemas de precisão, é melhor verificar se a diferença entre os valores é menor que uma pequena margem de erro (como mostrado no exemplo).

Tabela de Operadores Relacionais

Operador Nome Exemplo Resultado
> Maior que 10 > 5 true
< Menor que 10 < 5 false
>= Maior ou igual a 10 >= 10 true
<= Menor ou igual a 10 <= 5 false
== Igual a 10 == 10 true
!= Diferente de 10 != 5 true

Exercícios

Teste seus conhecimentos sobre operadores relacionais em Java:

1. Qual é o resultado da expressão (7 > 3 && 2 < 5)?

2. Qual operador relacional é usado para verificar se dois valores são diferentes?

3. O que acontece quando você compara dois números de ponto flutuante usando ==?

4. Qual será o resultado da expressão: 5 >= 5?

5. Complete o código para verificar se uma pessoa é adulta e tem altura mínima para um brinquedo:

int idade = 20;
double altura = 1.65;
boolean podeEntrar = ___________________;

Exercícios de Aplicação AFF Education

Reforce o conteúdo desta aula com mais dois exercícios práticos:

1. Qual o resultado da expressão 7 >= 7?

2. Sendo int a = 5, b = 9;, qual o valor de a != b?