Bom sou iniciante estou aprendendo java agora, baixei akela apostila no site da caelum e estou com uma duvida em um laco dentro do outro. Tipo…
for(int n = 1; n <= 4; n ++)
{
for(int i = 1; i <= n; i++)
{
System.out.print("*");
}
System.out.println();
}
*
**
//Alguem poderia me dar uma explicacao mais detalhada como que funciona esse segundo laco?
ou onde eu posso baixar apotilas que explica com mais detalhe…
Cara, os dois laços funcionam exatamente da mesma maneira !!
dê um
System.out.println(i);
e
System.out.println(n);
Que você vai entender.
Opa!
Um livro bem detalhado (tão detalhado que torna cansativo) é o do Deitel.
O primeiro for indica que existe uma iteração (repetição) de 1 até 4.
Ou seja, tudo o que tem dentro desse for vai ser executado 4 vezes.
O segundo for (dentro do primeiro) indica que tudo o que está dentro dele será executado um determinado número de vezes (que depende do valor de n).
Na primeira vez, vai executar 1. Na segunda, 2. Na terceira, 3. E na quarta, 4.
Cola esse código em um arquivo e salva ele como T.java, compila e vê o que sai escrito.
for (int n = 1; n <= 4; n++) {
for (int i = 1; i <= n; i++) {
System.out.println("N = " + n + ", "I = " + i);
}
System.out.println("O valor de n foi mudado");
}Acho que vai dar pra entender melhor.
Abraço.
[editado]
Opz. Desculpa, Tché, não vi seu post.
[/editado]
Relaxa André,
mas é isso mesmo !!!
Sim… deu pra enteder um pouco, mais oque mais t pegando eh na hora de comparar i com n.
nao estou sabendo quais sao os passos que o programa da.
Entende?
e esse livro seria qual edicao? ele ta disponivel para download? eu baixei o 6 Edicao mais eu olhei ele e nao explica nada.
Opa.
Olha só.
public class Leandro {
public static void main(String[] args) {
int i, n;
for (n = 1; n <= 4; n++) {
for (i = 1; i <= n; i++) {
System.out.println("n = " + n + ", i = " + i);
}
System.out.println();
}
}
}Saída
O que acontece?
“i”, no começo, sempre é 1. Se ele for menor ou igual a “n”, executa o que tem dentro do for. Senão (se “i” for 5, por exemplo), sai do for.
Então, no começo, “n” é 1. “i” é 1. Então, como “i” é menor ou igual a “n”, executa (imprime). Na segunda iteração, “i” é 2, então não executa. Na próxima, “n” é 2. “i” começa com 1 e executa. “i” é incrementado (i++ é i = i + 1) e a verificação (i <= n) é feita. Como “i” é menor ou igual a “n”, executa. E assim por diante.
Acho que sua dúvida está na estrutura do for.
for (int i = 0; i <= n; i++)
{
}É a mesma coisa que dizer “i, inicialmente, recebe 0. Se i for menor ou igual a n, o que tem dentro do for é executado (dentro do “{” e “}”). Quando terminar de executar, i é incrementado e a comparação é feita. Se ainda assim for igual ou menor que n, executa. Senão, sai do for”.
E agora. Entendeu?
Vou da mais uma estudada e jaja eu volto a dizer se sim ou nao, mais por enquanto muito obrigo pela atencao.
ele comeca executar o for de dentro o for(int i) para depois ir para o for(int n)?
desculpa talvez sua resposta pode estar muito clara mais nao estou conseguindo entender direito; na hora de conferir as variaveis que estar tensoo :(, nao sei por onde ele comesa verificar as variaveis. 
inicia o programa
entra no laço externo
inicia n com 1
verifica se n(1) é menor ou igual a 4 : verdadeiro
entra no laço interno
inicia i com 1
verifica se i(1) é menor ou igual a n(1) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(2) é menor ou igual a n(1) : falso
sai do laço interno
imprime uma nova linha
incrementa n com 1
volta ao laço externo
verifica se n(2) é menor ou igual a 4 : verdadeiro
entra no laço interno
inicia i com 1
verifica se i(1) é menor ou igual a n(2) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(2) é menor ou igual a n(2) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(3) é menor ou igual a n(2) : falso
sai do laço interno
imprime uma nova linha
incrementa n com 1
volta ao laço externo
verifica se n(3) é menor ou igual a 4 : verdadeiro
entra no laço interno
inicia i com 1
verifica se i(1) é menor ou igual a n(3) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(2) é menor ou igual a n(3) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(3) é menor ou igual a n(3) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(4) é menor ou igual a n(3) : falso
sai do laço interno
imprime uma nova linha
incrementa n com 1
volta ao laço externo
verifica se n(4) é menor ou igual a 4 : verdadeiro
entra no laço interno
inicia i com 1
verifica se i(1) é menor ou igual a n(4) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(2) é menor ou igual a n(4) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(3) é menor ou igual a n(4) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(4) é menor ou igual a n(4) : verdadeiro
imprime *
incrementa i com 1
volta ao laço interno
verifica se i(5) é menor ou igual a n(4) : falso
sai do laço interno
imprime uma nova linha
incrementa n com 1
volta ao laço externo
verifica se n(5) é menor ou igual a 4 : falso
sai do laço externo
sai do programa
O Bruno mostrou o processo de execução…
Mas caso você ainda não tenha entendido, vou tentar explicar mais algo:
for(int n = 1; n <= 4; n ++) // "for 1"
{
for(int i = 1; i <= n; i++) // "for 2"
{
System.out.print("*");
}
System.out.println();
}
Me parece que o que você não está entendendo é a ordem de execução dos processos.
Quando você executa o programa, ele começa pelo for 1…
Cada passagem pelo for 1 irá executar a instrução do for 2 ((System.out.print("*")
“n” vezes (onde “n” é o número da passagem pelo for 1), daí depois de concluída a passagem pelo for 2 irá pular uma linha ((System.out.println();), incrementar “n” em 1 até que atinja 4 e daí encerrar a execução.
As instruções do for 1 são executadas apenas 4 vezes (n = 1, n = 2, n = 3 e n = 4).
O for 2 está contido no for 1; as do for 2 são executadas “n” vezes a cada passagem pelo for 1 (na primeira passagem pelo for 1 uma vez, na segunda duas, na terceira três e na quarta quatro)
Não sei se consegui explicar direito…
mas espero ter ajudado 
Faço as palavras dos usuários acima, as minhas.
Ele verifica primeiro se o n é menor ou igual a 4. Se for, ele vai executar o for de dentro. Então tipo, no for, primeiro é atribuído (na primeira execução do for), depois é verificado. Executa o que tem dentro e incrementa. Verifica novamente e, se verdadeiro, executa o que tem dentro e incrementa.
Não sei se você já aprendeu o while, mas seria basicamente assim:
int n = 1;
int i;
while (n <= 4) {
i = 1;
while (i <= n) {
// faz alguma coisa
i++;
}
n++;
}Acho que mais compliquei fazendo assim, mas é mais ou menos dessa forma que acontece.
Já que tem tanta gente tem me ajudando nesse forum,vou me meter um pouco e tentar ajudar alguem tmb!
Assim,vc primeiramente entende o primeiro for,que é o laço de n.
Nele é verificado se o valor ATUAL de n é menor ou igual a 4,
se for positivo,ele passa a proxima etapa que é justamente o segundo for que é o laço de i.
No for(i),a verificaçao é, caso o for(i) seja menor que o for(n),entao ele o incrementa na medida correta(i = i+1)
e o for(i),só roda até a medida que for(i) possa ser iguar ao for(n),
ao termino do for (i),o programa volta para o for(n),que faz outra verificaça(se n,ainda é menor ou igual a 4) e com base nisso ele continua ou interrompe o programa.
Algumas coisinhas para te ajudar a entender a logica,só quem pode parar o programa é o for(n),pois ele é o laço principal,entao quando ele chegar a 4,o programa se encerra.
Na estrutura de controle FOR,a ordem entre parenteses pode ser entendida como, n começa com 1(n = 1;),se n for menor ou igual a 4 faça(n <= 4;), acrescente mais um a n(n++).
espero ter ajudado!!
Bom primeiramente gostaria de agradecer a atenção de todos que leram e responderam e deu pra tirar a duvida ja agora posso continuar em frente, as resposta de voces foram bastante clara, muito obrigado pela atenção de vcs, Um grande abraço e espero um dia poder ajudar tambem assim como vcs me ajudaram , Um abraço a todos.