Instrução de interrupção em Java

Olá a todos os colegas e simplesmente interessados. Hoje veremos um recurso da linguagem de programação Java como o operador break. Este é o primeiro artigo sobre o tema operadores de transição, então se você gostar, terei prazer em escrever mais. Gostaria de observar imediatamente que este artigo se destina principalmente a desenvolvedores iniciantes, e estudantes mais avançados podem não encontrar nada de novo aqui. Então vamos. Em Java, existem 2 maneiras de alterar a ordem em que as instruções do programa são executadas: instruções de salto e mecanismo de tratamento de exceções. Existem três operadores de salto em java: break, continue e return. Hoje convido você a dar uma olhada mais de perto na operadora break. O tratamento de exceções é um tópico tão amplo que está além do escopo deste artigo. Existem três maneiras de usar a instrução break em java. A primeira e mais popular forma é usá-lo breakpara sair do loop mais cedo, por exemplo:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

Este exemplo exibirá:

1
2
cycle was finished

Isso significa que quando o contador do loop ise torna igual ao parâmetro passado number, ou seja, o número 3, a execução do loop é encerrada antecipadamente. Se o programa tiver vários loops aninhados, interrompa as saídas apenas do loop mais interno, por exemplo:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

Este exemplo produz a saída:

012
012
012
012
012
cycles was finished

Como pode ser visto no exemplo, o loop interno é interrompido cada vez no número 3 (parâmetro number), e o loop externo é executado 5 vezes, conforme pretendido. Em java, você pode usar mais de uma instrução break dentro de um loop, mas isso não é recomendado, pois a legibilidade e a estrutura do código ficam bastante degradadas. O segundo uso breaké utilizá-lo para interromper a execução de instruções em ramificações switch, por exemplo:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

Executar este exemplo produzirá a saída:

4
after switch

A instrução break passou o controle para o código que segue todo o bloco switch. Se você não especificar breakneste switchexemplo:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

A saída não será a esperada:

4
4
after switch

Isso aconteceu porque após a execução do bloco, case 2o programa continuou executando todos os blocos case subsequentes , o que nos deu a saída correspondente. Às vezes, esse recurso da operadora switch pode ser benéfico para nós, por exemplo:

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

Este programa compara um determinado número com o número 5 e fornece a seguinte saída:

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

Quando um método é chamado pela primeira vez, o operador switchtransfere o controle para o operador case 2e depois para o operador breakem case 5. A segunda chamada é semelhante à primeira, mas começa com c case 7. A terceira chamada não encontra um valor adequado entre todos os casos, então o operador é executado default. A terceira maneira é usar o operador breakem vez do gotooperador C. Para fazer isso, usaremos uma forma especial do operador breakchamado breakcom um rótulo. Este formulário se parece com break метка;um rótulo - geralmente é qualquer nome adequado do namespace java, precedendo um bloco de código. Além disso, após aplicar este bloco de código breakcom um rótulo, o código continuará a ser executado a partir do local após o bloco com o rótulo correspondente, por exemplo:

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

Este exemplo produzirá a seguinte saída:

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

Após a primeira chamada de método, o operador breaktransfere o controle para o final do bloco secondBlock, saindo secondBlockde e thirdBlock, enquanto executa outro operador println()no final firstBlock. Após a segunda chamada, todas as linhas serão exibidas na tela. Os rótulos também podem ser usados ​​para indicar ciclos. Deve ser lembrado que você só pode acessar um rótulo de dentro do bloco de código indicado pelo rótulo; por exemplo, esse código não será compilado:

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

Notas sobre limpeza de código e instrução break: Há um conselho geralmente aceito para usar a instrução breakcom muito cuidado, pois o uso breaktorna o loop mais difícil de entender e força o programador a olhar dentro do loop para entender as nuances de sua operação. Existe uma regra heurística que break você pode usar com mais confiança em loops mais curtos e com mais cautela em loops longos e profundamente aninhados, pois isso aumenta a probabilidade de erros e complica a leitura e compreensão do seu código por outros programadores. Como escrevi acima, o uso de um grande número de break. espalhados por todo o código indica que o programador não entende completamente por que escreveu seu código daquela maneira. Pode valer a pena considerar refatorar esse loop, dividindo-o em vários loops menores. Tente ter cuidado ao usar break um rótulo como substituto de goto, pois isso complica a estrutura do código. Isso é tudo que eu queria contar hoje sobre o operador breakem java. Terei prazer em receber críticas construtivas e também estou pronto para escrever uma continuação sobre operadores continuee return, se você estiver interessado.