(ACH2001) Introdução à Programação - Aula 09

Aula 09 – La¸cos (cont.)
Norton Trevisan Roman
19 de mar¸co de 2020
Norton Trevisan Roman Aula 09 – La¸cos (cont.) 19 de mar¸co de 2020 1 / 47

Do ... While
Existe ainda um outro tipo de la¸co: do...while
do {
comando1;
comando2;
...
comandon;
} while (condi¸c~ao);

Do ... While
Existe ainda um outro tipo de la¸co: do...while
do {
comando1;
comando2;
...
comandon;
public static void main(String[] args) {
double area = 50;
int tipo = ALVENARIA;
System.out.println("´AreatValor");
do {
System.out.println(area+"t"+
valorPiscina(area,tipo));
area = area + 50;
} while (area<=200);
}

Do ... While
O while faz o teste antes de
rodar o la¸co pela primeira vez
O do...while faz o teste depois
de rodar o la¸co pela primeira
vez
Rodando novamente apenas se o
teste for positivo
while (condi¸c~ao) {
comando1;
comando2;
...
comandon;
}
do {
comando1;
comando2;
...
comandon;

Do ... While
E quando usar um ou o outro?
comando1;
comando2;
...
comandon;
}
do {
comando1;
comando2;
...
comandon;

Do ... While
E quando usar um ou o outro?
Depende de quando o teste
deve ser feito:
Se antes ou depois do corpo do la¸co
rodar uma vez
comando1;
comando2;
...
comandon;
}
do {
comando1;
comando2;
...
comandon;

Do ... While
E qual dentre o while e do...while ´e melhor?

Do ... While
S˜ao totalmente equivalentes

Do ... While
S˜ao totalmente equivalentes
Todo while pode ser escrito
como do... while
comando;
}
if (condi¸c~ao) {
do {
comando;
}

Do ... While
E vice versa:
do {
comando;
condi¸c~ao = true;
comando;
recalcula_condi¸c~ao;
}

Do ... While
O que ditará qual deles será
usado é a conveniência para o
programador
comando1;
comando2;
...
comandon;
}
do {
comando1;
comando2;
...
comandon;

Do ... While
O que ditará qual deles será
usado é a conveniência para o
programador
Será escolhido, naturalmente,
aquele que exigir a escrita de
menos código
comando1;
comando2;
...
comandon;
}
do {
comando1;
comando2;
...
comandon;

Do ... While
Em nosso código, esses trechos são equivalentes:
public static void main(String[]
args) {
double area = 50;
System.out.println("Áreat
Valor");
while (area <= 200) {
System.out.println(area+"t"
+ valorPiscina(area,tipo));
area = area+50;
}
}
args) {
double area = 50;
Valor");
if (area <= 200) {
do {
System.out.println(area+
"t"+
area = area + 50;
}
}

Do ... While
Nesse caso, contudo, o if sempre ser´a verdadeiro
args) {
double area = 50;
Valor");
area = area+50;
}
}
args) {
double area = 50;
Valor");
if (area <= 200) {
do {
System.out.println(area+
"t"+
area = area + 50;
}
}

Do ... While
Ent˜ao podemos removˆe-lo
args) {
double area = 50;
Valor");
area = area+50;
}
}
args) {
double area = 50;
Valor");
do {
area = area + 50;
}

Do ... While
Da mesma forma, esses trechos s˜ao equivalentes:
args) {
double area = 100;
System.out.println("Materialt
Valor");
while (tipo <= PLASTICO) {
System.out.println(tipo+"t
t"+valorPiscina(area,
tipo));
tipo = tipo+1;
}
}
args) {
double area = 50;
Valor");
if (tipo <= PLASTICO) {
do {
System.out.println(tipo+
"tt"+valorPiscina(area,
tipo));
tipo = tipo + 1;
} while (tipo <= PLASTICO);
}
}

