A tomada de decisão na programação é semelhante à tomada de decisão na vida real. Na programação também nos deparamos com algumas situações em que queremos que um determinado bloco de código seja executado quando alguma condição for satisfeita.
Uma linguagem de programação usa instruções de controle para controlar o fluxo de execução do programa com base em certas condições. Eles são usados ​​para fazer com que o fluxo de execução avance e se ramifique com base nas alterações no estado de um programa.
Declarações de seleção do Java:

• E se
• if-else
• aninhado-se
• if-else-if
• caixa de interruptor
• pular - quebrar, continuar, voltar

  Essas instruções permitem controlar o fluxo de execução do programa com base em condições conhecidas apenas durante o tempo de execução.

• if : if é a declaração de tomada de decisão mais simples. É usado para decidir se uma determinada instrução ou bloco de instruções será executado ou não, ou seja, se uma determinada condição for verdadeira, um bloco de instruções será executado, caso contrário, não.
  Sintaxe :

  if (condição) 
  {
     // Instruções a serem executadas se
     // condição é verdadeira
  }
  

  Aqui, a condição após a avaliação será verdadeira ou falsa. se a instrução aceita valores booleanos - se o valor for verdadeiro, ele executará o bloco de instruções abaixo dele.
  Se não fornecermos as chaves '{' e '}' após if (condição), então, por padrão, a instrução if irá considerar a instrução imediata como estando dentro de seu bloco. Por exemplo,

  if (condição)
     declaração1;
     declaração2;
  
  // Aqui se a condição for verdadeira, se o bloco 
  // considerará apenas a instrução 1 como dentro 
  // seu bloco.

  Fluxograma:
  
  Exemplo:

  
  

  
  
  

  // Java program to illustrate If statement class IfDemo {     public static void main(String args[])     {         int i = 10;            if (i > 15)             System.out.println("10 is less than 15");            // This statement will be executed         // as if considers one statement by default         System.out.println("I am Not in if");     } }

  Saída:

  
  
  
  

  Eu não estou em se
  

• if-else : A instrução if por si só nos diz que se uma condição for verdadeira, ela executará um bloco de instruções e, se a condição for falsa, não o fará. Mas e se quisermos fazer outra coisa se a condição for falsa. Aí vem a declaração else. Podemos usar a instrução else com a instrução if para executar um bloco de código quando a condição for falsa.
  Sintaxe :

  if (condição)
  {
      // Executa este bloco se
      // condição é verdadeira
  }
  outro
  {
      // Executa este bloco se
      // condição é falsa
  }
  

  
  Exemplo:

  
  

  
  
  

  // Java program to illustrate if-else statement class IfElseDemo {     public static void main(String args[])     {         int i = 10;            if (i < 15)             System.out.println("i is smaller than 15");         else             System.out.println("i is greater than 15");     } }

  Saída:

  eu é menor que 15

• nested-if: Um if aninhado é uma instrução if que é o destino de outro if ou else. As instruções if aninhadas significam uma instrução if dentro de uma instrução if. Sim, o java nos permite aninhar as instruções if dentro das instruções if. ou seja, podemos colocar uma instrução if dentro de outra instrução if.
  Sintaxe:

  if (condição1) 
  {
     // Executa quando a condição1 é verdadeira
     if (condição 2) 
     {
        // Executa quando a condição 2 é verdadeira
     }
  }
  

  
  Exemplo:

  
  

  
  
  

  // Java program to illustrate nested-if statement class NestedIfDemo {     public static void main(String args[])     {         int i = 10;            if (i == 10)         {             // First if statement             if (i < 15)                 System.out.println("i is smaller than 15");                // Nested - if statement             // Will only be executed if statement above             // it is true             if (i < 12)                 System.out.println("i is smaller than 12 too");             else                 System.out.println("i is greater than 15");         }     } }

  Saída:

  eu é menor que 15
  eu é menor que 12 também
  

• If-else-if ladder: Aqui, um usuário pode decidir entre várias opções. As instruções if são executadas de cima para baixo. Assim que uma das condições que controlam o if for verdadeira, a instrução associada àquele if é executada e o resto da escada é ignorado. Se nenhuma das condições for verdadeira, a instrução else final será executada.

  if (condição)
      demonstração;
  else if (condição)
      demonstração;
  .
  .
  outro
      demonstração;
  

  
  Exemplo:

  
  
  
  
  
  

  
  
  

  // Java program to illustrate if-else-if ladder class ifelseifDemo {     public static void main(String args[])     {         int i = 20;            if (i == 10)             System.out.println("i is 10");         else if (i == 15)             System.out.println("i is 15");         else if (i == 20)             System.out.println("i is 20");         else             System.out.println("i is not present");     } }

  Saída:

  eu tenho 20
  

