Materiais, Manuais e Tutoriais>JAVA>Comandos condicionais

Comandos condicionais

Operadores Lógicos

 

Operador Descrição
> Maior que
< Menor que
>= Maior ou igual
<= Menor ou igual
== Igual
!= Diferente
! Negação
&& E
|| Ou

 

Os operadores lógicos são utilizados em expressões lógicas que sempre tem como resposta verdadeiro ou falso (true ou false). Utilizamos os mesmos quando queremos saber se um valor é maior que outro, se uma variável é igual a outra, se o resultado de um cálculo é diferente de outro, etc.

Geralmente utilizamos expressões lógicas dentro do comando "if" que significa "se". Veja um exemplo:

Supondo que em nosso algoritmo tivesse uma variavel chamada idade, onde gostariamos de exibir na tela a mensagem "Você é maior de idade" caso o valor desta variável fosse maior ou igual a 18. O algoritmo seria o seguinte:

if(idade>=18){
    System.out.println("Você é maior de idade");
}

 

Perceba que as instruções que estiverem entre as chaves de abertura e fechamento de um if  "{...}" só serão executadas SE o resultado da expressão for verdadeiro. Exemplo:

if(expressão){
   //instruções que só serão executadas se a "expressão" do if for verdadeira
}

E se você quisesse executar determinadas instruções caso o resultado da expressão fosse falso? Neste caso temos o comando "else" que significa "senão". O comando else só pode existir se existir um if, se no nosso exemplo quisessemos mostrar a mensagem "Você é menor de idade" caso a idade NÂO fosse maior ou igual a 18, o algoritmo ficaria assim:

if(idade>=18){
    System.out.println("Você é maior de idade");
}
else{
   System.out.println("Você é menor de idade");
}

Traduzindo para o português o algoritmo seria assim:

 

se(idade maior ou igual a 18){
   escreve("Você é maior de idade");
}
senão{
   escreve("Você é menor de idade");
}

 

E se tivessemos 3 possibilidades? Os maiores de idade, os menores de idade e os idosos?

Eventualmente poderemos ter inúmeras possibilidades e quando isso acontecer usaremos o comando "else if()" que significa "senão se". Exemplo:

 

if(idade>=60){
   System.out.println("Você é idoso");
}
else if(idade<18){
   System.out.println("Você é menor de idade");
}
else{
   System.out.println("Você é maior de idade");
}

 

Em português:

 

se(idade maior ou igual a 60){
   escreve("Você é idoso");
}
senão se(idade menor ou igual a 18){
   escreve("Você é menor de idade");
}
senão{
   escreve("Você é maior de idade");
}

 

Para uso dos comandos condicionais, algumas regras devem ser observadas:

1 - Todo bloco de condições começa com um if.

2 - Para todo else deve existir um if.

3 - Para todo else if também deve existir um if

4 - O programa interpreta um bloco de condições de cima para baixo, quando a primeira condição for verdadeira todas as demais são ignoradas.

5 - Nem todo if terá else if ou else.

Veja alguns exemplos:

 

//Bloco de condições
if(expressão){
   //Entrará aqui sempre que a expressão do if for verdadeira
}
//Bloco de condições
if(expressão){
   //Entrará aqui sempre que a expressão do if for verdadeira
}
else{
   //Entrará aqui se a expressão do if for falsa
}
//Bloco de condições
if(expressão){
   //Entrará aqui sempre que a expressão do if for verdadeira
}
else if(expressão){
   //Entrará aqui se a expressão do if for falsa
}
else{
   //Entrará aqui se a expressão do "if" e do "else if" forem falsas
}
//Bloco de condições
if(expressão){
   //Entrará aqui sempre que a expressão do if for verdadeira
}
else if(expressão){
   //Entrará aqui se a expressão do if for falsa
}
else if(expressão){
   //Entrará aqui se a expressão do "if" e do "else if" anterior forem falsas
}
else{
   //Entrará aqui se a expressão do "if" e dos "else ifs" forem falsas
}

 

 

 

Perceba que todo "if" representa um NOVO bloco de condições independente dos blocos anteriores, ou seja um bloco de condições não tem nada a ver com outro bloco de condições. Sabemos que quando uma expressão lógica resulta em verdadeiro o programa executa as instruções daquela condição, mas para isso a expressão deve ser analisada (lembrando que quando a primeira expressão do bloco for verdadeira todas as outras serão ignoradas). Veja outro exemplo:

 

