Campo Minado em Java: código comentado

Vamos agora explicar, em detalhes, como fazer, entender e programar toda a lógica de um campo minado na linguagem de programação Java.

O código do jogo se encontra em nosso artigo passado de nosso curso online de Java:
Jogo: Campo Minado em Java

Jogo: Campo Minado em Java

Dando continuidade aos games que estamos fazendo, e ensinando a fazer, vamos agora mostrar como fazer e programar o famoso jogo Campo Minado em Java.

Se não acompanhou os outros jogos feitos em nosso curso de Java, veja:

 Como fazer o Jogo da Velha em Java
 Como fazer o jogo Batalha Naval em Java

Aqui mostraremos as classes e código do jogo, no próximo artigo vamos explicar em detalhes como programar o jogo:


Código comentado sobre a criação do Campo Minado em Java

• Java Progressivo em PDF(download da Apostila)

Como jogar o nosso Campo Minado em Java

Existe um tabuleiro 8x8, onde estão localizadas 10 minas.
A cada rodada você irá fornecer o número da linha e da coluna (ou seja, números de 1 até 8).

Caso exista uma mina naquele lugar, você perde o jogo.

Caso não exista uma mina naquela posição, será exibido número naquele local e números nos locais vizinhos aquele que você escolheu, exceto onde há minas.

Esses números informam quantos minas existem ao redor daquele local.

Por exemplo, se você escolhe um local e aparece o número '2' lá, é porque existem duas minas nas vizinhanças daquele local. Vale salientar que 'ao redor' e 'vizinhança' significam todos os blocos ao redor, incluindo na diagonais.

Objetivo: Deixar os 10 campos que possuem minas livres. Ou seja, onde você deduzir que existe mina, não marque, simplesmente deixe o '_' lá, pois quando existem 10 underlines você ganhará o jogo.

Código do jogo Campo Minado em Java

-->campoMinado.java 

public class campoMinado {
    public static void main(String[] args) {
        Jogo jogo = new Jogo();

    }

}

-->Jogo.java

public class Jogo {
    private Tabuleiro board;
    boolean terminar = false;
    boolean ganhou = false;
    int[] jogada;
    int rodada=0;
    
    public Jogo(){
        board = new Tabuleiro();
        Jogar(board);
        jogada = new int[2];
    }
    
    public void Jogar(Tabuleiro board){
        do{
            rodada++;
            System.out.println("Rodada "+rodada);
            board.exibe();
            terminar = board.setPosicao();
            
            if(!terminar){
                board.abrirVizinhas();
                terminar = board.ganhou();
            }
            
        }while(!terminar);
        
        if(!board.ganhou()){
            System.out.println("Havia uma mina ! Você perdeu!");
            board.exibeMinas();
        } else {
            System.out.println("Parabéns, você deixou os 8 campos de minas livres em "+rodada+" rodadas");
            board.exibeMinas();
        }
    }
}

-->Tabuleiro.java

import java.util.Random;
import java.util.Scanner;

public class Tabuleiro {
    private int[][] minas;
    private char[][] tabuleiro;
    private int linha, coluna;
    Random random = new Random();
    Scanner entrada = new Scanner(System.in);
    
    public Tabuleiro(){
        minas = new int[10][10];
        tabuleiro = new char[10][10];
        iniciaMinas(); // coloca 0 em todas as posições do tabuleiro de minas
        sorteiaMinas(); //coloca, aleatoriamente, 10 minas no tabuleiro de minas
        preencheDicas();//preenche o tabuleiro de minas com o número de minas vizinhas
        iniciaTabuleiro();//inicia o tabuleiro de exibição com _
        
    }
    
    public boolean ganhou(){
        int count=0;
        for(int line = 1 ; line < 9 ; line++)
            for(int column = 1 ; column < 9 ; column++)
                if(tabuleiro[line][column]=='_')
                    count++;
        if(count == 10)
            return true;
        else
            return false;                
    }
    