Do ... While
Tamb´em aqui o if era redundante
args) {
double area = 100;
Valor");
tipo));
tipo = tipo+1;
}
}
args) {
double area = 50;
Valor");
do {
tipo));
tipo = tipo + 1;
}

Do ... While
E, ﬁnalmente,
assim como no
while...
double area = 50;
int tipo;
System.out.println("´AreatMaterialt
Valor");
tipo = ALVENARIA;
System.out.println(area+"t"+tipo+
"tt"+valorPiscina(area,tipo));
tipo = tipo+1;
}
area = area+50;
}
}

Do ... While
Tamb´em o
do...while
pode estar
aninhado
double area = 50;
int tipo;
System.out.println("´AreatMaterialt
Valor");
do {
tipo = ALVENARIA;
do {
System.out.println(area+"t"+tipo+
"tt"+valorPiscina(area,tipo));
tipo = tipo+1;
area = area+50;
} while (area <= 200);
}

Em Suma...
comando;
}
do {
comando;

Em Suma...
comando;
}
Primeiro testa a condi¸c˜ao
do {
comando;

Em Suma...
comando;
}
Se ela for verdadeira,
executa o la¸co (corpo do
while)
do {
comando;

Em Suma...
comando;
}
while)
do {
comando;
Primeiro executa o la¸co
(corpo do do...while)

Em Suma...
comando;
}
while)
do {
comando;
Primeiro executa o la¸co
(corpo do do...while)
Ao final do corpo, testa
então a condi¸cão

Em Suma...
comando;
}
Ao ﬁnal do corpo, volta ao
in´ıcio, testando novamente
a condi¸c˜ao
do {
comando;

Em Suma...
comando;
}
a condi¸cão
Se ela for falsa, passa à
próxima instru¸cão após o
while
do {
comando;

Em Suma...
comando;
}
a condi¸c˜ao
while
do {
comando;
Se a condi¸c˜ao for
verdadeira, executa o la¸co
novamente

Em Suma...
comando;
}
a condi¸c˜ao
while
do {
comando;
Se a condi¸c˜ao for
verdadeira, executa o la¸co
novamente
do...while

Em Suma...
Fonte: Meme de autor desconhecido

For
Os while vistos
tinham
caracter´ısticas em
comum em suas
vari´aveis de controle:
args) {
double area = 100;
Valor");
System.out.println(tipo+"tt"+
tipo = tipo+1;
}
}

For
Os while vistos
tinham
caracter´ısticas em
comum em suas
vari´aveis de controle:
Ambos variavam em
passos constantes (de
1 em 1 ou de 50 em
50)
args) {
double area = 100;
Valor");
tipo = tipo+1;
}
}

For
N˜ao haveria um
modo de deixar esse
c´odigo mais enxuto?
args) {
double area = 100;
Valor");
tipo = tipo+1;
}
}

For
Não haveria um
modo de deixar esse
código mais enxuto?
Um modo de dizer
“para tipo
come¸cando em 0,
variando de 1 em 1,
até 3, fa¸ca...”
args) {
double area = 100;
Valor");
tipo = tipo+1;
}
}

For
Ou “para area
come¸cando em 50,
variando de 50 em
50, at´e 200, fa¸ca...”
args) {
double area = 50;
area = area+50;
}
}

For
O la¸co for:
for (inicializa¸c~ao;
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}

For
O la¸co for:
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Primeiro, há a inicializa¸cão das variáveis de controle

For
O la¸co for:
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Primeiro, há a inicializa¸cão das variáveis de controle
Esse passo é executado uma única vez

For
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Em seguida, a condi¸c˜ao ´e testada

For
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Em seguida, a condi¸cão é testada
Se resultar verdadeira, os comandos do corpo do
for são executados

For
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Ao final do corpo, é executada a atualiza¸cão

For
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Inicia-se o la¸co novamente, voltando ao teste da
condi¸c˜ao

