Expressões válidas para switch e case

 

A expressão switch deve analisar um char, byte, int, short ou enum. Isso quer dizer, que senão estiver usando um enum, apenas variáveis que puderem ser automaticamente promovidos, ou seja, implicitamente convertidos a um tipo int, serão permitidos.

Também, a instrução switch pode verificar apenas a igualdade. Ou seja, os outros operadores relacionais, como maior que (>), são considerados não-utilizáveis em uma instrução case.

Para o exame, procure por alguma violação nas regras de argumentos de switch e case. É possível encontrar exemplos inválidos, como os 2 abaixo.

//exemplo 1

switch(x){//faltam os dois pontos do case e o case não pode estar entre chaves

            case 0{

                        g=9;

            }

}

//exemplo2

switch(y){//omite a palavar-chave case

2:{ }

3:{ }

}

Loops e iteradores

 

As variantes de um loop proporcionam que a execução de um bloco de código seja repetida, enquanto uma determinada condição for verdadeira ou durante uma quantidade determinada de iterações.

Não se esqueça de verificar a utilização do ponto e vírgula ao final da expressão while. Como nos testes if, procure loops while com uma expressão que não resulte em booleano. Verifique alguns exemplos.

 

int a=1;

while(a){ }//Não compila, pois a não é booleano

while(a=8){ }//Não compila, pois a é resolvido como 8(resultado de atribuição)

while(a==8){ }//Válido teste de igualdade

while(true){ }//Válido

package br.devmedia;

 

public class Demo {

 

      /**

       * @param args

       */

      public static void main(String[] args) {

            int count = 2;

            while(count<12){

                  System.out.println("Count is: "+count);

                  count++;

            }

      }

}

class Demo2{

      public static void main(String args[]){

            int count = 2;

            do{

                  System.out.println("Count is: "+count);

                  count++;

            }while(count<=12);

      }

}

 

O loop for será especificamente útil para o controle de fluxo quando se souber quantas vezes terá que iterar. Sua declaração tem 3 partes: declaração/inicialização, expressão booleana e expressão de iteração. Cada uma é separada por ponto-e-vírgula. Todas essas partes são opcionais.

Opções de saídas forçadas incluem um return, um break, uma exceção ou uma instrução System.exit(). Todas essas opções fazem com que o loop seja encerrado bruscamente, sem executar a expressão de iteração. Ao se deparar com um break, a execução saltará imediatamente para próxima instrução após o loop for.

Ao se deparar com um return, a execução retornará imediatamente ao método chamador. Por último, ao encontrar um System.exit(), a execução do programa será totalmente interrompida e a JVM será finalizada.

O exemplo abaixo é perfeitamente válido, porém não é uma boa prática.

 

for(;;){

                  System.out.println("Loop Infinito");

            }

É essencial que você saiba que, com a ausência das seções de declaração/inicialização e da expressão de iteração, o loop for agirá como um loop while. Avalie como isso acontece:

 

int i = 0;

            for(;i<5;){

                  i++;

                  //outros processos

            }

Loop for aprimorado

 

O loop for aprimorado é uma inovação do Java 5. Nada mais é que um loop for especializado que facilita a tarefa de iteragir através de um conjunto ou um array.

A expressão verifica o array através do qual o loop acontece. Avalie um exemplo que contém alguns loops for aprimorados:

 

package br.devmedia;

 

class Automovel{

      public String toString(){

            return "Veículo";

      }

}

class AutomovelEsportivo extends Automovel{

      public String toString(){

            return " Veículo Esportivo";

      }

}

public class DemoFor {

 

      /**

       * @param args

       */

      public static void main(String[] args) {

            int [] a={1,2,3,4,5,6};

            for(int y: a){

                  System.out.print(y+" ");

            }

            Automovovel[] b=new Automovel[]{new Automovel(), new AutomovelEsportivo()};

            for(Automovel z: b){

                  System.out.print(z+" ");

            }

            int[][] x = {{1,2},{3},{4,5}};

            for(int[]c:x){

                  for(int r:c){

                        System.out.print(r+" ");

                  }

            }

      }

 

}

 

Break e continue

As palavras-chaves continue e break são utilizadas para finalizar o loop inteiro (break) ou somente a iteração atual (continue). Geralmente, quando é executado break ou continue, executamos um teste if dentro do loop e se alguma condição for true, ou false dependendo da aplicação, saímos dele logo após.

No exemplo abaixo, não haverá impressão quando x for ==6.

 

package br.devmedia;

 

public class ContinueTeste {

 

      /**

       * @param args

       */

      public static void main(String[] args) {

            for(int x=0;x<5;x++){

                  if(x==2){

                        continue;

                  }

                  System.out.print(x+" ");

            }

 

      }

 

}

Console:

0 1 3 4

É notório que você entenda que não pode haver nada, ou seja, nenhuma instrução após um break ou continue, dentro de um loop for. Nessa circunstância é gerado um erro de compilação, uma vez que se trata de código inatingível.


Na última parte do artigo, testaremos seus conhecimentos aplicando um mini-teste.

 

Leia todos artigos da série