Como Verificar se uma Variável Booleana é Falsa em Java - Tutorial e Exemplos

Introdução

Neste laboratório, você aprenderá como verificar se uma variável booleana é false em Java. Exploraremos técnicas fundamentais para trabalhar com valores booleanos, que são essenciais para controlar o fluxo do programa com base em condições.

Através de exemplos práticos, você praticará o uso do operador de igualdade (==) para verificar false, testar com objetos Boolean e combinar verificações para condições tanto true quanto false. Ao final deste laboratório, você terá uma sólida compreensão de como utilizar efetivamente variáveis booleanas em seus programas Java.

Usar o Operador de Igualdade para Verificação de Falso

Nesta etapa, exploraremos como verificar se uma variável booleana é false usando o operador de igualdade (==) em Java. Compreender como trabalhar com valores booleanos é fundamental na programação, pois eles são usados para controlar o fluxo de seus programas com base em condições.

Uma variável booleana pode conter um de dois valores: true ou false. Esses valores são frequentemente o resultado de uma comparação ou uma operação lógica.

Vamos criar um programa Java simples para demonstrar a verificação de false.

Abra o arquivo HelloJava.java no editor WebIDE, caso ele ainda não esteja aberto.
Substitua o código existente pelo seguinte:
```
public class HelloJava {
    public static void main(String[] args) {
        boolean isComplete = false;

        if (isComplete == false) {
            System.out.println("The task is not complete.");
        }
    }
}
```
Vamos analisar as novas partes:
- boolean isComplete = false;: Esta linha declara uma variável booleana chamada isComplete e a inicializa com o valor false.
- if (isComplete == false): Esta é uma instrução if, que é usada para executar um bloco de código somente se uma determinada condição for verdadeira. A condição aqui é isComplete == false. O operador == verifica se o valor de isComplete é igual a false.
- System.out.println("The task is not complete.");: Esta linha será executada somente se a condição isComplete == false for verdadeira.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa usando o comando javac no Terminal:
```
javac HelloJava.java
```
Se não houver erros, você não verá nenhuma saída.
Execute o programa compilado usando o comando java:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
The task is not complete.
```
Esta saída confirma que a condição isComplete == false foi de fato verdadeira, e o código dentro do bloco if foi executado.

Usar o operador de igualdade (==) para verificar se um booleano é false é uma maneira direta de expressar essa condição. Na próxima etapa, exploraremos outra maneira de verificar o valor false.

Testar com Objeto Boolean

Na etapa anterior, trabalhamos com um tipo booleano primitivo. Java também possui uma classe correspondente chamada Boolean, que é um wrapper de objeto para o tipo booleano primitivo. Embora você frequentemente use o tipo primitivo, é útil saber sobre o objeto Boolean, especialmente ao trabalhar com coleções ou métodos que exigem objetos.

Nesta etapa, veremos como verificar o valor false ao usar um objeto Boolean.

Abra o arquivo HelloJava.java no editor WebIDE.
Substitua o código atual pelo seguinte:
```
public class HelloJava {
    public static void main(String[] args) {
        Boolean isProcessed = Boolean.FALSE;

        if (isProcessed.equals(false)) {
            System.out.println("The item has not been processed.");
        }
    }
}
```
Vamos analisar as mudanças:
- Boolean isProcessed = Boolean.FALSE;: Esta linha declara um objeto Boolean chamado isProcessed e o inicializa com a constante estática Boolean.FALSE, que representa o valor booleano false.
- if (isProcessed.equals(false)): Ao trabalhar com objetos em Java, geralmente é recomendado usar o método equals() para comparar seus valores, em vez do operador ==. O método equals() da classe Boolean verifica se o valor booleano do objeto é igual ao valor booleano passado como argumento.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa usando javac no Terminal:
```
javac HelloJava.java
```
Novamente, nenhuma saída significa compilação bem-sucedida.
Execute o programa usando java:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
The item has not been processed.
```
Isso mostra que o método equals() identificou corretamente que o objeto Boolean isProcessed contém o valor booleano false.

Embora usar == false com booleanos primitivos seja comum e perfeitamente aceitável, usar .equals(false) é a maneira padrão de comparar objetos Boolean. Compreender a diferença entre tipos primitivos e seus wrappers de objeto é um conceito importante em Java.

Combinar Verificações True e False

Na programação do mundo real, você frequentemente precisará verificar múltiplas condições simultaneamente. Isso envolve combinar verificações para valores true e false usando operadores lógicos como && (AND - E) e || (OR - OU).

Nesta etapa, modificaremos nosso programa para incluir verificações para condições true e false.

Abra o arquivo HelloJava.java no editor WebIDE.
Substitua o código atual pelo seguinte:
```
public class HelloJava {
    public static void main(String[] args) {
        boolean isTaskStarted = true;
        boolean isTaskFinished = false;

        if (isTaskStarted == true && isTaskFinished == false) {
            System.out.println("The task has started but is not finished.");
        }

        if (isTaskStarted == false || isTaskFinished == true) {
             System.out.println("The task is either not started or is already finished.");
        }
    }
}
```
Vamos detalhar o novo código:
- boolean isTaskStarted = true;: Declaramos uma variável booleana isTaskStarted e a definimos como true.
- boolean isTaskFinished = false;: Declaramos outra variável booleana isTaskFinished e a definimos como false.
- if (isTaskStarted == true && isTaskFinished == false): Esta instrução if usa o operador lógico AND (&&). O código dentro deste bloco será executado somente se ambas as condições forem verdadeiras: isTaskStarted é true E isTaskFinished é false.
- if (isTaskStarted == false || isTaskFinished == true): Esta instrução if usa o operador lógico OR (||). O código dentro deste bloco será executado se pelo menos uma das condições for verdadeira: isTaskStarted é false OU isTaskFinished é true.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa usando javac no Terminal:
```
javac HelloJava.java
```
Execute o programa usando java:
```
java HelloJava
```
Com base nos valores iniciais de isTaskStarted e isTaskFinished, você deve ver a seguinte saída:
```
The task has started but is not finished.
```
A primeira condição if (true && false) é avaliada como false, então o primeiro println é executado. A segunda condição if (true || false) é avaliada como true, então o segundo println é executado.

Espere, a saída é apenas "The task has started but is not finished."? Vamos reavaliar as condições:
- isTaskStarted == true && isTaskFinished == false: true == true é true, false == false é true. true && true é true. Então a primeira mensagem imprime.
- isTaskStarted == false || isTaskFinished == true: true == false é false, false == true é false. false || false é false. Então a segunda mensagem não imprime.
Minhas desculpas, a saída esperada é de fato apenas a primeira linha. Isso demonstra como os operadores lógicos funcionam para combinar condições.

Você pode experimentar alterando os valores iniciais de isTaskStarted e isTaskFinished e executando o programa novamente para ver como a saída muda.

Combinar verificações booleanas com operadores lógicos é uma maneira poderosa de controlar o fluxo de seus programas e tomar decisões com base em múltiplos fatores.

Resumo

Neste laboratório, aprendemos como verificar se uma variável booleana é false em Java. Começamos usando o operador de igualdade (==) para comparar uma variável booleana diretamente com o literal false. Isso demonstrou a maneira fundamental de verificar uma condição falsa e controlar o fluxo do programa usando uma instrução if. Em seguida, testamos esse conceito com um programa Java simples, compilando-o e executando-o para observar a saída esperada quando a variável booleana era de fato false.