Criando alguns desenhos interessantes apenas com Linhas

Para mostrar melhor como usar linhas em programação gráfica em Java, vamos ensinar e mostrar o código de diversos programas que geram belas figuras, como essa abaixo.Para isso, vamos usar o código de nosso aplicativo do artigo sobre desenho de linhas.

Caso não tenha visto, pegue o código em nosso tutorial sobre como criar linhas em Java.
Para criar esses desenhos, vamos apenas alterar o conteúdo do método paintComponent.

• Estudar offline pela apostila Java Progressivo

Herança ou Composição: Qual o melhor?

Acabamos de estudar a Herança, que assim como a Composição, é uma forma de tratar a relação entre os objetos, como eles devem ser vistos e trabalhados.

Talvez agora, como iniciante em nossa apostila de Java, isso não seja motivo de muita preocupação para você, mas certamente no futuro será. E para melhor esclarecer isso, nossa apostila de Java irá falar mais sobre as vantagens e desvantagens de cada uma dessas técnicas.

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;
        }
    }
}

Código comentado sobre como criar um Jogo da Velha em Java

• Baixar a Apostila Java Progressivo

No tutorial passado mostramos um print do Jogo da Velha em Java, modo texto e Humano x Humano, bem como o código de 6 classes necessárias para rodar o programa:
Jogo da Velha em Java

Agora vamos comentar, em detalhes, cada classe, método e idéia que usamos para criar o jogo.

A classe Object: o que é, uso e principais métodos

Agora que já sabemos o que é herança, como a herança se comporta em relação aos construtores, uso do @Override e vimos os modificadores de acesso private, public e protected, vamos apresentar uma classe de suma importância bem como alguns de seus métodos: a classe Object.

• Baixar a Apostila Java Progressivo

Aplicativo: Simulação simples de conta bancária

Aplicativo: Conta bancária/Caixa eletrônico simples em Java

Crie um protótipo de caixa eletrônico na linguagem de programação Java. No início, ele pede seu nome e valor $$ inicial que tem na conta. O programa deve fornecer um número de até 4 dígitos - número da conta - para o usuário (use Random). Esses dados serão usados para criar um objeto da classe "Conta.java"

A seguir, mostra um menu com as opções (esse menu deverá ser um método):
- Extrato: exibe o nome, número da conta, saldo e quantos saques já foram realizados
- Sacar: recebe o valor a ser sacado, informa se pode ser sacado (não pode ficar negativo) e mostra o saldo
- Depositar: recebe o valor a ser depositado e mostra o novo saldo
- Sair

Esse menu aparece até o usuário escolher sair. As outras opções são métodos que devem fazer parte da "Conta.java" (setters e getters). Note que o usuário pode sacar no máximo 5 vezes por dia.

• Apostila de Java em PDF

Obter meu certificado!

Construtor padrão e com parâmetros: o que são, para que servem e como usar

• Você reparou que, no tutorial passado, sobre como declarar e criar classe e instanciar objetos, nós fizemos:

Aluno fulano = new Aluno();

Você reparou como repetimos 'Aluno' duas vezes?
Por que? Não é inútil ou perda de tempo repetir isso?

Em Java - aliás, em programação - nada é à toa (se for, logo eles mudam). Tudo tem um motivo.

Nesse artigo você irá aprender sobre os Construtores (constructors) e saberá o motivo dessa repetição e como usufruir e ganhar muito tempo a partir deles

As explicações e exemplos deste tutorial são baseadas nos outros artigos desta seção:
O que são e para que servem Classes e Objetos em Java
Como criar uma Classe e declarar um Objeto
Acessando e modificando variáveis de Classes e Objetos

• Java Progressivo em PDF(download da Apostila)

O que são construtores/constructor em Java

Quando usamos a keyword 'new' para criar um objeto de uma determinada classe estamos alocando um espaço na memória. Ao fazer isso, o Java requer que algumas variáveis sejam iniciadas com algum valor.
Esse ato de inicializar, ou construir, é feito pelos construtores, que são métodos - que iremos estudar mais a fundo em nossa apostila de Java logo mais.

