Estruturas de Controle em Java

Prof. Marcelo Marcon de Vargas

Estruturas de Controle
Um programa de computador é uma seqüência de instruções
organizadas de forma a produzir a solução de um determinado
problema; o que representa uma das habilidades básicas da
programação, que é a seqüenciação.

Naturalmente, as instruções de um programa são executadas em

seqüência, o que se denomina fluxo seqüencial de execução. Mas,
em inúmeras circunstâncias, é necessário executar as instruções
de um programa em uma ordem diferente da estritamente
seqüencial.

Tais situações são caracterizadas pela necessidade da repetição de

instruções individuais ou conjuntos de instruções, e também pelo
desvio do fluxo de execução, tarefas que podem ser realizadas
por meio das “estruturas de controle” da linguagem.
Definições: Diretivas e Blocos (1/2)
Formalmente, as “instruções”, ou comandos de um programa são
chamadas diretivas (statements).

Em Java, tal como nas linguagens C/C++ e Pascal, as diretivas são

separadas umas das outras pelo símbolo de pontuação “;” (ponto-
e-vírgula), sendo possível existir várias diretivas numa mesma
linha, desde que separadas por um ponto-e-vírgula.

Veja os exemplos hipotéticos colocando “N” diretivas

seqüencialmente:
diretiva1; diretiva1; diretiva2; diretiva3;
diretiva2; …
… diretivaN;
diretivaN;
Definições: Diretivas e Blocos (2/2)
As diretivas podem ser tratadas individualmente ou como um
conjunto, que é denominado bloco. Um bloco em Java é um grupo
de diretivas delimitadas por chaves ({ diretivas }).
{
diretiva1;
diretiva2; diretiva3;
…
diretivaN;
}
Assim, as estruturas de controle podem tanto operar sobre uma
diretiva individual como sobre um bloco de diretivas. Outra
conseqüência da criação de blocos é que as estruturas de controle
podem ser aninhadas de forma coletiva, isto é, dentro de um bloco
podem existir várias estruturas de controle contendo, por sua vez,
seus próprios blocos de diretivas.
 Tipos de Estruturas de Controle

fluxo fluxo fluxo

seqüencial repetitivo de execução
de execução de execução com desvio

as diretivas são as diretivas são executadas, as diretivas são executadas

executadas uma após a de forma repetida, um dependendo do valor de
outra seqüencialmente determinado número uma condição, ou expressão
do início ({) até o de vezes: lógica:
final (}) for, while e do while. if e switch.
Outras Estruturas de Controle
• Mecanismos de Modularização
Possibilitam a divisão de um programa em partes menores,
facilitando seu entendimento, sua correção ou modificação. Tal
divisão é feita por meio da construção de funções e procedimentos
(dentro do paradigma procedural) ou de métodos (dentro do
paradigma da orientação a objetos).

• Estruturas de Controle de Erros

Constituem uma importante contribuição para a programação,
pois simplificam bastante a inclusão e construção de rotinas
seletivas de tratamento de erros dentro dos programas.
// Classe Input, que contém métodos para efetuar a leitura
// através do teclado de valores inteiros, em ponto
flutuante // e também strings.
// ----------------------------------------------------------
// Os métodos: readFloat, readInteger e readString; serão
// utilizados com freqüência nos próximos exemplos desta
// apresentação.

import java.io.*;

public final class Input {

public static float readFloat() {

...
}

public static int readInteger() {

...
}

public static String readString() {

...
}
}
Estruturas de Desvio de Fluxo (1/3)
O if é uma diretiva de desvio “condicional” simples do fluxo de
execução, isto é, capaz de selecionar um entre dois caminhos
distintos para execução, dependendo do resultado, falso ou
verdadeiro, resultante da expressão lógica associada.

if (expressão lógica, ou codição)

diretiva1;
falso
condição

Esta primeira forma (simples) verdadeiro

de desvio de fluxo permite diretiva1

executar ou não uma certa
diretiva, conforme o resultado
de uma condição.
Estruturas de Desvio de Fluxo (2/3)
Esta segunda forma (composta) de desvio de fluxo permite que
seja executada a diretiva1, caso o resultado da expressão
lógica for verdadeiro e no caso do resultado da expressão lógica
for “falso” a “diretiva2” e que será executada.

if (expressão lógica)
diretiva1; falso verdadeiro
else condição
diretiva2;

diretiva2 diretiva1
// Calcula a média de um acadêmico e define sua situação:
// aprovado, reprovado ou em exame.

