Variáveis, Tipos Primitivos e Operadores em Java

Nesta lição, vamos aprender alguns conceitos fundamentais da programação em Java, combinando teoria e prática. Serão abordados:

Declaração e uso de variáveis – como criar e manipular variáveis em Java.
Tipos de dados primitivos – em especial int, double, char e boolean.
Operadores aritméticos, relacionais e lógicos – como realizar cálculos e comparações básicas.

Cada tópico incluirá explicações claras, exemplos de código e boas práticas. Ao final, propomos exercícios práticos para reforçar o conteúdo, seguidos de suas soluções comentadas.

Table of Contents

Declaração e Uso de Variáveis em Java

Em Java, uma variável é um espaço na memória do computador reservado para armazenar um dado que poderá ser usado no programa. Pense em uma variável como uma caixinha nomeada onde você guarda um valor para usar depois. Toda variável em Java tem um tipo (que define que espécie de dado ela guarda), um nome e um valor.

Declaração de variável: Para declarar uma variável, informamos o tipo e um nome válido. Por exemplo: int idade;. Isso cria uma variável chamada idade do tipo inteiro (int).

Inicialização (atribuição de valor): Podemos atribuir um valor à variável usando o operador de atribuição (=). Isso pode ser feito no momento da declaração ou em outra linha. Por exemplo: idade = 25; atribui o valor 25 à variável idade. É comum combinar declaração e inicialização em uma só linha: int idade = 25;.

// Declaração e posterior inicialização
int idade;
idade = 25;

// Declaração já com inicialização
int ano = 2025;

// Declaração e posterior inicialização

int idade;

idade = 25;

// Declaração já com inicialização

int ano = 2025;

Uso da variável: Uma vez declarada e inicializada, podemos utilizar a variável em expressões, cálculos, exibi-la na tela etc. Por exemplo, System.out.println(idade); exibirá o valor da variável idade no console.

Regras e Boas Práticas para Nomes de Variáveis

Use nomes descritivos que reflitam o propósito da variável (por exemplo, use saldoConta ao invés de x).
O nome de uma variável deve começar com letra (letra minúscula, por convenção). Pode conter letras, dígitos, $ ou _, mas não pode começar com dígito nem ter espaços.
Não use palavras reservadas da linguagem (como class, int, public) como nome de variável.
Siga o estilo camelCase – início em minúsculo e cada palavra interna com inicial maiúscula (ex: quantidadeItens).
Java diferencia maiúsculas de minúsculas (case-sensitive): Total e total são variáveis diferentes.
Sempre inicialize (atribua um valor) à variável antes de usá-la. Em Java, variáveis locais (dentro de métodos) não podem ser usadas sem inicialização – o compilador exigirá que tenham um valor antes do uso.

Exemplo de Declaração e Uso de Variáveis

Vamos declarar algumas variáveis com tipos diferentes e usar System.out.println para mostrar seus valores:

public class ExemploVariaveis {
    public static void main(String[] args) {
        int numero = 10;               // variável inteira
        double temperatura = 22.5;     // variável de ponto flutuante (decimal)
        char letra = 'C';              // variável caractere (aspas simples)
        boolean ligado = false;        // variável booleana (true ou false)

        System.out.println("Número: " + numero);
        System.out.println("Temperatura: " + temperatura);
        System.out.println("Letra: " + letra);
        System.out.println("Ligado? " + ligado);
    }
}

