5.1. O tipo primitivo boolean

O tipo das expressões cujo valor é verdade ou falso é o tipo de dados boolean.

Enquanto que os conjuntos de valores definidos pelos tipos int e double, por exemplo, são muito grandes, o conjunto de valores do tipo boolean tem somente dois elementos {true, false}.

Os literais deste tipo são, portanto, somente true e false.

As operações que podemos fazer com operandos do tipo boolean são: conjunção, com o operador &&, disjunção, com o operador ||, e negação, com o operador !. Estes três operadores chamam-se operadores lógicos e têm operandos e resultado do tipo boolean.

O significado, ou semântica, dos operadores lógicos é o mesmo que aprendeu na lógica matemática:

• a conjunção só é verdadeira se ambos os operandos forem verdadeiros (nos outros casos é falsa);
• a disjunção só é falsa se ambos os operandos forem falsos (nos outros casos é verdadeira);
• a negação é falsa se o operando é verdadeiro e vice-versa.

As seguintes instruções imprimem os valores false, true e false no ecrã:

xxxxxxxxxx
    boolean a = true;
    boolean b = false;
    System.out.println(a && b);
    System.out.println(a || b);
    System.out.println(!a);

Temos ainda os seguintes operadores relacionais que, embora não tenham operandos do tipo boolean, têm resultado do tipo boolean. São eles >, <, >=, <=, == e !=.

Sendo expr1 e expr2 duas expressões de um mesmo tipo numérico (int ou double, para já), a semântica dos seguintes operadores relacionais é a esperada:

xxxxxxxxxx
expr1 > expr2        // o valor de expr1 eh maior que o de expr2
expr1 < expr2        // o valor de expr1 eh menor que o de expr2
expr1 >= expr2       // o valor de expr1 eh maior ou igual que o de expr2
expr1 <= expr2       // o valor de expr1 eh menor ou igual que o de expr2

Os dois operadores seguintes são também operadores relacionais que podem ter operandos de tipos numéricos, boolean ou de outros tipos. O resultado é do tipo boolean.

xxxxxxxxxx
expr1 == expr2        // o valor de expr1 eh igual ao de expr2
expr1 != expr2        // o valor de expr1 eh diferente do de expr2

Estes operadores == e != também operam sobre strings mas o resultado não é o esperado (mais sobre isto adiante).

Estas expressões, sendo do tipo boolean, podem constituir operandos para os operadores lógicos.

Por exemplo,

• a expressão x > 0 && x < 10 é true só se x é maior que zero e x é menor que 10
• a expressão x > 0 || x % 3 == 0 é true sempre que x é maior que zero ou x é divisível por 3
• a expressão !(x <= 0) é true se x <= 0 é false, ou seja, se x é positivo
• dada uma variável x do tipo double, a expressão x >= 3.5 && x < 4.8 tem o valor true se x está no intervalo [3.5,4.8[.

O seguinte programa imprime os valores true, false, true, true, false, false, true e false no ecrã:

​x
public class Expressions4 {
​
    public static void main (String [] args) {
​
       int i = 2;
       int j = 6;
       System.out.println(i + 3 < i * 3);
       System.out.println(i == j);
       System.out.println(i + 4 == j);
​
       // o resultado de um operador relacional eh boolean, portanto
       // pode ser guardado numa variavel de tipo boolean
       boolean expr = i <= j + 3;
       System.out.println(expr);
       System.out.println(expr && i != 2);
       System.out.println(i <= 2 && j <= 2);
       System.out.println(i <= 2 || j <= 2);
       System.out.println(!(i <= 2 || j <= 2));
    }
}

NOTA: um erro comum que se comete no início da aprendizagem é usar = em vez de == para exprimir o operador de igualdade. Lembre-se que = é a instrução de atribuição!

No que diz respeito à prioridade das operações, os operadores relacionais têm todos a mesma prioridade e são associativos à esquerda (por isso quando há vários numa expressão, são avaliados da esquerda para a direita).

Como pode ver no quadro das prioridades do Capítulo 3, a prioridade dos operadores relacionais é menor que, por exemplo, a dos operadores aritméticos (por isso na expressão i <= j + 3 a soma é avaliada antes do operador <=).

Os operadores lógicos não têm todos a mesma prioridade – a negação é o que tem maior prioridade, seguido da conjunção; a disjunção é, desses operadores, o que tem menor prioridade. Para que a negação não seja avaliada em primeiro lugar, na expressão !(i <= 2 || j <= 2) usamos parêntesis à volta da expressão que queremos negar. Se os parêntesis não estivessem lá, a primeira operação a ser avaliada seria !i, o que não é legal pois i não é do tipo boolean.

Como qualquer tipo de dados, também o tipo boolean pode servir para tipo de retorno de uma função. Por exemplo, o seguinte programa imprime os valores true, false e true no ecrã:

xxxxxxxxxx
public class ExemploFuncaoBoolean {
​
    public static void main (String [] args) {
​
       int i = 2;
       int j = 7;
       System.out.println(ehPar(i));
       System.out.println(ehPar(j));
       System.out.println(ehPar(i * j));
    }
​
    /**
      * Um numero inteiro eh par?
      * @param num
      * @return true se num eh par; false caso contrario
      */
     static boolean ehPar(int num) {
        return num % 2 == 0;
     }
}

Repare na única instrução da função ehPar. É a instrução de retorno da função que, como já referido, calcula a expressão à direita da palavra return e termina a execução do método devolvendo como resultado o valor dessa expressão.

A expressão num % 2 == 0 é do tipo boolean pois o seu resultado só poderá ser true ou false. Esta expressão tem o valor true quando o resto da divisão de num por 2 é zero, ou seja, quando num é par.

Então, o valor devolvido pela função é true se num é par e false se num não é par.

Anterior: 5. O tipo de dados boolean e comandos condicionais

Seguinte: 5.2. Execução condicional