For
condi¸c~ao;
atualiza¸c~ao) {
comandos;
}
inicializa¸c~ao;
comandos;
atualiza¸c~ao;
}
Inicia-se o la¸co novamente, voltando ao teste da
condi¸cão
Se a condi¸cão for falsa, o corpo é ignorado

For
args) {
double area = 100;
Valor");
tipo = tipo+1;
}
}
args) {
double area = 100;
Valor");
for(int tipo = ALVENARIA;
tipo <= PLASTICO;
tipo = tipo+1) {
}
}
S˜ao totalmente equivalentes: dependem da
conveniˆencia do programador

For
É poss´ıvel declarar
a variável de
controle dentro do
for
Nesse caso, seu
escopo é o
corpo do for
args) {
double area = 100;
Valor");
tipo <= PLASTICO;
tipo = tipo+1) {
}
}

For
Nada impede,
contudo, que seja
declarada antes,
para ser vis´ıvel a
mais algu´em:
args) {
double area = 100;
Valor");
int tipo;
for(tipo = ALVENARIA;
tipo <= PLASTICO;
tipo = tipo+1) {
}
}

For
Incremento de um em um não é só o que o for é
capaz de fazer:
args) {
double area = 50;
area = area+50;
}
}
args) {
for(double area = 50; area <= 200;
area = area+50) {
}
}

For
Qualquer express˜ao
alg´ebrica pode ser
usada
args) {
area = area+50) {
}
}

For
Qualquer expressão
algébrica pode ser
usada
Até mesmo coisas
como
area = 2*area +
Math.pow(area,3)
args) {
area = area+50) {
}
}

For
E não é apenas o
int que pode ser
usado como
variável de controle
Podemos também
usar outros tipos –
Cuidado com
compara¸cões em
ponto flutuante!!!
args) {
area = area+50) {
}
}

For
Da mesma forma,
na condi¸cão
qualquer expressão
lógica ou relacional
pode ser usada
Ex:
(area <= 200)||
(area == 300)
args) {
area = area+50) {
}
}

For
Tamb´em nada nos
impede de fazer um
decremento
args) {
for(double area = 200; area >= 50;
area = area-50) {
}
}

For
E o resultado seria
apenas a invers˜ao
da tabela:
´Area Valor
200.0 300000.0
150.0 225000.0
100.0 150000.0
50.0 75000.0
args) {
for(double area = 200; area >= 50;
area = area-50) {
}
}

For Aninhado
La¸cos for podem tamb´em ser aninhados
double area = 50;
int tipo;
System.out.println("´AreatMaterial
tValor");
tipo = ALVENARIA;
tipo+"tt"+
tipo = tipo+1;
}
area = area+50;
}
}
tValor");
area = area+50) {
tipo <= PLASTICO;
tipo = tipo+1) {
tipo+"tt"+
}
}
}

For Aninhado
La¸cos for podem também ser aninhados
double area = 50;
int tipo;
tValor");
tipo = ALVENARIA;
tipo+"tt"+
tipo = tipo+1;
}
area = area+50;
}
}
tValor");
area = area+50) {
tipo <= PLASTICO;
tipo = tipo+1) {
tipo+"tt"+
}
}
}
Podem ficar até mais fáceis de serem entendidos

For
Embora a condi¸c˜ao
tenha que ser ´unica
int a;
int b;
for(???; a<b; ???) {
System.out.println("a="+a);
System.out.println("b="+b);
}

For
Aceita m´ultiplas
inicializa¸c˜oes
Separadas por v´ırgula
int a;
int b;
for(a=1, b=4; a<b; ???) {
}
Declaradas fora do for

For
Aceita múltiplas
inicializa¸cões
int a;
int b;
for(a=1, b=4; a<b; a++,b--) {
}
E múltiplas atualiza¸cões
Também separadas por v´ırgula

