Controle de fluxo em Java

Ao desenvolver algoritmos, estruturas de dados e controles de fluxo devem ser considerados, cuja sintaxe Java é compilada neste artigo: Controle de fluxo em Java (ochoscar.com)

1. Controle de Fluxo: Declarações Condicionais

Em Java, as instruções de programação estruturada estão disponíveis para controlar o fluxo e determinar quais instruções executar ou quantas vezes repeti-las.

Visite a página de histórico do java para obter mais detalhes introdutórios.

A primeira instrução de controle é a condicional cuja forma composta é mostrada abaixo.

Código 1. Condicionales i
// Forma simple del condicional
if(expresión booleana) {
  // Bloque en caso que la expresión sea verdadera
}
// Forma compuesta del condicional
if(expresión booleana) {
  // Bloque en caso que la expresión sea verdadera
} else {
  // Bloque en caso que la expresión sea verdadera
}
// Condicional en escalera
if(expresión booleana 1) {
  // Bloque en caso que la expresión 1 sea verdadera
} else if(expresión booleana 2) {
  // Bloque en caso que la expresión 2 sea verdadera
} else if(expresión booleana 3) {
  // Bloque en caso que la expresión 3 sea verdadera
} else{
  // Bloque en caso que ninguna expresion sea verdadera
}

Os pontos-chave a serem observados sobre a instrução condicional são os seguintes:

• Os parênteses na expressão booleana são obrigatórios.
• O uso da parte do else No código.
• É extremamente importante observar que o código dentro de um bloco deve ser recuado.
• Na terceira forma da condicional (em escada) embora várias expressões booleanas sejam verdadeiras, apenas o bloco correspondente à primeira expressão booleana verdadeira é executado, da mesma forma pode haver um número indefinido de segmentos else if.
• Tenha em mente que em muitos casos o operador ternário simplifica a escrita de código, entretanto, você deve equilibrar essa simplicidade com a dificuldade de ler expressões muito enigmáticas.
• Caso os blocos possuam uma única instrução, não é necessário o uso de colchetes, apesar do acima, é altamente recomendável para legibilidade usar sempre colchetes.

1.1. instrução de troca

Outra declaração condicional é switch cuja sintaxe pode ser vista no segmento de código a seguir.

Código 2. Condicionales ii
switch(variable) {
  case CONSTANTE1:
      // código 1
      break;
  case CONSTATE2:
      // código 2
      break;
  default:
      // código por defecto
}

No caso de instrução switch Pode-se ver que ele é usado de forma semelhante a um if em ladder, permitem que os ramos do código realizem o controle de fluxo. Deve ser lembrado que as instruções que serão executadas correspondem à primeira comparação verdadeira da variável com as diferentes constantes, da mesma forma que é executado apenas um bloco de código que é marcado a partir dos dois pontos e para o próximo break, às vezes e dado que a instrução break é opcional, vários segmentos podem ser unidos case executar o mesmo código para qualquer uma das constantes que acompanham os referidos segmentos case.

Observe também que existe um segmento padrão e é opcional, ele é executado quando nenhuma das comparações com as constantes retornou um resultado verdadeiro. Os tipos de dados suportados para a variável são: int, Integer, byte, Byte, short, Short, char, Character, String, y enum.

Constantes, por outro lado, devem ser literais ou variáveis ​​marcadas com a palavra reservada final, o tipo de dados das constantes deve corresponder ao tipo de dados da variável, observe também que final faz com que a variável se torne uma constante e só possa receber um valor no momento de sua criação, porém o código não irá compilar se você usar uma variável como constante e ela for um parâmetro de uma função, mesmo que esta esteja marcada como final.

2. Controle de fluxo: ciclos

Os loops são outra maneira de realizar o controle de fluxo em Java repetindo ou iterando uma série de instruções.

2.1. loop while

O ciclo mais simples e fácil de usar é o while, que repete as instruções enquanto uma condição for verdadeira, nesse sentido observe que na sintaxe é muito semelhante ao condicional if. Sua sintaxe é apresentada a seguir.

Código 3. Ciclos i
while(condición booleana) {
  // Código
}

2.2. loop do-while

Da mesma forma, encontramos o ciclo do - while que é semelhante ao anterior, exceto que é repetido pelo menos uma vez, pois a condição é avaliada no final do loop e não no início. Sua sintaxe é mostrada abaixo.

Código 4. Ciclos ii
do {
  // Código
} while(condición booleana);

2.3. loop para

O terceiro ciclo e de fato um dos mais comuns é o ciclo for que em sua apresentação básica é mostrado abaixo

Código 5. Ciclos iii
for(inicialización, expresión booleana, actualización) {
  // Código
}

As três partes do ciclo for são opcionais e se todos forem omitidos o loop seria um loop infinito. Também é possível separar várias instruções de inicialização ou atualização usando vírgulas.

É importante lembrar que a inicialização não pode realizar ocultação de variáveis, ou seja, se a variável declarada na inicialização já foi declarada antes do loop for o compilador lançará um erro indicando que há uma declaração dupla da variável, desta forma as variáveis ​​declaradas na inicialização pertencerão ao escopo do corpo do loop e não poderão ser utilizadas fora dele. O último loop disponível em Java é o loop for - each que é mostrado abaixo.

Código 6. Ciclos vi
for(TipoDato variable : colección) {
  // Código
}

Neste caso, a coleção deve ser uma implementação de java.lang.Iterable e o loop é executado uma vez para cada item da coleção, atribuindo em cada iteração um valor da coleção.

Uma coisa importante a ter em mente com os diferentes loops é que blocos de código podem omitir chaves quando é apenas uma única linha, nestes casos é importante manter a tabulação ou colocar a linha de código na frente da estrutura de controle. De qualquer forma, essa prática não é altamente recomendada, pois é mais provável que introduza erros no código.

3. Rótulos, continuar e quebrar

As frases (if, while, do while, for, switch) de Java pode ser iniciado com uma tag, geralmente escrita em letras maiúsculas e terminando em dois pontos. Esses rótulos são usados ​​para marcar os pontos onde o código pode ser retornado por meio de uma instrução break o continue, essas duas instruções permitem interromper um ciclo para sair dele e não continuar sua execução ou no caso de continue continue imediatamente com a próxima iteração do loop, não importa quais instruções permaneçam para serem executadas. A sintaxe dessas tags é:

Código 7. Break y Continue
break etiquetaOpcional;
continue etiquetaOpcional;

Estas instruções estão disponíveis para loops, adicionalmente as instruções switch suporta o uso de break. O uso dessas instruções é particularmente útil quando em um ciclo se detecta que não é necessário continuar executando, por exemplo, se estiver sendo realizada uma pesquisa e o item desejado for encontrado, não seria necessário continuar iterando para pesquisa, neste caso você pode usar para instrução break ou se a iteração não for mais necessária, ela será usada continue.. Um exemplo de uso de tags em conjunto com uma instrução break y continue mostrado abaixo.

Código 8. Etiquetas
PRIMERO: for( ... ) {
  SEGUNDO: for( ... ) {
      if( ... ) {
          // Rompe el ciclo actual terminándolo y haciendo
          // un salto a la etiqueta PRIMERO
          break PRIMERO;
      }
      if( ... ) {
          // Deja de ejecutar la iteración actual del ciclo
          // interno y brinca a la etiqueta SEGUNDO,
          // en este caso no es necesario el uso de etiquetas
          // puesto que la instrucción continue esta en el
          // cuerpo del segundo ciclo
          continue SEGUNDO;
      }
      // ... código ...
  }
}