    public void abrirVizinhas(){
        for(int i=-1 ; i<2 ; i++)
            for(int j=-1 ; j<2 ; j++)
                if( (minas[linha+i][coluna+j] != -1) && (linha != 0 && linha != 9 && coluna != 0 && coluna != 9) ){
                    tabuleiro[linha+i][coluna+j]=Character.forDigit(minas[linha+i][coluna+j], 10);
                }
    }
    
    public int getPosicao(int linha, int coluna){
        return minas[linha][coluna];
    }
    
    public boolean setPosicao(){
            
            do{
                System.out.print("\nLinha: "); 
                linha = entrada.nextInt();
                System.out.print("Coluna: "); 
                coluna = entrada.nextInt();
                
                if( (tabuleiro[linha][coluna] != '_') && ((linha < 9 && linha > 0) && (coluna < 9 && coluna > 0)))
                    System.out.println("Esse campo já está sendo exibido");
                
                if( linha < 1 || linha > 8 || coluna < 1 || coluna > 8)
                    System.out.println("Escolha números de 1 até 8");
                
            }while((linha < 1 && linha > 8) && (coluna < 1 && coluna > 8) || (tabuleiro[linha][coluna] != '_') );
            
            if(getPosicao(linha, coluna)== -1)
                return true;
            else
                return false;
            
    }
    
    public void exibe(){
        System.out.println("\n     Linhas");
        for(int linha = 8 ; linha > 0 ; linha--){
            System.out.print("       "+linha + " ");
            
            for(int coluna = 1 ; coluna < 9 ; coluna++){
                    System.out.print("   "+ tabuleiro[linha][coluna]);
            }
                
            System.out.println();
        }
            
        System.out.println("\n            1   2   3   4   5   6   7   8");
        System.out.println("                      Colunas");
        
    }
    
    public void preencheDicas(){
        for(int line=1 ; line < 9 ; line++)
            for(int column=1 ; column < 9 ; column++){
                
                    for(int i=-1 ; i<=1 ; i++)
                        for(int j=-1 ; j<=1 ; j++)
                            if(minas[line][column] != -1)
                                if(minas[line+i][column+j] == -1)
                                    minas[line][column]++;
                
            }
            
    }
    
    public void exibeMinas(){
        for(int i=1 ; i < 9; i++)
            for(int j=1 ; j < 9 ; j++)
                if(minas[i][j] == -1)
                    tabuleiro[i][j]='*';
        
        exibe();
    }
    
    public void iniciaTabuleiro(){
        for(int i=1 ; i<minas.length ; i++)
            for(int j=1 ; j<minas.length ; j++)
                tabuleiro[i][j]= '_';
    }
    
    public void iniciaMinas(){
        for(int i=0 ; i<minas.length ; i++)
            for(int j=0 ; j<minas.length ; j++)
                minas[i][j]=0;
    }
    
    public void sorteiaMinas(){
        boolean sorteado;
        int linha, coluna;
        for(int i=0 ; i<10 ; i++){
            
            do{
                linha = random.nextInt(8) + 1;
                coluna = random.nextInt(8) + 1;
                
                if(minas[linha][coluna] == -1)
                    sorteado=true;
                else
                    sorteado = false;
            }while(sorteado);
            
            minas[linha][coluna] = -1;
        }
    }
}

Jogo: Batalha Naval em Java

• 
  Java Progressivo em PDF(download da Apostila)

Agora que aprendemos como passar arrays (de qualquer dimensão) para métodos, já podemos fazer algo mais útil. Vamos fazer o famoso batalha naval, no modo texto.

Usaremos tudo que aprendemos até o momento em nosso curso de Java: if else, laço do while, laço for, métodos, números aleatórios, arrays, arrays multidimensionais e muita criatividade.

Jogo: adivinhe o número sorteado pelo computador

Jogar é bom...mas jogar um jogo que você mesmo criou, é um prazer que poucos tem.

A linguagem de programação Java é conhecida por ser bastante usada para criação de jogos. Muito provavelmente você já jogou algum jogo, mesmo que seja aqueles online, feito em Java.