For
Aceita múltiplas
inicializa¸cões
int a;
int b;
for(a=1, b=4; a<b; a++,b--) {
}
E múltiplas atualiza¸cões
Também separadas por v´ırgula
a++? b--?

Expressões Contra´ıdas
São “atalhos” →
Expressões contra´ıdas int a;
int b;
for(a=1, b=4; a<b; a++,b--) {
}

São “atalhos” →
Expressões contra´ıdas
Úteis para realizar a
opera¸cão e armazenar
o resultado na mesma
variável
int a;
int b;
for(a=1, b=4; a<b; a++,b--) {
}

Express˜ao Contra´ıda
x = x + 5 x += 5
x = x - 5 x -= 5
x = x * 5 x *= 5
x = x / 5 x /= 5
x = x % 5 x %= 5
int a;
int b;
for(a=1, b=4; a<b; a++,b--) {
}

Express˜ao Contra´ıda
x = x + 5 x += 5
x = x - 5 x -= 5
x = x * 5 x *= 5
x = x / 5 x /= 5
x = x % 5 x %= 5
int a;
int b;
for(a=1, b=4; a<b; a++,b--) {
}
E o ++?

Tem duas formas: x++
ou ++x
int x = 2;
int y = 2;
x++;
++y;
System.out.println("x = "
+x+", y = "+y);
Sa´ıda:

ou ++x
int x = 2;
int y = 2;
x++;
++y;
+x+", y = "+y);
Sa´ıda:
x = 3, y = 3

ou ++x
Usados isoladamente,
tanto ++x quanto x++
correspondem a
x = x+1
int x = 2;
int y = 2;
x++;
++y;
+x+", y = "+y);
Sa´ıda:
x = 3, y = 3

Mas coisas acontecem
quando usados em
conjunto com outros
comandos...
int x = 2;
int y = 2;
System.out.println("x = "+
x++ +", y = "+ ++y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 3
x = 3, y = 3

quando usados em
conjunto com outros
comandos...
O que houve?
int x = 2;
int y = 2;
x++ +", y = "+ ++y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 3
x = 3, y = 3

quando usados em
conjunto com outros
comandos...
O que houve?
x++ ´e um
p´os-incremento
int x = 2;
int y = 2;
x++ +", y = "+ ++y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 3
x = 3, y = 3

quando usados em
conjunto com outros
comandos...
O que houve?
x++ é um
pós-incremento
int x = 2;
int y = 2;
x++ +", y = "+ ++y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 3
x = 3, y = 3
Diz que o compilador deve usar o valor que está em
x e só então incrementá-lo

++x ´e um
pr´e-incremento
int x = 2;
int y = 2;
x++ +", y = "+ ++y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 3
x = 3, y = 3

++x é um
pré-incremento
Diz que o compilador
deve primeiro
incrementar o valor de
x, e só então usá-lo
int x = 2;
int y = 2;
x++ +", y = "+ ++y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 3
x = 3, y = 3

De forma semelhante
ao ++, o --
decrementa, em vez
de incrementar
Tamb´em em suas duas
formas: x-- e --x
int x = 2;
int y = 2;
x-- +", y = "+ --y);
x +", y = "+ y);
Sa´ıda:

De forma semelhante
ao ++, o --
decrementa, em vez
de incrementar
Tamb´em em suas duas
formas: x-- e --x
int x = 2;
int y = 2;
x-- +", y = "+ --y);
x +", y = "+ y);
Sa´ıda:
x = 2, y = 1
x = 1, y = 1

Mais exemplos:
C´odigo
int x = 2;
int y = x++;
System.out.println("x = "+ x +", y = "+ y);
int z = ++x;
System.out.println("x = "+ x +", z = "+ z);

Mais exemplos:
Código
int x = 2;
int y = x++;
int z = ++x;
Sa´ıda
x = 3, y = 2
x = 4, z = 4
y = x++ fará y conter 2, se x contiver 2
antes do ++
z = ++x fará z conter 4,
se x contiver 3 antes do ++