O Java automaticamente inicializa as variáveis globais quando criamos um objeto de uma classe.
No artigo passado de nossa apostila, fizemos um exemplo com a classe "Aluno", onde criamos três variáveis: "nome", "notaMat" e "notaFis", que são consideradas variáveis globais da classe, pois não fazem parte de nenhum método.

Logo, elas devem ser inicializadas pelo Java. Para você ver como isso realmente acontece, vá na sua classe principal, que contém a 'main', e após a criação do objeto "patropi" da classe "aluno" adicione as seguintes linhas de código, de print, para você ver como essas variáveis da classe já possuem um valor, sem nem mesmo você ter atribuído nada:
Aluno patropi = new Aluno();
System.out.println(patropi.nome);
System.out.println(patropi.notaMat);
System.out.println(patropi.notaFis);

O resultado é:
null
0.0
0.0

Ou seja, por padrão, as strings são iniciadas com valores 'null' (nulos) e valores zeros para números.
Isso é o que ocorre automaticamente, quando nenhum construtor é especificado. Vamos mostrar como especificar construtores.

O que é e como utilizar o construtor padrão em Classes

Construtor é um método, em Java.
Embora não tenhamos estudado métodos ainda, diremos como utilizar. É bem simples, e em breve você aprenderá tudo sobre método em nosso curso de Java.

Métodos são um trecho de código que fazem uma coisa específica, em programação. Se já estudou C ou C++, lá eles são chamados de funções ou de rotinas ou sub-rotinas em outras linguagens, como Perl.

Podemos criar vários construtores. O padrão é aquele que não recebe nenhum parâmetro.
Em termos mais simples, é aquele que não recebe nenhuma informação. Ele sempre vai ser executado quando você criar um objeto.

Para criar um construtor, crie um método com o mesmo nome da classe.
Métodos tem a seguinte sintaxe:
nomeDoMetodo( tipoDoParametro nomeDosParametros) {
 // código dos métodos
}

Como nossa classe se chama "Aluno", nosso método é um construtor dessa classe e ela é padrão (não recebe parâmetros) e é 'public', ficará assim:
public Aluno(){
}

Para melhor visualizar a utilidade do construtor padrão, vamos adicionar um print:

public Aluno(){
        System.out.println("Objeto criado");
}

Ao rodar seu programa, você verá a mensagem "Objeto criado" sendo exibida logo após ter criado o objeto "patropi".

Esse método é chamado construtor default. Ao contrário do que muitos pensam, default não é padrão (embora usemos muito como se fosse).
Default é omissão. Quando estamos omitindo outros construtores - que recebem parâmetro - é esse construtor 'padrão' (default) que será chamado.

Note que ao criar o objeto, usamos "new Aluno();"  - logo, não passamos nenhum parâmetro. Então, chamamos claramente o construtor padrão.

Criando um construtor que recebe parâmetros

No nosso aplicativo que cadastro um aluno, seu nome e duas notas, estamos atribuindo os valores dessas variáveis direto no objeto:
patropi.nome = entrada.nextLine();
patropi.notaMat = entrada.nextDouble();
patropi.notaFis = entrada.nextDouble();

O que vamos fazer agora, para ilustrar como funciona os construtores que recebem parâmetros, é pedir esses dados antes e iniciar o objeto "patropi" com esses dados.
Por exemplo, vamos criar as variáveis "Nome", "NotaMat", "NotaFis" na 'main' e receber esses dados pela Scanner:
Nome = entrada.nextLine();
NotaMat = entrada.nextDouble();
NotaFis = entrada.nextDouble();

Agora vamos criar nosso construtor na classe "Aluno" que recebe esses três parâmetros: uma string e dois doubles.
Ele vai ficar assim:

public Aluno(String Nome, double NotaMat, double NotaFis){
        nome=Nome;
        notaMat=NotaMat;
        notaFis=NotaFis;
}

Isso pode parecer um pouco estranho ou complicado agora, mas quando estudar melhor métodos, fará todo o sentido do mundo e verá como é simples.
O que esse método faz é receber uma string "Nome", dois doubles "NotaMat" e "NotaFis" e atribuir eles aos valores da classe aluno.