Com base nos conhecimentos obtidos em nosso curso online de Java, já é possível criarmos um jogo.
Embora bem simples, é bem engenhoso e legal:

O computador vai sortear um número, entre 1 e 1000 e você terá que adivinhar que número é esse.
A cada rodada você entra com um número e o computador vai te dar as dicas, dizendo se o número que você digitou é maior ou menor ao número que ele sorteou.

Termina quando você acerta, e ele guarda o número de tentativas que você fez. Consegue bater seu próprio record?
Sabe qual é a melhor estratégia?

• Estudar offline pela apostila Java Progressivo

PASSO 1: Computador gera um número entre 1 e 1000

Para gerar um número, necessitamos importar a classe Random:
import java.util.Random;

Precisamos criar um objeto do tipo Random para que ele possa gerar os números, vamos chamar de 'geradorDeAleatorios':
Random geradorDeAleatorios = new Random();

Agora precisamos que esse gerador nos forneça um número aleatório no intervalo de 1000 números. Vamos armazenas esse valor na variável inteira 'sorteado':
sorteado = geradorDeAleatorios.nextInt(1000);

Porém, dessa maneira, ele vai gerar um número entre 0 e 999. Para ser entre 1 e 1000, somamos 1:
sorteado = geradorDeAleatorios.nextInt(1000) + 1;

PASSO 2: looping principal do programa

Número gerado!
Agora o usuário vai dar os palpites. Como o usuário vai tentar adivinhar o número pelo menos uma vez, o looping precisa rodar pelo menos uma vez. Portanto, usamos o do ... while.

Esse laço ocorre enquanto não adivinharmos o número, ou seja, enquanto nosso palpite for diferente do número sorteado:
do{
 // laço
}while( palpite != sorteado);

PASSO 3: tentativa incrementada

A cada tentativa que damos, a variável 'tentativas', que contabiliza nossas tentativas é incrementada em uma unidade:
tentativas++;

PASSO 4: analisando o palpite

Vamos mandar 3 números para o método dica(): o nosso palpite, o número sorteado pelo computador e o número de tentativas que fizemos.
Para o nosso jogo dar a dica certa, usaremos os testes condicionais if else.