Mais exemplos:
C´odigo
int x = 2;
int y = x++;
int z = ++x;
Sa´ıda
x = 3, y = 2
x = 4, z = 4
antes do ++
C´odigo
int x = 1;
int y = x++ + 4;
int z = ++x + 4;

Mais exemplos:
C´odigo
int x = 2;
int y = x++;
int z = ++x;
Sa´ıda
x = 3, y = 2
x = 4, z = 4
antes do ++
C´odigo
int x = 1;
int y = x++ + 4;
int z = ++x + 4;
Sa´ıda
x = 2, y = 5
x = 3, z = 7

La¸cos
Considere o c´odigo ao
lado:
public static void main(
String[] args) {
int x = 1;
for (; x<5; x++) {
System.out.print(
x+" ");
}
}

La¸cos
lado:
O que ser´a impresso?
String[] args) {
int x = 1;
for (; x<5; x++) {
System.out.print(
x+" ");
}
}

La¸cos
lado:
1 2 3 4
String[] args) {
int x = 1;
for (; x<5; x++) {
System.out.print(
x+" ");
}
}

La¸cos
lado:
1 2 3 4
A inicializa¸c˜ao em um
la¸co for ´e opcional
String[] args) {
int x = 1;
for (; x<5; x++) {
System.out.print(
x+" ");
}
}

La¸cos
Considere agora esse
c´odigo: public static void main(
String[] args) {
int x = 1;
for (; x<5;) {
System.out.print(
x+" ");
}
}

La¸cos
c´odigo:
String[] args) {
int x = 1;
for (; x<5;) {
System.out.print(
x+" ");
}
}

La¸cos
c´odigo:
1 1 1 1 1 1 1 1 1...
String[] args) {
int x = 1;
for (; x<5;) {
System.out.print(
x+" ");
}
}

La¸cos
código:
1 1 1 1 1 1 1 1 1...
La¸co infinito: a
condi¸cão de parada
nunca é satisfeita
String[] args) {
int x = 1;
for (; x<5;) {
System.out.print(
x+" ");
}
}

La¸cos
Também a atualiza¸cão
da variável de controle
é opcional
String[] args) {
int x = 1;
for (; x<5;) {
System.out.print(
x+" ");
}
}

La¸cos
E esse c´odigo?
String[] args) {
for (int x=1;;x++) {
System.out.print(
x+" ");
}
}

La¸cos
E esse c´odigo?
1 2 3 4 5 6 7 8...
String[] args) {
System.out.print(
x+" ");
}
}

La¸cos
E esse c´odigo?
1 2 3 4 5 6 7 8...
De novo! Ningu´em
disse ao la¸co o que
testar para parar
String[] args) {
System.out.print(
x+" ");
}
}

La¸cos
E esse código?
1 2 3 4 5 6 7 8...
De novo! Ninguém
disse ao la¸co o que
testar para parar
A condi¸cão de parada
em um la¸co for
também é opcional
String[] args) {
System.out.print(
x+" ");
}
}

La¸cos
Em Suma:
Inicializa¸cão, condi¸cão e atualiza¸cão são opcionais
A condi¸cão aceita qualquer expressão que resulte em
verdadeiro ou falso (expressões lógicas e relacionais)
Inicializa¸cão e atualiza¸cão são apenas códigos
rodados, respectivamente, antes da primeira
itera¸cão e ao fim de cada itera¸cão do la¸co

Videoaula
https://www.youtube.com/watch?v=mOrsP1-wtlM
(parcial)
e
https://www.youtube.com/watch?v=SKoEmpiSXm0

(ACH2001) Introdução à Programação - Aula 09

Recomendados

Recomendados

Mais conteúdo relacionado

Mais de Norton Trevisan Roman

Mais de Norton Trevisan Roman (20)

Último

Último (20)

(ACH2001) Introdução à Programação - Aula 09