public class SituacaoAcademico {

public static void main(String args[]) {

System.out.println("Forneça a nota do 1o. Bimestre: ");
float nota1 = Input.readFloat();
System.out.println("Forneça a nota do 2o. Bimestre: ");
float nota2 = Input.readFloat();

float media = (nota1 + nota2) / 2;

System.out.println();
if (media >= 7.0)
System.out.println(media + ", aprovado.");
else
if (media < 4.0)
System.out.println(media + ", reprovado.");
else
System.out.println(media + ", em exame.");
}

}
Uso “Aninhado” de if else
if (condição1) Neste caso a diretiva1 é executada quando a
if (condição2) condição1 e a condição2 forem verdadeiras,
diretiva1; e a “diretiva2” é executada quando a
else “condição1 for verdadeira e a condição2 for
diretiva2; falsa”.

Isso porque a regra básica é que uma cláusula else sempre pertence à diretiva
if imediatamente anterior. O uso de chaves permite modificar esta regra.

if (condição1) { Agora a diretiva1 continua sendo executada

if (condição2) quando a condição1 e a condição2 forem
diretiva1; verdadeiras, entretanto, a “diretiva2” é
} else executada, simplesmentes, quando a
diretiva2; “condição1 for falsa”.
 Estruturas de Desvio de Fluxo (3/3)
O switch é uma diretiva de desvio “múltiplo” de fluxo, isto é, com
base na avaliação de uma expressão ordinal é escolhido um
caminho de execução “dentre muitos”.
switch (expressão ordinal) {
case ordinal1: diretiva1;
break;
case ordinal2: diretiva2;
expressão break;
ordinal ...
default: diretivaDefault;
}

Caso1 Caso2 default

diretiva1 diretiva1 ... diretivaDefault

break; break;
Semântica da Diretiva switch
O corpo da diretiva switch tem um ou mais casos (cláusulas case) rotulados por valores
ordinais. Conforme o resultado da avaliação da expressão ordinal associada ao switch, é
selecionado o caso correspondente, se existir. Se um caso for selecionado, serão
executadas as diretivas encontradas a partir deste até o final do corpo do switch (mesmo
que isso signifique “invadir” outros casos) ou até a primeira diretiva break encontrada,
que encerra o switch. Pode ser adicionado um caso especial, identificado pela cláusula
default, cujas diretivas são executadas se nenhum caso for selecionado por meio do
resultado da avaliação da expressão ordinal. A cláusula default e suas diretivas sempre
são posicionadas no final do corpo da diretivas switch.

char opcao; // obter um valor para a variável “opcao”.

switch (opcao) {
case ‘a’:
case ‘A’: System.out.println(“Alteração”);
break;
case ‘i’:
case ‘I’: System.out.println(“Inclusão”);
break;
case ‘e’:
case ‘E’: System.out.println(“Exclusão”);
break;
default: System.out.println(“Opção inválida !”);
}
// Conta e exibe a quantidade de vogais existentes em uma cadeia de caracteres (string).
public class ContaVogais {

public static void main(String args[]) {

System.out.println("Informe uma cadeia de caracteres (string):");
String msg = Input.readString();
int ctA, ctE, ctI, ctO, ctU;
ctA = ctE = ctI = ctO = ctU = 0;

for (int i=0; i<=(msg.length()-1); i++) {

switch (msg.charAt(i)) {
case 'a':
case 'A': ctA += 1;
break;
case 'e':
case 'E': ctE += 1;
break;
case 'i':
case 'I': ctI += 1;
break;
case 'o':
case 'O': ctO += 1;
break;
case 'u':
case 'U': ctU += 1;
break;
}
}
System.out.println("Na cadeia de caracteres: \"" + msg + "\".");
System.out.println("Existem " + ctA + " vogais A.");
System.out.println("Existem " + ctE + " vogais E.");
System.out.println("Existem " + ctI + " vogais I.");
System.out.println("Existem " + ctO + " vogais O.");
System.out.println("Existem " + ctU + " vogais U.");
}
}
Estruturas de Repetição Simples
A repetição é uma das tarefas mais comuns da programação,
sendo utilizada para realizar contagens, totalizações, a obtenção
de múltiplos dados, impressão etc. A repetição simples é a
execução consecutiva de uma diretiva ou bloco de um número
conhecido e fixo de vezes, o que muitas vezes se denomina laço
automático.
Cada repetição efetuada é o que sefor
chama “iteração”.
([inic]; [cond]; [incr/decr])
Inicialização da
variável de controle diretiva(s);

