if669 - Introdução à Programação
Aula 2
Igor Ebrahim (ies)
Monitoria de IP
Agenda
•
•
•
•
Estruturas de Repetição
Recursão
Exceção
Encapsulamento
Estruturas de Repetição
• Estruturas de repetição permitem executar um
trecho de código várias vezes;
• Loops;
• Assim como as estruturas condicionais, estruturas
de repetição também são controladas por
expressões booleanas;
• Três tipos de estruturas de repetição:
– while;
– do... while;
– for;
• Cada situação pede um tipo de loop diferente!
Instrução while
• Sintaxe:
while ( condicao ) {
instrucao;
}
• Se condicao for true então instrucao é
executada;
• Após a execução ter sido realizada, se condicao
continuar true, instrucao é realizada
novamente;
• A execução se repete indefinidamente até a
condicao tornar-se false.
Lógica do while
avalia
condição
true
instrução
false
Instrução while
• Exemplo:
MiniJavaSystem console;
console = new MiniJavaSystem();
int count = 1;
while (count <= 5){
console.println (count);
count = count + 1;
}
• Caso a condição já fosse false na primeira
avaliada, então a instrução não seria executada, e
o bloco seria pulado;
• Valor Sentinela;
• Robustez;
Loop Infinito
• Caso a condição do loop nunca seja false, então
aquele laço será executado “para sempre”;
• Erro de lógica muito comum;
• Exemplo:
MiniJavaSystem console;
console = new MiniJavaSystem();
int count = 1;
while (count <= 25){
console.println (count);
count = count - 1;
}
Loop Aninhado
• Um loop pode conter uma outra estrutura de
repetição dentro do seu corpo;
• Para cada iteração externa, deve-se completar a
interna.
MiniJavaSystem console;
console = new MiniJavaSystem();
count1 = 1;
while (count1 <= 10){
count2 = 1;
while (count2 <= 20){
console.println ("Aqui");
count2 = count2 + 1;
}
count1 = count1 + 1;
}
Instrução do...while
• Sintaxe:
do {
instrucao;
} while ( condicao )
• A instrucao é executada uma primeira vez;
• A condicao é avaliada e caso seja true, a
instrucao é executada novamente;
• A instrucao se repete indefinidamente até a
condicao tornar-se false.
Lógica do do...while
instrução
true
avalia
condição
false
Instrução do...while
• Exemplo:
MiniJavaSystem console;
console = new MiniJavaSystem();
int count = 0;
do {
count = count + 1;
console.println (count);
} while (count < 5);
• O corpo de um do...while executa pelo menos
uma vez;
Instrução for
• Sintaxe:
A inicializacao
é executada uma vez
antes do loop começar
A instrucao é
executada até a
condicao tornar-se false
for ( inicializacao ; condicao ; incremento )
instrucao;
O incremento é executado ao final
de cada iteração
Lógica do for
inicialização
avalia
condição
true
intrução
incremento
false
Instrução for
• Exemplo:
MiniJavaSystem console;
console = new MiniJavaSystem()
for (int count=1; count <= 5; count++)
System.out.println (count);
• O campo de inicialização pode ser usado para
declarar uma variável;
• O campo de incremento pode ser calculado da
forma que o programador quiser;
• Usa-se o for quando sabemos o número de
iterações ou quando ele é facilmente calculado.
Recursão
• Toda definição recursiva deve ter uma parte não
recursiva;
• Caso ela não tivesse, a recursão não teria fim;
• A parte não recursiva também é chamada de caso
base;
• Exemplo:
– !n  É o fatorial de n, ou seja, o produto de todos os
inteiros entre 1 e n;
– O fatorial pode ser definido de forma recursiva:
1! = 1
n! = n * (n-1)!
– O caso base desta recursão é o 1!;
Recursão
5!
120
5 * 4!
24
4 * 3!
6
3 * 2!
2
2 * 1!
1
Recursão
• Um método que chama a ele mesmo em seu
corpo é dito recursivo;
• Métodos recursivos tem que ser implementados
para trabalhar com o caso base e os casos
recursivos;
// Este método retorna a soma de 1 a n
public int soma (int num){
int resultado;
if (num == 1)
resultado = 1;
else
resultado = num + soma (n-1);
return resultado;
}
Exceção
• Objeto que descreve um erro;
• São lançadas (thrown) por um programa e podem
ser capturadas (caught) e tratadas (handled) por
uma outra parte do programa;
• Java tem predefinida uma série de exceções que
podem ser lançadas em um programa;
• Um programa Java pode lidar de três maneiras
com as exceções:
– Ignorando;
– Tratando onde ela ocorre;
– Tratando em outra parte do programa.
Exceção
• Java possui uma série de exceções predefinidas
que podem ser lançadas;
• Um programa Java pode lidar com exceções de
três maneiras diferentes:
– Ignorando;
– Tratando onde a exceção ocorre;
– Tratando em outra parte do programa;
• Caso seja ignorada, o programa terminará sua
execução de uma forma anormal, produzindo uma
mensagem apropriada  Stack Trace:
– Linha onde ocorreu a exceção;
– O caminho pelo qual o método que levantou a exceção
foi chamado.
Exceção
public class Zero {
public static void main (String[] args){
MiniJavaSystem console;
console = new MiniJavaSystem();
int numerator =
int denominator
console.println
console.println
printed.");
}
}
10;
= 0;
(numerator / denominator);
("This text will not be
try...catch
• Para tratar uma exceção, a linha que a lança é
colocada dentro de um bloco try;
• Um bloco try é seguido por uma ou mais
cláusulas catch.
• Quando uma exceção ocorre, a execução do
programa pula para o primeiro catch e procura
qual é o que possui a mesma exceção;
finally
• finally é uma cláusula opcional que pode vir depois
do catch.
• As instruções dento do bloco finally são
executadas sempre;
• Se nenhuma exceção for levantada pelo bloco try,
mesmo assim as instruções do bloco finally são
executadas;
• Se uma exceção for lançada, o bloco finally é
executado após a cláusula catch apropriada;
throws / throw
• A exceção pode se propagar através do caminho
pelo qual o método que o levantou foi chamado;
• Todos os tipos de exceção que podem ser
levantados pelo método, devem ser declarados
em sua assinatura usando o throws;
• Exceções são lançadas usando o throw ;
public double dividir(double d, double f)
throws DividirPorZeroException {
double retorno = 0;
if(f != 0) retorno = d/f;
else throw new DividirPorZeroException();
}
Encapsulamento
• Visões de objetos:
– Interna - atributos e métodos da classe que o define;
– Externa - os serviços que um objeto proporciona e como
ele interage com o resto do sistema;
• Externamente, um objeto é uma entidade
encapsulada;
• Um objeto pode usar os serviços providos por
outro – mas não deve saber como estes serviços
são implementados;
• Qualquer mudança no estado de algum atributo do
objeto usado deve ser feito através de seus
métodos – dificultar (tornar impossível) a mudança
direta de atributos fora da própria classe;
Encapsulamento
• Pode-se pensar no objeto encapsulamento como
sendo uma caixa preta;
Cliente
Métodos
Atributos
Modificadores de Acesso
• Java torna possível o encapsulamento através dos
modificadores de acesso;
• Um modificador é uma palavra reservada que
especifica uma característica particular de um
método ou atributo;
• Java possui três modificadores de acesso:
public, protected e private;
Modificadores de Acesso
• Membros que são declarados como:
– public podem ser referenciados em qualquer parte;
– private só podem ser referenciados dentro da própria
classe;
• Membros que são declarados sem modificadores
de acesso têm visibilidade default e podem ser
referenciados por qualquer classe do mesmo
pacote;
Modificadores de Acesso
Variables
Methods
public
private
Violate
encapsulation
Enforce
encapsulation
Provide services
to clients
Support other
methods in the
class