• switch-case A instrução switch é uma instrução de ramificação multiway. Ele fornece uma maneira fácil de despachar a execução para diferentes partes do código com base no valor da expressão.
  Sintaxe:

  switch (expressão)
  {
    valor de caso 1:
      declaração1;
      pausa;
    valor de caso 2:
      declaração2;
      pausa;
    .
    .
    valor de caso N:
      declaraçãoN;
      pausa;
    predefinição:
      statementDefault;
  }

  • A expressão pode ser do tipo byte, short, int char ou uma enumeração. Começando com JDK7, a expressão também pode ser do tipo String.
  • Valores de maiúsculas e minúsculas duplicados não são permitidos.
  • A instrução padrão é opcional.
  • A instrução break é usada dentro do switch para encerrar uma seqüência de instruções.
  • A instrução break é opcional. Se omitido, a execução continuará no próximo caso.

  
  Exemplo:

  
  

  
  
  

  // Java program to illustrate switch-case class SwitchCaseDemo {     public static void main(String args[])     {         int i = 9;         switch (i)         {         case 0:             System.out.println("i is zero.");             break;         case 1:             System.out.println("i is one.");             break;         case 2:             System.out.println("i is two.");             break;         default:             System.out.println("i is greater than 2.");         }     } }

  Saída:

  i é maior que 2.
  

• jump: Java suporta três instruções de salto: break, continue e return . Essas três instruções transferem o controle para outra parte do programa.
  1. Break: Em Java, break é usado principalmente para:
     • Encerre uma sequência em uma instrução switch (discutida acima).
     • Para sair de um loop.
     • Usado como uma forma “civilizada” de goto.

     Usando break para sair de um Loop

     Usando break, podemos forçar o encerramento imediato de um loop, ignorando a expressão condicional e qualquer código restante no corpo do loop.
     Nota: Break, quando usado dentro de um conjunto de loops aninhados, irá quebrar apenas o loop mais interno.
     
     Exemplo:

     
     

     
     
     

     // Java program to illustrate using // break to exit a loop class BreakLoopDemo {     public static void main(String args[])     {         // Initially loop is set to run from 0-9         for (int i = 0; i < 10; i++)         {             // terminate loop when i is 5.             if (i == 5)                 break;                System.out.println("i: " + i);         }         System.out.println("Loop complete.");     } }

     Saída:

     i: 0
     i: 1
     i: 2
     i: 3
     i: 4
     Loop completo.
     

     Usando break como uma forma de Goto

     Java não tem uma instrução goto porque fornece uma maneira de ramificar de maneira arbitrária e não estruturada. Java usa rótulo. Um rótulo é usado para identificar um bloco de código.
     Sintaxe:

     rótulo:
     {
       declaração1;
       declaração2;
       declaração3;
       .
       .
     }

     Agora, a instrução break pode ser usada para pular do bloco de destino.
     Nota: Você não pode quebrar para qualquer rótulo que não seja definido para um bloco envolvente.
     Sintaxe:

     
     
     
     

     etiqueta de quebra;

     Exemplo:

     
     

     
     
     

     // Java program to illustrate using break with goto class BreakLabelDemo {     public static void main(String args[])     {         boolean t = true;            // label first         first:         {             // Illegal statement here as label second is not             // introduced yet break second;             second:             {                 third:                 {                     // Before break                     System.out.println("Before the break statement");                        // break will take the control out of                     // second label                     if (t)                         break second;                     System.out.println("This won't execute.");                 }                 System.out.println("This won't execute.");             }                // First block             System.out.println("This is after second block.");         }     } }

     Saída:

     Antes do intervalo.
     Isso ocorre após o segundo bloco.
     

  2. Continue: Às vezes, é útil forçar uma iteração inicial de um loop. Ou seja, você pode querer continuar executando o loop, mas parar de processar o restante do código em seu corpo para esta iteração específica. Isso é, na verdade, um goto logo após o corpo do loop, até o final do loop. A instrução continue executa essa ação.
     
     Exemplo:
     
     

     
     
     

     // Java program to illustrate using // continue in an if statement class ContinueDemo {     public static void main(String args[])     {         for (int i = 0; i < 10; i++)         {             // If the number is even             // skip and continue             if (i%2 == 0)                 continue;                // If number is odd, print it             System.out.print(i + " ");         }     } }

     Saída:

     1 3 5 7 9 
     

  3. Retorno: a instrução return é usada para retornar explicitamente de um método. Ou seja, faz com que um controle de programa seja transferido de volta para o chamador do método.
     Exemplo:
     
     

     
     
     

     // Java program to illustrate using return class Return {     public static void main(String args[])     {         boolean t = true;         System.out.println("Before the return.");                if (t)             return;            // Compiler will bypass every statement          // after return         System.out.println("This won't execute.");     } }

     Saída:

     Antes do retorno.