Falso Condição
Execução

Verdadeiro

Incremento/Decremento da
Diretiva(s) variável de controle
Sintaxe e Semântica da Diretiva for
O for tem três seções distintas de controle, todas opcionais, delimitadas por um
par de parênteses, nos quais cada seção é separada de outra por um ponto-e-
vírgula. Após as seções de controle, é declarada a diretiva ou o bloco de
diretivas que será repetido.

A primeira seção é utilizada para declarar e inicializar uma “variável de

controle” (geralmente, um contador de repetições). A segunda seção determina
a condição de execução da diretiva associada ao for e, geralmente, é uma
expressão lógica que utiliza a variável de controle e outros valores. A última
seção determina como a variável de controle será modificada a cada iteração.

O for funciona como ilustrado no slide anterior, ou seja, após a execução da

seção de inicialização, ocorre a avaliação da expressão lógica. Se a mesma for
avaliada como verdadeira, a diretiva associada será executada uma vez (uma
iteração); caso contrário, o comando for é encerrado e a execução do programa
prossegue com a próxima diretiva após o for. A cada iteração, executa-se uma
vez a seção de incremento ou decremento, que usualmente modifica o valor da
variável de controle, e novamente é feita a verificação da condição para
determinar se uma nova iteração, ou passo, deverá ser realizada ou não.
// Apresenta a tabuada de um número inteiro qualquer.