//Bloco de condições
if(sempre analisará esta expressão){
   //Instruções que serão executadas se a expressão for verdadeira
}
//Bloco de condições
if(sempre analisará esta expressão){
   //Instruções que serão executadas se a expressão for verdadeira
}
//Bloco de condições
if(sempre analisará esta expressão){
  //Instruções que serão executadas se a expressão for verdadeira
}
//Bloco de condições
if(sempre analisará esta expressão){
  //Instruções que serão executadas se a expressão for verdadeira
}
else{
   //Instruções que serão executadas se a expressão for falsa
}
//Bloco de condições
if(sempre analisará esta expressão){
  //Instruções que serão executadas se a expressão for verdadeira
}
else{
   //Instruções que serão executadas se a expressão for falsa
}
//Bloco de condições
if(sempre analisará esta expressão){
  //Instruções que serão executadas se a expressão for verdadeira
}
else if(analisará esta expressão se a anterior for falsa){
   //Instruções que serão executadas se a expressão for verdadeira
}
//Bloco de condições
if(sempre analisará esta expressão){
  //Instruções que serão executadas se a expressão for verdadeira
}
else if(analisará esta expressão se a anterior for falsa){
   //Instruções que serão executadas se a expressão for verdadeira
}
else if(analisará esta expressão se a anterior for falsa){
   //Instruções que serão executadas se a expressão for verdadeira
}
//Bloco de condições
if(sempre analisará esta expressão){
  //Instruções que serão executadas se a expressão for verdadeira
}
else if(analisará esta expressão se a anterior for falsa){
   //Instruções que serão executadas se a expressão for verdadeira
}
else if(analisará esta expressão se a anterior for falsa){
   //Instruções que serão executadas se a expressão for verdadeira
}
else{
   //Instruções que serão executadas se nenhuma expressão do bloco for verdadeira
}

 

Podemos ter algoritmos com varios ifs:

 

if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}

 

Podemos ter alguns ifs com else:

 

if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
else{
   //Instruções
}
if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
else{
   //Instruções
}

 

Podemos ter alguns ifs com else ifs e alguns com else:

 

if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
else{
   //Instruções
}
if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
else if(expressão){
   //Instruções
}
if(expressão){
   //Instruções
}
else if(expressão){
   //Instruções
}
else{
   //Instruções
}

 

 

 Toda instrução que não estiver "dentro" de um if, else if ou else SEMPRE serão executadas.

 

Utilizando os operadores E(&&) e OU(||)

O operador E é formado por 2 E comerciais (shift+7), enquanto o operador OU é formado por dois pipes (shift+ contra-barra(tecla localizada ao lado da letra Z)). Utilizamos os mesmos quando queremos unir expressões lógicas. 

Imagine o seguinte exemplo, gostariamos de exibir a mensagem "Maior de idade" somente quando o valor da variável idade for maior ou igual a 18 e menor que 60. O algoritmo ficaria assim:

if(idade>=18 && idade<60){
   System.out.println("Maior de idade");
}

Agora imagine que gostariamos de proibir o acesso de idosos e crianças de um site por exemplo. o algoritomo seria o seguinte:

if(idade<18 || idade>=60){
   System.out.println("Acesso proibido");
}

Veja que os operadores E e OU devem "unir" expressões lógicas "bem formadas" onde cada uma delas poderia ser executada separadamente. Portanto seria errado escrever o algoritmo desta maneira:

if(idade>=18 && <60){
   ....
}

 

Apenas a primeira expressão está "bem formada" e poderia ser executada separademente:

if(idade>=18){
   ...
}

Já a segunda é uma expressão "mal formada" pois não poderia ser executada separadamente:

if(>60){
   ...
}

 

O que é maior que 60? Portanto mais uma vez repito que os operadores E e OU só podem unir expressões "bem formadas" ficando o algoritmo da seguinte forma:

if(idade>=18 && idade<60){
   ...
}

 

 

 Para que uma condição que une expressões com E resultar verdadeiro, todas as expressões devem ser verdadeiras, se uma das condições for falsa toda a expressão e falsa. Exemplo:

int variavel=5;
if(variavel==5 && variavel>0 && variavel<10){
   //entrará neste if pois todas as condições são verdadeiras
}
if(variavel>0 && variavel<10 && variavel==4){
   //não entrará neste if pois a última condição é falsa
}

 Já o OU resultará em verdadeiro quando pelo menos uma condição for verdadeira. Exemplo:

 

int variavel=5;
if(variavel==3 || variavel==4 || variavel==5){
   //entrará neste if pois a última condição é verdadeira
}
if(variavel==3 || variavel==4 || variavel==6){
   //não entrará neste if pois nenhuma condição é verdadeira
}

 O operador de negação "!"

Utilizamos a negação quando queremos o resultado "falso" da expressão. Exemplo:

Gostariamos de exibir a mensagem "Você não é maior de idade" caso a variável idade NÃO SEJA maior ou igual a 18. Neste caso o algoritmo ficaria assim:

 

if(!idade>=18){
   System.out.println("Você não é maior de idade");
}

 

 

 

 

 

Compartilhe com seus amigos!



Teste de mesa | Tecnologia | Ciência | Informática