Veja que nossa classe tem uma variável string "nome" e dois doubles "notaMat" e "notaFis", que seriam inicializados com 'null' e '0.0', conforme mostramos no início deste tutorial.
O que estamos fazendo com esse método é inicializar estas variáveis com outros valores! E que valores são estes? Ora, são os valores das variáveis "Nome" e "NotaMat" e "NotaFis", que definimos a partir da classe Scanner no método 'main'.

Embora estejamos engatinhando na orientação a objeto, vamos fazer uma coisa interessante e mostrar o quão poderosa e útil essa técnica é. Vamos adicionar na classe uma variável, um double de nome "media", e no construtor vamos adicionar uma linha de código:
media = (notaMat + notaFis)/2;

Ou seja, nosso construtor vai ficar:

public Aluno(String Nome, double NotaMat, double NotaFis){
        nome=Nome;
        notaMat=NotaMat;
        notaFis=NotaFis;
     
        media = (notaMat + notaFis)/2;
}

O que quer dizer isso?
Que quando iniciarmos nosso objeto com as notas, esse método vai automaticamente calcular a média dessas notas!
Você pode pensar "Mas já fazíamos isso na 'main', durante o print. Não é a mesma coisa?".
Imagine que você vai preencher os dados de 20 alunos.

Então vai colocar 20 vezes essa fórmula? Claro que não.
Aí é que reside a beleza das Classes & Objetos. Você declara essa fórmula uma única vez, e poderá usar ela sempre que criar um objeto!
Criou o objeto, iniciou ele com as variáveis, ele vai calcular automaticamente a média!
Para acessar essa variável basta fazer: patropi.media
E ela estará lá, bonitinha para você usar.

Como iniciar Objetos com parâmetros

Agora que criamos nossos métodos construtores padrão e com parâmetros, vamos mostrar como iniciar um objeto com dados.

No construtor padrão, vínhamos fazendo:
Aluno patropi = new Aluno();

Agora, que já temos as variáveis "Nome", "NotaMat" e "NotaFis" e um construtor que está preparado para receber esses três tipos de dados, podemos criar um objeto e lançar essas variáveis:
Aluno patropi = new Aluno( Nome, NotaMat, NotaFis);

Note que você só deve criar esse objeto depois de ter essas variáveis com os valores corretos, senão vai iniciar o objeto com valores errados.

Um detalhe importante é que o nome dessas variáveis, "Nome", "NotaMat" e "NotaFis", não precisam ser iguais aos nomes que declaramos lá no construtor da classe "Aluno". Poderíamos passar:
Aluno patropi = new Aluno( name, math, phys);

Desde que "name" seja uma string e "math" e "phys" doubles. Quando elas 'chegam' no construtor, elas 'chegam' com os nomes "Nome", "NotaMat" e "NotaFis".
Você se acostumará melhor sobre isso quando estudar métodos.

Classes com mais de um construtor

O que ocorre se deixarmos o construtor: Aluno()
e o construtor: public Aluno(String Nome, double NotaMat, double NotaFis)
juntos, na classe "Aluno"?