public class Tabuada {

public static void main(String args[]) {

System.out.println("Informe um numero inteiro:");

int n = Input.readInteger();

for (int i=1; i<=10; i++) {

System.out.println(i + " * " + n + " = " + (i*n));
}

}
// 1ª seção = a variável de controle “i” é inicializada com 1
// (int i=1; i<=10; i++)
// 2ª seção = determina o valor final para a variável de controle
“i” // (int i=1; i<=10; i++)
// 3ª seção = determina que o incremento na variável de controle
“i” // será realizado de um em um a cada iteração
// (int i=1; i<=10; i++)
// Em síntese: a variável de controle inicia com o valor 1 vai até
10 // (inclusive) de um em um, ou seja, executando 10 vezes a
diretiva:
// System.out.println(i + " * " + n + " = " + (i*n));
Estruturas de Repetição Condicionais (1/2)
As estruturas de repetição condicionais são as diretivas cujo controle da
repetição de execução é feito por meio da avaliação de uma expressão lógica
associada à diretiva, sendo então chamados de laços condicionais. Essas
estruturas são adequadas para permitir a execução repetida de uma ou mais
diretivas por um número indeterminado de vezes, isto é, um número que não é
conhecido durante a programação, mas que se torna conhecido durante a
execução do programa, tal como um valor fornecido pelo usuário, obtido de um
arquivo, ou ainda de cálculos realizados com outros dados. No Java, tais
estruturas são o while e do while.
while (condição)
diretiva(s);

Condição Verdadeiro
Execução
Diretiva(s)

Falso
// Verifica se um número inteiro é primo.

public class NumeroPrimo {

public static void main(String args[]) {

System.out.println("Informe um numero inteiro:");
int n = Input.readInteger();
boolean ehPrimo = true;
int i = 2;
while ((ehPrimo == true) && (i <= (n / 2))) {
if ((n % i) == 0)
ehPrimo = false; // encontrou um divisor (não eh primo)
else i++; // próximo divisor usando autoincremento
}
if (ehPrimo == true)
System.out.println(n + " \"eh\" um numero primo.");
else
System.out.println(n + " \"não eh\" um numero primo.");
}
}
// na diretiva while, um conjunto de instruções é repetido, enquanto
// o resultado de uma expressão lógica (a condição) é avaliado como
// verdadeiro.
// É importante observar que o while avalia o resultado da expressão
// lógica antes (a priori) de executar a diretiva associada; assim, é
// possível que esta diretiva nunca seja executada, caso a condição
// seja inicialmente falsa.
Estruturas de Repetição Condicionais (2/2)
A diretiva do while é outro laço condicional, no qual um conjunto
de instruções também é repetido, enquanto o resultado da
condição é avaliado como verdadeiro, mas, diferentemente do
while, a diretiva associada é executada “uma primeira vez antes”
da avaliação da expressão lógica e da eventual continuação da
repetição.

do
Diretiva(s) diretiva(s);
while (condição);

Condição Verdadeiro
Execução

Falso
 Controles de Estruturas de Repetição
As diretivas a seguir podem ser utilizadas para controlar melhor as estruturas de
repetição:
label: diretiva; // onde diretiva deve ser um for, while ou do while

break [label]; // quebra, ou interrompe, um bloco repetitivo

continue [label]; // continua na próxima iteração

// “loop” e “test” são declarações de labels, ou rótulos

1.  loop: while (...) {
2.  for (...){
3.  // pula para fora da diretiva while, para a linha 7
4.  break loop;
5.  } // finaliza o for linha 2
6.  } // finaliza o while linha 1

7.  test: for (...) {

8.  while (...){
9.  if (...) // pula para a próxima iteração da
10.  continue test; // diretiva for (linha 7)
11.  } // finaliza o while linha 8
12.  } // finaliza o for linha 7
Estruturas de Controle de Erros
O Java oferece duas importantes estruturas para o controle de erros try catch e
try catch finally. Ambas têm o propósito de separar o código que executa as
tarefas desejadas das rotinas de tratamento de eventuais erros, além de evitar
que o programador tenha que realizar testes de verificação e avaliação, antes da
realização de certas operações.

Por meio dessas diretivas, é possível delimitar um trecho de código que será
monitorado automaticamente pela JVM. Ocorrendo algum erro, o fluxo de
execução é “tranferido” para uma “rotina de tratramento de erro”, sendo que tal
transferência pode ser seletiva, isto é, pode-se transferir a execução para rotinas
diferentes, conforme o erro ocorrido.

A ocorrência de erros no Java é sinalizada pelas exceções, isto é, objetos

especiais que carregam informações sobre o tipo de erro detectado. Existem
várias categorias diferentes de execeções, adequadas ao tratamento dos
problemas mais comuns em Java. Exceções particulares podem ser criadas em
adição às existentes, ampliando-se as possibilidades de tratamento de erros.
Sintaxe do Tratamento de erros (try catch finally)

Com a diretiva try catch, a ocorrência de um ou mais tipos de erros dentro do

trecho de código delimitado (diretiva de execução normal, ou protegida) desvia
a execução automaticamente para uma ou mais rotinas designadas para o
tratamento específico desses erros (catch (tipo da exceção)). O uso opcional da
cláusula finally garante a execução de um trecho final de código.

try {
diretiva normal (ou protegida);
} catch (exceção 1) {
diretiva de tratamento de erro 1;
}[catch (exceção 2) {
diretiva de tratamento de erro 2;
}][finally {
diretiva de execução garantida;
}]

A sintaxe do try catch finally exige que cada bloco try tenha “ao menos um
bloco” catch ou finally.
Exemplo do Tratamento de erros (try catch finally)

public class ExemploTryCatchSeletivo {

public static void main (String args[]) {
try { // trecho de código protegido
int j = Integer.parseInt(args[0]);
while (j >=0) {
System.out.println(j);
j--;
}
} catch (ArrayIndexOutOfBoundsException e1) {
System.out.println(“Não foi fornecido um argumento”);
} catch (NumberFormatException e2) {
System.out.println(“Argumento não é um nro. inteiro”);
}
}
}

A cláusula finally é geralmente usada para garantir que certos recursos do

sistema ou estrutura de dados devem ser liberados, independentemente de sua
utilização.
Exceções Comuns (1/2)
A linguagem Java fornece várias exceções predefinidas. Entres
estas exceções pode-se destacar:
• ArithmeticException
normalmente, o resultado de uma operação de divisão de
inteiros por zero
• NullPointerException
uma tentativa de acessar um objeto ou método antes do
próprio ser instanciado (ou criado)
• ArrayIndexOutOfBoundsException
uma tentativa de acessar um elemento de um vetor além da
definição original do tamanho do vetor
• NegativeArraySizeException
uma tentativa de criar um vetor com dimensão negativa
• NumberFormatException
incompatibilidade de tipos
Exceções Comuns (2/2)
• IOException
exceções para operações de Entrada (Input) e Saída
(Output). Ex. acessar arquivos ou dispositivos de entrada
e saída.
• FileNotFoundException
arquivo não encontrado

• Exception, classe base exceção (generalizar a execeção)

raiz de todas as exceções
o método “getMessage” retorna uma mensagem indicando
a execeção ocorrida
try {
:
} catch (Exception e) {
System.err.println(“Exceção: ” + e.getMessage());
}
Referência
•  Introdução ao Java.
– Peter Jandl Junior.
– São Paulo: Berkeley - 2002.
– Capítulo 2: Java e sua Sintaxe, pág. 36..51.