public class ExemploVariaveis {

public static void main(String[] args) {

int numero = 10; // variável inteira

double temperatura = 22.5; // variável de ponto flutuante (decimal)

char letra = 'C'; // variável caractere (aspas simples)

boolean ligado = false; // variável booleana (true ou false)

System.out.println("Número: " + numero);

System.out.println("Temperatura: " + temperatura);

System.out.println("Letra: " + letra);

System.out.println("Ligado? " + ligado);

}

Saída esperada:

Número: 10  
Temperatura: 22.5  
Letra: C  
Ligado? false

Número: 10

Temperatura: 22.5

Letra: C

Ligado? false

No exemplo acima, criamos quatro variáveis de tipos diferentes e imprimimos seus valores. Observe o uso de concatenação de strings ("Texto: " + variavel) para combinar texto e valores das variáveis na hora de exibir. Note também que valores do tipo char são colocados entre aspas simples ('C'), enquanto strings (que não são tipo primitivo) usam aspas duplas – por exemplo, "Ligado?" no código.

Tipos de Dados Primitivos

Java é uma linguagem fortemente tipada, ou seja, ao declarar uma variável precisamos especificar o tipo do dado que será armazenado. Os tipos de dados mais básicos são os tipos primitivos. Existem 8 tipos primitivos em Java, mas aqui focaremos nos quatro mais usados em um começo de aprendizagem:

int (inteiro): Armazena números inteiros, positivos ou negativos, sem parte decimal. Por exemplo: 0, 10, -7. É frequentemente usado para contagens, índices, idades, etc.
double (dupla precisão): Armazena números de ponto flutuante (decimais) com dupla precisão (64 bits). Por exemplo: 3.14, 0.5, -7.0. Use double para valores com casas decimais, como medições, resultados de cálculos fracionários, etc. (Obs: Java possui também o tipo float (32 bits) para decimais de simples precisão, mas double é mais comum por sua maior precisão.)
char (caractere): Armazena um único caractere Unicode (como uma letra, dígito ou símbolo). Exemplos: 'A', '7', '?'. Chars são delimitados por aspas simples. Internamente, um char é representado por um número inteiro que corresponde ao código Unicode do caractere, mas na prática o usamos para representar símbolos individuais.
boolean (lógico): Armazena um valor lógico: true (verdadeiro) ou false (falso). Booleans são usados em condições e controle de fluxo, indicando sim/não, ligado/desligado, etc.

Dica: além desses, Java tem outros tipos primitivos numéricos: byte, short, long (inteiros de tamanhos diferentes) e float (decimal de 32 bits). Porém, int e double costumam bastar na maioria dos casos iniciais. Escolha o tipo conforme o valor que precisa armazenar. Por exemplo, use int para contagem de pessoas (geralmente cabe em 32 bits), e double para um valor monetário ou cálculo científico que exige casas decimais.

Exemplos de declaração de variáveis primitivas:

int quantidade = 42;
double preco = 19.99;
char iniciais = 'J';
boolean ativo = true;

int quantidade = 42;

double preco = 19.99;

char iniciais = 'J';

boolean ativo = true;

No código acima, quantidade armazena um número inteiro 42, preco armazena 19.99 (um valor decimal, note o ponto indicando decimal), iniciais guarda o caractere 'J', e ativo guarda o valor booleano true. Esses valores podem ser usados em operações conforme seu tipo: por exemplo, podemos somar ou subtrair variáveis int e double, comparar valores char ou int, usar booleans em condições lógicas, etc.

Observação: Valores literais inteiros sem casa decimal são por padrão do tipo int. Valores com ponto decimal são considerados double por padrão (para usar um float, precisaríamos colocar um f ou F ao final, e para long usar um L, mas isso é detalhe adicional). Valores char devem ser colocados entre aspas simples, e valores booleanos são sempre as palavras reservadas true ou false.

Operadores Aritméticos, Relacionais e Lógicos

Operadores são símbolos especiais que realizam operações sobre valores (operandos). Veremos três categorias importantes de operadores em Java:

Operadores aritméticos – servem para realizar cálculos matemáticos básicos.
Operadores relacionais – permitem comparar valores.
Operadores lógicos – permitem combinar expressões booleanas (verdadeiro/falso).

Vamos explorar cada categoria:

Operadores Aritméticos

Os principais operadores aritméticos em Java são:

+ (adição): soma dois valores. Ex: 5 + 3 resulta em 8.
- (subtração): subtrai o segundo valor do primeiro. Ex: 5 - 3 resulta em 2.
* (multiplicação): multiplica dois valores. Ex: 5 * 3 resulta em 15.
/ (divisão): divide o primeiro valor pelo segundo. Ex: 6 / 2 resulta em 3. Atenção: se ambos os operandos forem inteiros, a divisão inteira descarta qualquer parte fracionária (por exemplo, 7 / 2 resulta em 3, não 3.5). Para obter divisão com decimal, pelo menos um operando deve ser double (por exemplo, 7.0 / 2 resulta em 3.5).
% (módulo ou resto): calcula o resto da divisão inteira do primeiro pelo segundo. Ex: 7 % 2 resulta em 1 (já que 7 dividido por 2 é 3 com resto 1). Este operador é útil para saber se um número é par ou ímpar (x % 2 == 0 indica par), por exemplo.

Além desses, existem os operadores de incremento (++) e decremento (--), que aumentam ou diminuem em 1 o valor da variável respectivamente. Por exemplo, se a = 5, então a++ resulta em a = 6. Estes são atalho úteis, mas é importante entender primeiro os operadores básicos listados acima.

Exemplo de uso de operadores aritméticos:

int a = 7, b = 3;
System.out.println("a + b = " + (a + b));        // soma -> 10
System.out.println("a - b = " + (a - b));        // subtração -> 4
System.out.println("a * b = " + (a * b));        // multiplicação -> 21
System.out.println("a / b = " + (a / b));        // divisão inteira -> 2
System.out.println("a % b = " + (a % b));        // resto da divisão -> 1

// Divisão com decimais
double resultado =  (double) a / b;
System.out.println("a / b (como double) = " + resultado);  // -> 2.333...

int a = 7, b = 3;

System.out.println("a + b = " + (a + b)); // soma -> 10

System.out.println("a - b = " + (a - b)); // subtração -> 4

System.out.println("a * b = " + (a * b)); // multiplicação -> 21

System.out.println("a / b = " + (a / b)); // divisão inteira -> 2

System.out.println("a % b = " + (a % b)); // resto da divisão -> 1

// Divisão com decimais

double resultado = (double) a / b;

System.out.println("a / b (como double) = " + resultado); // -> 2.333...

Note no exemplo acima:

O resultado de a / b com ambos a e b inteiros é 2 (já que 7/3 = 2 com resto 1, parte fracionária descartada).
Ao converter a para double (fazendo (double) a), a divisão passa a considerar decimais e o resultado é aproximadamente 2.3333.
Sempre que possível, use parênteses para deixar claro a ordem das operações, principalmente na hora de concatenar na System.out.println. Por exemplo, escrevemos "a + b = " + (a + b) para somar a + b primeiro, antes de concatenar com a string.

Boas práticas: Tenha cuidado com divisão por zero – se b fosse 0 em a / b, o programa lançaria um erro (ArithmeticException). Nunca tente dividir por zero. Além disso, ao lidar com números decimais, lembre-se de que o tipo double pode introduzir pequenas imprecisões em cálculos devido à forma de representação em ponto flutuante. Isso geralmente não é um problema para usos simples, mas é bom ter em mente.

Operadores Relacionais

Operadores relacionais comparam dois valores e produzem um resultado booleano (true ou false). São usados para tomar decisões, por exemplo dentro de estruturas condicionais (que serão vistas em aulas futuras), mas podemos já entender seu funcionamento. Os principais operadores relacionais em Java são:

== (igual a): verifica se dois valores são iguais. Ex: 5 == 5 resulta true; 5 == 3 resulta false.
!= (diferente de): verifica se dois valores são diferentes. Ex: 5 != 3 resulta true; 5 != 5 resulta false.
> (maior que): verifica se o primeiro valor é maior que o segundo. Ex: 7 > 3 é true; 3 > 7 é false.
< (menor que): verifica se o primeiro valor é menor que o segundo. Ex: 3 < 7 é true; 7 < 3 é false.
>= (maior ou igual): verifica se o primeiro valor é maior ou igual ao segundo. Ex: 5 >= 5 é true; 5 >= 6 é false.
<= (menor ou igual): verifica se o primeiro valor é menor ou igual ao segundo. Ex: 5 <= 6 é true; 5 <= 4 é false.

Importante: Não confunda o operador relacional de igualdade == com o operador de atribuição =. O primeiro compara valores, o segundo atribui um valor a uma variável. Por exemplo, a = 5; atribui 5 a a, enquanto a == 5 verifica se a é igual a 5.

Exemplo de uso de operadores relacionais (produzem valores booleanos):

int x = 5;
int y = 8;
System.out.println("x == y? " + (x == y));  // false, porque 5 não é igual a 8
System.out.println("x != y? " + (x != y));  // true, 5 é diferente de 8
System.out.println("x > y? "  + (x > y));   // false, 5 não é maior que 8
System.out.println("x < y? "  + (x < y));   // true, 5 é menor que 8

int x = 5;

int y = 8;

System.out.println("x == y? " + (x == y)); // false, porque 5 não é igual a 8

System.out.println("x != y? " + (x != y)); // true, 5 é diferente de 8

System.out.println("x > y? " + (x > y)); // false, 5 não é maior que 8

System.out.println("x < y? " + (x < y)); // true, 5 é menor que 8

Cada expressão relacional acima resultará em true ou false. Por exemplo, x < y é verdadeiro porque 5 é de fato menor que 8.

Operadores Lógicos

Operadores lógicos operam sobre valores booleanos (verdadeiro/falso) e permitem construir expressões lógicas mais complexas, combinando condições. Em Java temos três operadores lógicos principais:

&& (E lógico, AND): resulta true somente se ambos os operandos forem true. Ex: (cond1 && cond2) é verdadeiro se cond1 for verdadeiro e cond2 for verdadeiro.
|| (OU lógico, OR): resulta true se pelo menos um dos operandos for true. Ex: (cond1 || cond2) é verdadeiro se cond1 for verdadeiro ou cond2 for verdadeiro (ou ambos). Só é false se ambos forem falsos.
! (não lógico, NOT): é o operador de negação. Inverte o valor booleano da expressão ou variável à direita dele. Ex: !cond1 é true se cond1 for false (e vice-versa).

Estes operadores são normalmente usados em conjunto com os relacionais para formar condições. Por exemplo, para verificar se uma pessoa pode dirigir legalmente: ela precisa ter idade >= 18 e possuir carteira de motorista. Podemos representar essa lógica como:

int idade = 20;
boolean temCarteira = true;
boolean podeDirigir = (idade >= 18) && (temCarteira == true);
System.out.println("Pode dirigir? " + podeDirigir); // true, pois 20 >= 18 e temCarteira é true

int idade = 20;

boolean temCarteira = true;

boolean podeDirigir = (idade >= 18) && (temCarteira == true);

System.out.println("Pode dirigir? " + podeDirigir); // true, pois 20 >= 18 e temCarteira é true

No exemplo, (idade >= 18) é uma expressão relacional que resulta em true (20 é maior ou igual a 18). temCarteira == true verifica se temCarteira é verdadeiro (nesse caso é true). Ambos os resultados sendo true, o operador && retorna true. Assim, podeDirigir será true. Se qualquer uma das condições fosse falsa (menor de 18 ou não ter carteira), podeDirigir seria false.

Também podemos usar || para situações onde basta uma das condições ser verdadeira. Por exemplo, suponha que um evento aceita meia-entrada se a pessoa for estudante ou tiver menos de 21 anos:

boolean estudante = false;
int idadePessoa = 19;
boolean meiaEntrada = estudante || (idadePessoa < 21);
System.out.println("Tem direito à meia-entrada? " + meiaEntrada); // true, pois idadePessoa < 21

boolean estudante = false;

int idadePessoa = 19;

boolean meiaEntrada = estudante || (idadePessoa < 21);

System.out.println("Tem direito à meia-entrada? " + meiaEntrada); // true, pois idadePessoa < 21

Aqui usamos ||: mesmo não sendo estudante, a expressão toda é true porque a segunda condição (idade < 21) é verdadeira.

Resumo: Os operadores lógicos permitem combinar condições: use && quando todas as condições devem ser verdadeiras, || quando pelo menos uma deve ser verdadeira, e ! para negar/inverter uma condição. Lembre-se de usar parênteses para clarificar agrupamentos lógicos em expressões complexas.

Observação: Java também possui operadores bitwise (&, |, ^) que operam a nível de bits, mas para condições booleanas usuais, utilize && e ||, que têm também a propriedade de curto-circuito (eles não avaliam a segunda condição se não for necessário – por exemplo, em cond1 && cond2, se cond1 for false, o resultado já será false sem avaliar cond2). Esses detalhes serão mais importantes ao aprofundar em lógica de programação.

Exercícios Práticos

Agora vamos praticar os conceitos aprendidos. Tente resolver os exercícios abaixo escrevendo pequenos programas em Java. Em seguida, compare sua solução com o gabarito e explicações fornecidos.

1. Variáveis e Tipos: Crie um programa que declare e inicialize quatro variáveis, uma de cada um dos tipos: int, double, char e boolean. Escolha nomes significativos e atribua valores de exemplo a elas. Em seguida, use System.out.println para exibir cada uma das variáveis na tela, juntamente com um texto explicativo. (Dica: você pode se basear no exemplo dado durante a explicação de variáveis.)

2. Operadores Aritméticos: Escreva um programa que declare duas variáveis inteiras a e b, atribua valores a elas, e calcule os resultados das operações básicas entre essas variáveis. O programa deve exibir: a soma a + b, a diferença a - b, o produto a * b, a divisão inteira a / b e o resto da divisão a % b. Teste seu programa com diferentes valores de a e b (por exemplo, a maior que b, a menor que b, valores positivos e negativos) para verificar os resultados. Observe especialmente o resultado da divisão inteira.

3. Operadores Relacionais e Lógicos: Faça um programa que:
a. Declare duas variáveis int chamadas x e y, atribua a elas dois valores à sua escolha. Em seguida, exiba no console o resultado das comparações: x == y, x != y, x > y, x < y, x >= y e x <= y. Cada comparação deve imprimir o valor booleano resultante.
b. Declare duas variáveis booleanas, por exemplo cond1 e cond2, e atribua a elas valores true ou false (à sua escolha). Então imprima os resultados das operações lógicas: cond1 && cond2, cond1 || cond2 e !cond1. Observe e entenda cada resultado impresso, relacionando com a teoria dos operadores lógicos.

Tente escrever cada programa por conta própria antes de ver as respostas a seguir. Isso reforçará o entendimento. Bons códigos!

Gabarito e Explicação dos Exercícios

A seguir apresentamos soluções possíveis para cada exercício, acompanhadas de comentários e observações.

Exercício 1: Uma possível solução é declarar as variáveis dentro do método main de uma classe Java e usar System.out.println para imprimir seus valores. Por exemplo:

public class Exercicio1 {
    public static void main(String[] args) {
        int idade = 28;
        double altura = 1.75;
        char inicialNome = 'A';
        boolean estudante = true;

        System.out.println("Idade: " + idade);
        System.out.println("Altura: " + altura + " metros");
        System.out.println("Inicial do nome: " + inicialNome);
        System.out.println("É estudante? " + estudante);
    }
}

public class Exercicio1 {

public static void main(String[] args) {

int idade = 28;

double altura = 1.75;

char inicialNome = 'A';

boolean estudante = true;

System.out.println("Idade: " + idade);

System.out.println("Altura: " + altura + " metros");

System.out.println("Inicial do nome: " + inicialNome);

System.out.println("É estudante? " + estudante);

}

Explicação: Declaramos uma variável idade do tipo int com valor 28, uma altura do tipo double com valor 1.75, inicialNome do tipo char com a letra ‘A’, e estudante do tipo boolean com valor true. Em seguida, usamos System.out.println para exibir cada variável. A saída será algo como:

Idade: 28  
Altura: 1.75 metros  
Inicial do nome: A  
É estudante? true

Idade: 28

Altura: 1.75 metros

Inicial do nome: A

É estudante? true

Perceba que concatenamos textos descritivos com os valores das variáveis para tornar a saída legível. Você poderia ter escolhido qualquer valores para as variáveis; o importante era praticar a declaração de cada tipo e a impressão dos valores. Também note que na linha da altura concatenamos a palavra “metros” para indicar a unidade, e para o booleano escrevemos uma pergunta para contextualizar (É estudante?).

Exercício 2: Uma solução exemplificativa é:

public class Exercicio2 {
    public static void main(String[] args) {
        int a = 15;
        int b = 4;

        // operações aritméticas
        int soma         = a + b;
        int diferenca    = a - b;
        int produto      = a * b;
        int divisaoInt   = a / b;
        int restoDiv     = a % b;

        System.out.println("Para a = " + a + " e b = " + b + ":");
        System.out.println("a + b = " + soma);
        System.out.println("a - b = " + diferenca);
        System.out.println("a * b = " + produto);
        System.out.println("a / b = " + divisaoInt + " (divisão inteira)");
        System.out.println("a % b = " + restoDiv + " (resto da divisão)");
    }
}

public class Exercicio2 {

public static void main(String[] args) {

int a = 15;

int b = 4;

// operações aritméticas

int soma = a + b;

int diferenca = a - b;

int produto = a * b;

int divisaoInt = a / b;

int restoDiv = a % b;

System.out.println("Para a = " + a + " e b = " + b + ":");

System.out.println("a + b = " + soma);

System.out.println("a - b = " + diferenca);

System.out.println("a * b = " + produto);

System.out.println("a / b = " + divisaoInt + " (divisão inteira)");

System.out.println("a % b = " + restoDiv + " (resto da divisão)");

}

Explicação: Declaramos a e b com alguns valores inteiros (no exemplo, 15 e 4). Calculamos soma, diferença, produto, divisão inteira e resto, armazenando cada resultado em variáveis separadas apenas para clareza (poderíamos imprimir diretamente as expressões também). A saída do programa acima seria:

Para a = 15 e b = 4:  
a + b = 19  
a - b = 11  
a * b = 60  
a / b = 3 (divisão inteira)  
a % b = 3 (resto da divisão)

Para a = 15 e b = 4:

a + b = 19

a - b = 11

a * b = 60

a / b = 3 (divisão inteira)

a % b = 3 (resto da divisão)

Observe os resultados: 15 + 4 = 19; 15 – 4 = 11; 15 * 4 = 60. Na divisão inteira, 15 / 4 resulta em 3, pois 15 dividido por 4 é 3 com resto 3 (o valor decimal .75 é descartado na divisão de inteiros). O resto da divisão (15 % 4) é 3, confirmando que 15 = 4*3 + 3.

Se você testar com outros valores, verá, por exemplo, que se a for menor que b, a subtração ficará negativa. Se a ou b forem negativos, os resultados se ajustam conforme as regras matemáticas (ex.: se a = -7 e b = 2, então a + b = -5, a / b = -3 pois -7/2 = -3 truncado, e a % b = -1 em Java porque -7 = (-3)*2 + -1). O importante é entender o comportamento de cada operador. Caso b fosse 0, a operação a / b não é válida (divisão por zero) e geraria um erro em tempo de execução.

Exercício 3: Uma implementação possível para as duas partes é:

public class Exercicio3 {
    public static void main(String[] args) {
        // Parte a: operadores relacionais
        int x = 10;
        int y = 8;
        System.out.println("x = " + x + ", y = " + y);
        System.out.println("x == y ? " + (x == y));  // false
        System.out.println("x != y ? " + (x != y));  // true
        System.out.println("x > y ? "  + (x > y));   // true
        System.out.println("x < y ? "  + (x < y));   // false
        System.out.println("x >= y ? " + (x >= y));  // true
        System.out.println("x <= y ? " + (x <= y));  // false

        // Parte b: operadores lógicos
        boolean cond1 = true;
        boolean cond2 = false;
        System.out.println("cond1 = " + cond1 + ", cond2 = " + cond2);
        System.out.println("cond1 && cond2 = " + (cond1 && cond2)); // false
        System.out.println("cond1 || cond2 = " + (cond1 || cond2)); // true
        System.out.println("!cond1 = " + (!cond1));                 // false
    }
}

public class Exercicio3 {

public static void main(String[] args) {

// Parte a: operadores relacionais

int x = 10;

int y = 8;

System.out.println("x = " + x + ", y = " + y);

System.out.println("x == y ? " + (x == y)); // false

System.out.println("x != y ? " + (x != y)); // true

System.out.println("x > y ? " + (x > y)); // true

System.out.println("x < y ? " + (x < y)); // false

System.out.println("x >= y ? " + (x >= y)); // true

System.out.println("x <= y ? " + (x <= y)); // false

// Parte b: operadores lógicos

boolean cond1 = true;

boolean cond2 = false;

System.out.println("cond1 = " + cond1 + ", cond2 = " + cond2);

System.out.println("cond1 && cond2 = " + (cond1 && cond2)); // false

System.out.println("cond1 || cond2 = " + (cond1 || cond2)); // true

System.out.println("!cond1 = " + (!cond1)); // false

}

Explicação:

Parte a: Definimos x = 10 e y = 8. As comparações resultam em:
- x == y é false porque 10 não é igual a 8.
- x != y é true porque 10 de fato é diferente de 8.
- x > y é true (10 é maior que 8).
- x < y é false (10 não é menor que 8).
- x >= y é true (10 é maior ou igual a 8; aqui é maior).
- x <= y é false (10 não é menor ou igual a 8).
Essas linhas imprimem o resultado booleano de cada comparação. Notar que concatenamos as expressões com strings como "x == y ? " para deixar claro o que está sendo exibido. Os comentários // indicam o valor esperado de cada expressão, mas o programa em si exibirá true ou false.
Parte b: Definimos cond1 = true e cond2 = false. Então:
- cond1 && cond2 avalia para false porque embora cond1 seja true, cond2 é false – para o E lógico (&&) resultar true, ambos teriam que ser true.
- cond1 || cond2 avalia para true porque pelo menos um dos dois operandos (cond1) é true – no OU lógico basta um ser verdadeiro.
- !cond1 avalia para false porque cond1 era true e o operador ! inverte o valor.
A saída deixa claro os valores de cond1 e cond2 e o resultado de cada operação lógica. Por exemplo, a linha do OU lógico poderia mostrar algo como “cond1 || cond2 = true” dado os valores escolhidos.

Você pode testar diferentes combinações de verdadeiros e falsos em cond1 e cond2 para ver os efeitos: se ambos fossem true, cond1 && cond2 daria true; se ambos fossem false, cond1 || cond2 daria false, e assim por diante. O importante é confirmar na prática a tabela verdade dos operadores lógicos.

Com a prática desses exercícios, você deve ter fortalecido sua compreensão sobre declaração de variáveis, escolha de tipos adequados e uso dos operadores básicos em Java. Esses fundamentos serão muito úteis nas próximas lições, onde construiremos estruturas de controle (como condições if/else) e algoritmos mais complexos usando essas bases. Continue praticando e experimentando variações dos exemplos – a programação se aprende, sobretudo, escrevendo código! Boa codificação.