Nada. Aliás, é até recomendável. É um excelente costume.
Se você iniciar um objeto dessa classe sem nenhum parâmetro, o Java inicia o método construtor padrão (que mostra a mensagem "Objeto criado".
Se iniciar um objeto com 3 parâmetros, ele atribui esses valos que você passou aos valores do objeto e ainda calcula a média.
Você pode ainda criar outros métodos, que recebem só o nome do aluno, só a nota de matemática ou só de a física.

Enfim, os construtores são feitos para inicializar os atributos e preparar o objeto para o uso, seja lá qual for o uso que você queira dar. Se você utilizar vários construtores, o Java é inteligente o suficiente para saber qual método utilizar dependendo dos parâmetros que você passar.
Obviamente se criar dois construtores com a mesma lista de parâmetros, terá problemas.

Para mostrar um exemplo do uso de dois construtores - o padrão e o que recebe 3 parâmetros - , vamos criar dois objetos, o "donaFifi", logo no início, e veremos a mensagem "Objeto criado".
Depois pedimos os dados do aluno patropi e inicializamos o objeto "patropi" com esses dados. Em seguida, usamos as variáveis do objeto desse aluno, inclusive sua média, que foi calcula pelo construtor.

Veja como ficou o código:

PrimeiraClasse.java

import java.util.Scanner;
        
public class PrimeiraClasse {

    public static void main(String[] args) {
        Aluno donaFifi = new Aluno();
        String nome;
        Double notaMat,
               notaFis;
        
        Scanner entrada = new Scanner (System.in);
        
        System.out.print("Nome do aluno: ");
        nome = entrada.nextLine();
        
        System.out.print("Nota em Matemática: ");
        notaMat = entrada.nextDouble();
        
        System.out.print("Nota em Física: ");
        notaFis = entrada.nextDouble();
        
        Aluno patropi = new Aluno(nome, notaMat, notaFis);
        System.out.printf("O aluno \"%s\" tirou %2.2f em Matemática, "
                + "%2.2f em Física e obteve média %2.2f\n", patropi.nome,
                                                            patropi.notaMat,
                                                            patropi.notaFis,
                                                            patropi.media);
    }
}

Aluno.java

public class Aluno {
    public String nome;
    public double notaMat,
                  notaFis,
                  media;
   
    public Aluno(){
        System.out.println("Objeto criado");
    }
   
    public Aluno(String Nome, double NotaMat, double NotaFis){
        nome=Nome;
        notaMat=NotaMat;
        notaFis=NotaFis;
       
        media = (notaMat + notaFis)/2;
    }
}

Sobrecarga de métodos (method overloading): declarando métodos com o mesmo nome

Em nosso artigo sobre parâmetros e argumentos em Java, mostramos um exemplo sobre um método que recebe um número e retorna o quadrado desse número.

Porém esse método tem uma limitação: ele só recebia inteiros.
E se você quiser criar métodos com float? double?

Faça uma sobrecarga.

• Java Progressivo em PDF(download da Apostila)

Overloading ou sobrecarga em Java

O termo sobrecarga vem do fato de declararmos vários métodos com o mesmo nome, estamos carregando o aplicativo com o 'mesmo' método.
A única diferença entre esses métodos são seus parâmetros e/ou tipo de retorno.

Por exemplo, vamos declarar, num mesmo aplicativo, dois métodos quadrados: um que recebe e retorna inteiros e outro que recebe e retorna double.

 public static int quadrado(int num){
  int quadrado;
  quadrado = num * num;
  return quadrado;
 }



  public static double quadrado(double num){
  double quadrado;
  quadrado = num * num;
  return quadrado;
 }

Quando declaramos estes dois métodos, estamos fazendo umas sobrecarga de métodos, ou method overloading em Java.
O que acontece, então, quando fazemos o chamado da função? Já que existem duas.

Embora os nomes sejam os mesmos, elas atuam de forma diferentes e ocupam espaços diferentes em memória, pois estão lidando com tipos diferentes de variáveis.

Quando invocamos o método com um inteiro como um argumento, o Java é inteligente o suficiente para invocar corretamente o método que foi declarado com inteiro como parâmetro.
Caso invoquemos o método usando um double como um argumento, o method a ser executado será aquele que foi declarado com o tipo double em seu parâmetro.

Veja:

public class Sobrecarga {
    
    public static int quadrado(int num){
        int quadrado;
        quadrado = num * num;
        return quadrado;
    }

    public static double quadrado(double num){
        double quadrado;
        quadrado = num * num;
        return quadrado;
    }
    
    public static void main(String[] args){
        System.out.println("Inteiro 2 ao quadrado: " + quadrado(2));
        System.out.println("Double PI ao quadrado: " + quadrado( Math.PI ));
    }

}

Parâmetros e Argumentos: passando informações para os métodos

Em nosso curso de Java, até o momento, os nossos métodos faziam coisas bem específicas, como exibir uma string, um menu ou realizavam cálculos matemáticos.
Isso, na prática, não é muito útil.

• Download da Apostila Java Progressivo

O comando RETURN: obtendo informações dos métodos

Nesta seção do curso Java Progressivo iremos mostrar para que serve e como usar o comando return nos métodos.

• Baixar a Apostila Java Progressivo

Return: Retornando informações úteis em Java

Embora seja possível não retornar nada dos métodos (como simplesmente mostrar uma mensagem ou um menu de opções, como fizemos no artigo passado), o mais comum é que os métodos retornem algo.

Como assim 'retornar'?
Retornar no sentido de resultado. Por exemplo, uma soma.
O método pode ser simplesmente um trecho de código que calcula a soma de dois números e retorna esse resultado.

Ou pode ser um método que recebe os coeficientes de uma equação do segundo grau e retorna suas raízes.
O retorno pode ser um inteiro, um float, uma string, pode ser simplesmente uma decisão (como um boolean) ou outra coisa mais elaborada que você desejar.

Mas como eu disse, e mais uma vez vou repetir, crie métodos simples e os mais específicos possíveis.

Não crie métodos que fazem mil coisas. Ao invés disso, crie mil métodos, onde cada um faz uma coisa bem determinada. Isso é importante para você se organizar, não se perder e poder reutilizar seus códigos no futuro.

Retornando inteiros, floats, doubles... em Java

No exemplo do artigo passado onde criamos um método que simplesmente mostrava uma mensagem na tela, ele não retornava nada. Isso poderia ser visto por um detalhe na declaração do método, o 'void'.

Para retornar um inteiro, usaremos 'int'.
Por exemplo, vamos criar um método que retornar o valor de '1+1'.
Para fazer isto basta escrever 'return' e o que quisermos retornar após. Veja:

    public static int soma(){
        return 1+1;
    }

E agora, como usamos um retorno de inteiro?
É o mesmo que perguntar 'o que podemos fazer com um inteiro?'

Já que o método retorna um inteiro, você pode ver esse method como um inteiro.
Ou seja, você pode imprimir, somar com outro inteiro, com um float, ou simplesmente atribuir a um tipo inteiro.

Veja:

public class returnTest {
    
    public static int soma(){
        return 1+1;
    }
    
    public static void main(String[] args) {
        System.out.print("Declarando a variável 'res_soma' e recebendo o método soma(): ");
        int res_soma=soma();
        System.out.println(res_soma);
        
        System.out.println("Imprimindo diretamente o resultado do return: " + soma());
        
        System.out.println("Usando em uma soma: 2 + soma() = " + (2 + soma()));
        
        System.out.println("Usando em um produto: 3 * soma() = " + (3 * soma()));
        }
}

Se quisermos retornar um float: return 1.1*3.3
Devemos declarar o método como 'public static float soma()' ou obteremos um erro.

Retornando uma String em Java

Vamos refazer o programa do artigo passado. Porém, ao invés de imprimir mensagem na tela, ele vai retornar a string:

public class returnString {
    
    public static String mensagem(){
        return "Curso Java Progressivo!";
    }
    
    public static void main(String[] args) {
        System.out.println("Exibindo a mensagem uma vez: "+ mensagem());
        
        System.out.println("Exibindo a mensagem 3 vezes:");
        for(int count=1 ; count<=3 ; count++){
            System.out.println(mensagem());
        }
    }
}

Mais uma vez, você poderia ter declarado uma variável do tipo String para receber o 'return'.
Note que, dentro do método, seria a mesma coisa se tivéssemos feito:

    public static String mensagem(){
        String mensagem;
        mensagem="Curso Java Progressivo!";
        return mensagem;
    }

Retornando boolean em Java

Se você é um brasileiro e defensor ferrenho da língua portuguesa, pode definir os seguintes métodos:

    public static boolean verdade(){;
        return true;
    }

    public static boolean falso(){
        return false;
    }

E pronto. Agora poderá usar
if (verdade() ) ao invés de if(true) 
ou if (falso() ) no lugar de if(false) 

:)


Até o momento nossos métodos não são flexíveis, pois sempre  imprimem e retornam a mesma coisa.
Isso vai mudar quando você aprender como os method são utilizados em programas reais, através de argumentos e parâmetros, que será o assunto do próximo artigo de nossa apostila online Java Progressivo.

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?

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