O método testa se o nosso palpite foi maior que o número gerado pelo computador, se for, dá tal dica:
if(palpite > numero){
System.out.println("Seu palpite é maior que o número sorteado.");

Case não seja, o palpite será menor ou igual ao número sorteado. Então vai pro else.
Caso o palpite do usuário seja menor que o número sorteado pelo computador, tal dica é exibida:
if(palpite < numero){
System.out.println("Seu palpite é menor que o número sorteado.");

Por fim, se o palpite não for maior nem menor que o número sorteado é porque é igual.
Ora, se é igual, você acertou e é exibida a mensagem de acerto e o número de tentativas realizadas:
System.out.println("Parabéns, você acertou! O número era " + numero);
System.out.println("Você tentou " + tentativas + " vezes antes de acertar!");

Quando você acerta, o método dica não é mais chamado, pois 'palpite != sorteado' retornará um valor falso, já que estes números serão iguais (palpite = sorteado), então o laço acaba, acabando o nosso jogo em Java.

Nosso jogo/aplicativo Java ficará assim:

import java.util.Random;
import java.util.Scanner;

public class JogoAdivinhaNumero {

    public static void dica(int palpite, int numero, int tentativas){
        if(palpite > numero){
            System.out.println("Seu palpite é maior que o número sorteado.");
        } else {
            if(palpite < numero){
                    System.out.println("Seu palpite é menor que o número sorteado.");
            } else {
                System.out.println("Parabéns, você acertou! O número era " + numero);
                System.out.println("Você tentou " + tentativas + " vezes antes de acertar!");
            }
        }
            
    }
    
    public static void main(String[] args) {
        int palpite=0, 
            sorteado, 
            tentativas=0;
        
        Scanner entrada = new Scanner(System.in);
        
        Random geradorDeAleatorios = new Random();
        sorteado = geradorDeAleatorios.nextInt(1000) + 1;
        System.out.println("Número entre 1 e 1000 sorteado!");
        
        do{
            System.out.printf("\n\n\n\n-----------------\n");
            System.out.println("Número de tentativas: " + tentativas);
            
            System.out.print("Qual seu palpite: ");
            palpite = entrada.nextInt();
            
            tentativas++;
            
            dica(palpite,sorteado, tentativas);
        }while (palpite != sorteado);

    }

}

Programa que diz quantos dias o mês possui

Exercício:
Crie um programa em Java que receba um inteiro, de 1 até 12, representando os meses do ano e retorne o número de dias do mês.
Use switch e não use break. 
Use acúmulo de case.





Inicialmente, a variável 'dias' é declarada como tendo 31 dias.

Caso seja o mês 4, 6, 9 ou 11, é subtraído 1 da variável 'dias'  e o programa informa que esses meses possuem 30 dias.

Caso seja o mês 2, é subtraído 2  de 'dias', ficando 28 dias para o mês de fevereiro.

Caso não seja nenhum desses meses, não cai no switch, então continua com 31 dias (que são os meses 1, 3, 5, 7, 8, 10 e 12).

Código:

import java.util.Scanner;

public class months {
    public static void main(String[] args) {
        int mes, dias=31;
        Scanner entrada = new Scanner(System.in);
        
        System.out.print("Digite o mês [1-12]: ");
        mes = entrada.nextInt();
        
        if(mes>12 || mes<1){
            System.out.println("Mês inválido");
            return;
        }
        
        switch( mes )
        {
            // fevereiro: subtraímos 2 dias aqui e 1 dia no próximo case
            case 2: 
                dias -=2;
                
            //meses que possuem 30 dias: só subtraímos 1 dia
            case 4: case 6: case 9: case 11:
                dias--;

        }
        
        System.out.printf("O mês %d possui %d dias", mes, dias);
    }
}

Problemas envolvendo laços

Dizer 'use isso' ou 'use aquilo' é fácil.
Agora teste sua criatividade Javeana e invente seu jeito para resolver os seguintes problemas, mas se lembre de usar:

• if else
• while
• for
• do ... while 
• switch.

para exercitar seu aprendizado.

• Estudar offline pela apostila Java Progressivo

O comando switch: fazendo escolhas em Java

No artigo sobre o laço do ... while de nossa apostila online Java Progressivo, mostramos como criar um menu simples.

Porém, o Java possui um recurso específico para esse propósito, que nos permite optar por algo, dependendo do que tenhamos digitado, é o comando switch.

• Java Progressivo em PDF(download da Apostila)

Os comandos break e continue: interrompendo e alterando fluxos e loopings

Nesta parte de nossa apostila online iremos ver os comandos break e continue, do Java, que servem para nos propiciar um maior controle sobre o fluxo dos aplicativos, especialmente das iterações dos loopings.

• Apostila de Java em PDF

Para que servem os comandos BREAK e CONTINUE em Java

Geralmente, em nossos programas de Java, iremos usar os laços while, for e do ... while para procurar algum ítem, número ou checar alguma condição.

Por exemplo, imagine que você foi contratado para fazer um programa, em Java, claro, para um banco.
Em um momento do aplicativo, o cliente insere o número de sua conta e o programa vai buscar esse número no banco de dados do sistema, que tem milhões de clientes cadastrados.
Ele vai fazer essa busca através de um looping.

Porém, imagine que o programa encontra os dados do cliente logo no começo, logo nas primeiras posições.
E aí, vai checar todo o resto do banco de dados?
Claro que não, isso seria perda de tempo.

É aí que entram os comandos break e continue. Esse seria um bom exemplo onde daríamos um 'break' no laço, pois já encontramos o que queríamos.

O comando break

Break significa quebrar, parar, frear, interromper. E é isso que se faz.
Quando o Java encontra esse comando pela frente, ele interrompe o laço/estrutura de controle ATUAL, como o while, for, do ... while e o switch (que veremos no próximo artigo da apostila).

Vamos mostrar um exemplo do uso do break através de um exemplo matemático.

Exemplo de uso:

Suponha que você é um cientista e quer saber se entre os números 1 e um milhão existe um número que é múltiplo de 17 e 19, ao mesmo tempo.
Ou seja, queremos saber se existe um número entre 1 e um milhão que deixa resto 0 na divisão por 17 e por 19.
Caso exista, o imprima. E só imprima o menor.

Poderíamos fazer um laço de 1 até 1 milhão, e testar isso através de um for.
Ok, é uma solução. O principal na vida profissional de um programador é saber resolver o problema.

Vamos usar um método chamado 'currentTimeMillis()', que retorna um tipo 'long' com o tempo atual do sistema em mili segundos. Vamos declarar esse tipo no início e ao fim do laço, e depois subtrair esses valores, assim teremos o tempo de execução do programa.
Após imprimir o menor número, o boolean se torna falso, assim só o primeiro número é impresso.

Veja:

public class breakTest {
    public static void main(String[] args) {
        long i = System.currentTimeMillis();
        boolean imprimir = true;
        
        for(int count=1 ; count <=1000000 ; count++){
            if((count % 17 == 0) && (count % 19 == 0))
                if(imprimir){
                    System.out.println(count);
                    imprimir=false;
                }
        }

        System.out.println("Tempo de execução, em milisegundos: "+ (System.currentTimeMillis() -i));
    }

}

Em minha máquina deu:
26 mili segundos


Mas se você quiser ser um bom profissional, não basta só saber resolver. Tem que resolver e da melhor maneira possível.
Note que que o menor número achado é 323, e o laço vai até 1 milhão! Ou seja, ele percorre de 324 até 1 milhão à toa, pois já achou o número desejado!

Ora, se ele já achou o número, 323, vamos fazer com que o laço pare, usando o comando break:

public class break {
    public static void main(String[] args) {
        long i = System.currentTimeMillis();
        
        for(int count=1 ; count <=1000000 ; count++){
            if((count % 17 == 0) && (count % 19 == 0)){
                System.out.println(count);
                break;
            }
        }

        System.out.println("Tempo de execução, em milisegundos: "+ (System.currentTimeMillis() -i));
    }

}

8 mili segundos
Menos de um terço do tempo!

Você pode pensar "Ah, de 26 mili segundos para 8 mili segundos a diferença é insignificante".
Concordo com você.
Porém, no futuro você fará aplicações maiores e que levam mais tempo, e esses pequenos detalhes farão a diferença.
Por exemplo, existem métodos que, durante um game são facilmente chamados milhões de vezes.
Multiplique essa diferença 'insignificante' de alguns mili segundos por milhões de vezes e terá um belo de um 'lag', ou lentidão. Isso se chama otimizar: fazer da maneira mais eficiente possível.

Daremos bastante enfoque para as otimizações em nosso curso de Java, como verá no exemplo a seguir.

O comando continue

Como o nome diz, ele 'continua' o laço. O comando break interrompe o laço, já o continue interrompe somente a iteração atual.

Não basta porém ser um bom profissional. Você está no curso Java Progressivo, você tem que ser um dos melhores!
Nós vamos otimizar o código passado.

Note uma coisa, queremos achar um número que seja múltiplo de 17 e 19. Ora, tal número não pode ser par, pois 17 e 19 são ímpares.
Para cada número 'count', estamos fazendo dois testes: se é múltiplo de 17 e se é múltiplo de 19.

Vamos otimizar da seguinte maneira, vamos fazer um só teste: vamos checar se é múltiplo de 2. Caso seja, nem adianta testar se é múltiplo de 17 e 19, podemos pular essa iteração.
E como pulamos uma iteração? Com o comando continue!

Veja como fica:

public class continueTest {
    public static void main(String[] args) {
        long i = System.currentTimeMillis();
        
        for(int count=1 ; count <=1000000 ; count++){
            if(count % 2 == 0){
                continue;
            }
            if((count % 17 == 0) && (count % 19 == 0)){
                System.out.println(count);
                break;
            }
            
        }

        System.out.println("Tempo de execução, em milisegundos: "+ (System.currentTimeMillis() -i));
    }

}

E temos o impressionante tempo de 1mili segundo!
De 26 mili segundos, fomos para 1 mili segundo! Impressionante esse Java, não?

O laço do ... while: O laço que sempre acontece...pelo menos uma vez

Veremos nesse artigo mais um importante laço em Java, o laço do...while, que sempre executa o código do laço pelo menos uma vez, independente da condição do while ser true ou false.

Um dos maiores problemas do laço while é que ele só é executado se a condição contida nele for true.
Porém, muitas vezes, em nossos aplicativos Java, não podemos garantir que essa condição será sempre verdadeira ou queremos que o laço seja executado PELO MENOS UMA VEZ, e caso o usuário decida, o laço vai continuar ou não.

Então, o diferencial do laço do while é que ele sempre executa, sempre inicia o laço.

• Apostila de Java em PDF

Como usar o laço DO WHILE em Java

A sintaxe do laço do .. while em Java, é a seguinte

do
{
 //esse código será executado pelo menos uma vez    
} while( condição );

Seu uso é bem simples e intuitivo, visto que o laço while nós já conhecemos.
O 'do' do inglês quer dizer 'faça'.
Ou seja, esse laço nos diz 'faça isso enquanto 'condição' for verdadeira'

Exemplos de uso

Um dos exemplos de uso é para exibir o menu. Ora, o menu tem que ser exibido pelo menos uma vez.
Se depois, você quiser sair, é opção sua.
Mas que ele tem que ser exibido ao menos uma vez, ele tem. E uma boa saída para fazer isso, em Java, é usar o laço do ... while.

No exemplo a seguir, o menu é mostrado.
Para parar de exibir o menu, basta digitar 0, que o boolean irá se tornar 'false' e o laço não mais se repetirá, pois a condição dentro do while será falsa.

Caso a entrada do usuário seja qualquer outro número que não 0, a variável boolean continua 'true', como foi declarada e o laço continuará a rodar (ou seja, o menu continua a ser exibido).

O trecho: System.out.printf("\n\n\n\n\n\n");
É simplesmente para limpar a tela.

Teste para ver:

import java.util.Scanner;

public class DoWhile {
    public static void main(String[] args) {
        boolean continuar=true;
        int opcao;
        Scanner entrada = new Scanner(System.in);
        do
        {
            System.out.println("\t\tMenu de opções do curso Java Progressivo:");
            System.out.println("\t1. Ver o menu");
            System.out.println("\t2. Ler o menu");
            System.out.println("\t3. Repetir o menu");
            System.out.println("\t4. Tudo de novo");
            System.out.println("\t5. Não li, pode repetir?");
            System.out.println("\t0. Sair");
            
            System.out.print("\nInsira sua opção: ");
            opcao = entrada.nextInt();
            
            if(opcao == 0){
                continuar = false;
                System.out.println("Programa finalizado.");
            }
            else{
                System.out.printf("\n\n\n\n\n\n");
            }
            
        } while( continuar );
    }
}

Embora este seja um exemplo simples, ele será a base para vários menus que iremos fazer em nosso Curso de Java.
Por exemplo, como um sistema de cadastro de alunos e um esquema de caixa eletrônico.

Questões usando o laço for

• Baixar a Apostila Java Progressivo

Exercícios sobre o laço FOR em Java

Usando o laço for, faça as seguintes questões em Java:

0. Programa em Java dos patinhos da Xuxa
Xuxa, a rainha dos baixinhos, criou uma música que tem o segunte formato:

n patinhos foram passear
Além das montanhas
Para brincar
A mamãe gritou: Quá, quá, quá, quá
Mas só n-1 patinhos voltaram de lá.

Que se repete até nenhum patinho voltar de lá.

Ao final, todos os patinhos voltam:

A mamãe patinha foi procurar
Além das montanhas
Na beira do mar
A mamãe gritou: Quá, quá, quá, quá
E os n patinhos voltaram de lá.

Crie um programa em Java que recebe um inteiro positivo do usuário e exibe a música inteira na tela, onde o inteiro recebido representa o número inicial n de patinhos que foram passear.

1. Programa em Java que mostra os números ímpares
Escreva um aplicativo em Java mostra todos os números ímpares de 1 até 100.

2. Programa em Java que mostra os números pares
Escreva um aplicativo em Java mostra todos os números pares de 1 até 100.

3. Programa em Java que mostra os números pares e ímpares 
Escreva um aplicativo em Java que recebe inteiro e mostra os números pares e ímpares (separados), de 1 até esse inteiro.
4. Programa em Java que calcula a média das notas de uma turma
Escreva um programa que pergunte ao usuário quantos alunos tem na sala dele.
Em seguida, através de um laço for, pede ao usuário para que entre com as notas de todos os alunos da sala, um por vez.

Por fim, o programa mostra a média, aritmética, da turma.

5. Achando o maior número
Achar o maior, menor, média e organizar números ou sequências são os algoritmos mais importantes e estudados em Computação. Em Java não poderia ser diferente.
Em nosso curso, obviamente, também não será diferente.

Escreva um programa em Java que solicita 10 números ao usuário, através de um laço for, e ao final
mostre qual destes números é o maior.

6. Achando os dois maiores números

Escreva um programa em Java que solicita 10 números ao usuário, através de um laço for, e ao final
mostre os dois maiores números digitados pelo usuário.

7. Quadrado de asteriscos

Escreva um programa que lê o tamanho do lado de um quadrado e imprime um quadrado daquele tamanho com asteriscos. Seu programa deve funcionar para quadrados com lados de todos os tamanhos entre 1 e 20.
Para lado igual a 5:
*****
*****
*****
*****
*****
8. Quadrado de asteriscos e espaços em branco

Escreva um programa que lê o tamanho do lado de um quadrado e imprime um quadrado daquele tamanho com asteriscos e espaços em branco. Seu programa deve funcionar para quadrados com lados de todos os tamanhos entre 1 e 20.
Para lado igual a 5:
*****
*    *
*    *
*    *
*****

9. Construa um aplicativo em Java para gerar 20 números de 1000 a 1999 e mostrar aqueles que divididos por 11 deixam resto 5.
Solução

Aplicativo: Determina as raízes de uma equação do segundo grau

Crie um programa, em Java, que receba os coeficientes de uma equação do 2o grau e retorne suas raízes.

Um equação do segundo grau é uma equação onde:
ax² + bx + c = 0 , com 'a' diferente de 0

• Apostila completa Java Progressivo

Laço FOR: tendo um maior controle sobre as repetições

Veremos agora o tipo de laço mais importante e usado em Java, que será sempre visto nos código de nosso curso: o laço for

Sua fama se deve ao poder que temos por conta dos detalhes que o laço for é capaz de receber, sendo possível ter um maior controle sobre as repetições.

• Estudar offline pela apostila Java Progressivo

Diferenças entre o while e o for: para que serve o laço for em Java

Geralmente, o que é possível fazer usando o for, é possível fazer usando o o laço while em Java.
Então, naturalmente vem a pergunta: por que e para que serve, então, o laço for?

É o mesmo que perguntar 'por que usar a++' se podemos usar 'a=a+1'.
Simples: por questão de simplicidade e praticidade.

Nós, programadores Java, devemos procurar sempre a máxima eficiência. Fazer as coisas da maneira mais simples possível.
O uso do for se deve aos seguintes dois fatos, que você deve ter notado, caso tenha feito os exercícios sobre o laço while e caso tenha visto os exemplos do artigo while:
1. Geralmente existe um ponto de partida, um contador inicial para o laço while
2. Geralmente esse contador, ou outro, muda. De modo incrementativo ou decrementativo, até que a condição do while não seja mais satisfeita e o laço termine.

O que o laço for faz é automatizar isso.
Já que na grande maioria das vezes precisaremos desses dois fatores (inicial e de mudança), o laço for irá prover isso.

Como usar o laço for em Java

A sintaxe do laço for é a seguinte:

for(cond inicial; teste condicional ; apos iteraçao){
    //código
}

O laço funciona da seguinte maneira:
O laço se inicia pela condição inicial. Geralmente se inicia o contador. Esse primeiro estágio SEMPRE acontece.

O segundo estágio é o teste da condição do laço, um simples teste condicional. Caso seja verdade, o código é executado.
Ao término de execução do código, ocorre o fator de mudança, que geralmente é um incremento ou decremento, sempre após cada iteração do looping,

Depois a condição é testada novamente. Caso retorne 'true', o código é executado.
Ao término de execução do código, sempre ocorre o fator de mudança...e assim sucessivamente.

Faremos 3 exemplos que mostram bem o exemplo do uso e flexibilidade laço for.
É importante que você aprenda bem, pois eles serão muito usados em nosso curso de Java.

Exemplo 1: Contando até 10, com laço for

public class for1 {
    public static void main(String[] args) {
        for(int count=1 ; count <= 10 ; count++){
            System.out.println(count);
        }
    }

}

Nesse exemplo, fiz questão de mostrar uma importante característica do laço for: a declaração dentro do for
Note que, na condição inicial do contador, foi declarado o inteiro 'count', que foi usado no laço.

Como funciona:
A primeira coisa que acontece é a condição inicial. No nosso caso, é criado um inteiro, 'count' e inicializado com o valor 1.
Depois, a condição é testada. Como ela é verdadeira, ele imprime o valor de 'count', que é 1.

Depois 'count' é incrementada e vira 2.
Depois é testada. Como continua ser menor que 10, ela é imprimida. Depois incrementada, testada, imprimida...ela é imprimida até ser 10, pois depois disso ela será incrementada e 'count' será 11, então a condição não será mais verdadeira e o laço for terminará.

Exemplo 2: contagem regressiva, usando o laço for

public class for2{
    public static void main(String[] args) {
        for(int count=10 ; count >= 1; count--){
            System.out.println(count);
        }
    }
}

Esse exemplo serve para mostrar que podemos usar o decremento, não somente o incremento, dentro do laço for.

Como funciona:
A primeira coisa que acontece é a condição inicial. No nosso caso, é criado um inteiro, 'count' e inicializado com o valor 10.

Depois, a condição é testada. Como 'count' é maior ou igual a 1, é verdadeira e se imprime o valor de 'count', que é 10.
Após essa execução, 'count' se torna 9, e continua a ser maior ou igual a 1, e impressa...quando 'count' for 1, ela será impressa, por 1 é maior ou igual a 1.
Porém, ao ser decrementada, se tornará 0 e o laço for terminará.

Exemplo 3: contagem progressiva e regressiva no mesmo laço for

Outra característica do laço for, é que não precisamos usar só uma variável de controle ('count') ou  testar somente uma condição. O código Java para isso é:

public class for3 {
    public static void main(String[] args) {
        for(int sobe=1, desce=10 ; sobe<=10 && desce>=1; sobe++, desce--){
            System.out.printf("%d \t %d \n", sobe, desce);
        }
    }

}

Como funciona:

Declaramos duas variáveis, a 'sobe', que vai ser incrementada e impressa de 1 até 10,
e a variável 'desce' que será decrementada e impressa de 10 até 1.
Dentro do printf usamos o caractere '\t', que é o código ASCII para a tabulação, ou seja, o nosso famoso 'tab'.

Compile e rode esse simples código, verá como é maravilhoso ser programador Java e sua vida fará mais sentido.