Descobrindo a classe de um objeto: instanceof

Nesse rápido, e útil, tutorial ensinaremos como descobrir a classe de um objeto através da keyword:
instanceof

• Java Progressivo em PDF(download da Apostila)

Polimorfismo: Classes abstratas e Métodos abstratos

Desde que iniciamos nossos tutoriais sobre classes e objetos vínhamos tratando as classes como entidades 'reais' ou 'concretas', pois podíamos instanciar objetos a partir dela.

Nesse artigo vamos introduzir um conceito importante e bastante útil na orientação a objetos: a abstração.

Pode parecer estranho, ou no mínimo confuso, classificar e utilizar algo que se diz ser abstrato, mas veremos que esse tipo de idéia é bem interessante e bem mais realista que nossa noção antiga de classe e objeto.

private, public e protected: Protegendo suas informações em Java

Já vimos a relação de membros e métodos definidos como public e private, bem como a relação deles com o restante da aplicação.

Sabemos que membros private não podem ser acessados fora da classe em que foram declarados.
Mas em relação as suas subclasses?
E se eu quiser esconder algum dado das subclasses?

Veremos nesse artigo, de nosso curso online de Java, como proteger membros de uma classe, limitar e controlar o acesso aos dados importantes.

• Baixar a Apostila Java Progressivo

Vídeo-aula sobre Herança(extends) e Construtores da superclasse

O seguinte vídeo é da Universidade XTI, que publica de maneira gratuita seus vídeos e aulas no youtube.

São duas aulas sobre Herança, referente aos nossos tutoriais:

Herança em Java - o que é, para que serve, exemplos de uso e quando usar

Herança de Construtores e @Override

Herança de construtores e Override

Agora que você já sabe o que é herança, sua importância, quando usar e viu vários exemplos práticos do mundo real, vamos mostrar como fazer uma classe herdar as características de outra.

Nesse tutorial de Java ensinaremos também a relação dos construtores com as superclasses e subclasses, e como usar o tão importante @Override.

• Apostila de Java em PDF

Use constantes, e não números - declarando variáveis com o final

Suponha que o governo te contratou para criar um aplicativo que, dentre outras coisas, analisa se um cidadão é maior de idade ou não.
Como você faria este teste condicional?

if(idade >= 18)...ou quem sabe if(idade > 17) ?

Ambos corretos, mas absolutamente não recomendáveis.

Nesse artigo ensinaremos uma importante lição de Java: Não usar números, e sim constantes.

• Apostila completa Java Progressivo

Auto-referência com o this - Invocando métodos de Classes e Objetos

No tutorial de Java passado relacionado a Orientação a Objetos, falamos como criar construtores, com ou sem parâmetros, em nossas classes.

Nesta pequena aula, iremos aprender como referenciar membros de um objeto através da keyword 'this', que é uma ferramenta bastante usada por programadores Java em métodos dentro de Classes.

• Baixar a Apostila Java Progressivo

Referenciando membros da classe com this

Imagine que criemos uma classe chamada "Funcionario", onde seu construtor padrão recebe uma String com o nome do funcionário, um inteiro com seu número de identificação e um double com seu salário.
Se esses dados, dentro da classe são:

private String nome;
private int ID;
private double salario;

E o cabeçalho do construtor é:
public Funcionario( String nome, int ID, double salario)

Como faríamos a atribuição? Ora, do mesmo jeito que fizemos antes:
nome = nome;
ID = ID;
salario = salario;

Epa! Notou que as variáveis da classe e as variáveis do cabeçalho tem o mesmo nome?
E agora, como o Java vai saber que as variáveis da esquerda se referem as variáveis 'private' da classe a as da direita são as que o usuário mandou pra criar o objeto?

Já sei! Basta criar o método com nomes de variáveis diferentes, como fizemos antes:
public Funcionario( String Nome, int id, double Salario){
nome = Nome;
ID = id;
salario = Salario;
}

Ok, isso funcionaria perfeitamente. Mas seria extremamente incômodo, e desorganizado, criar dois nomes pra um mesmo tipo de variável.
Não pode parecer problema agora, com essa simples aplicação. Mas em uma situação real, em que seu programa em Java terá centenas de variáveis e você tiver que criar e decorar nomes de variáveis, isso vai ser um baita problema.

Para isso, existe o 'this', que referencia - ou seja, aponta - a própria classe!
'this' em inglês, significa 'isso', 'isto'. É bem fácil seu uso, veja como ficaria nosso construtor:

public Funcionario( String nome, int ID, double salario){
this.nome = nome;
this.ID = ID;
this.salario = salario;
}

Pronto.
Agora ficou óbvio que 'this.nome' é a variável 'nome' da classe "Funcionario" e 'nome' é a variável que a classe recebeu para criar um objeto!

Usamos o 'this' dentro da classe. Assim, sempre que colocarmos 'this.' antes de uma variável, fica implícito ao Java que estamos nos referindo aos atributos daquela Classe.
Podemos usar, inclusive, em um print, caso esteja dentro da classe. Em um método, por exemplo, como veremos a seguir.

Outra utilidade do 'this' é passar o objeto atual como parâmetro.
public Object getObjeto(){
     return this;
}

Outro exemplo disso é criar o método...:
public String toString()

...na sua classe, e usar 'this' dentro de um print. O Java entenderá que deve ser impresso o que estiver dentro desse método 'toString()'.

Outra utilidade do 'this' é invocar outros construtores. Para invocar um construtor dentro de outro, essa chamada deve ser o primeiro comando do construtor atual.
Por exemplo, fazendo simplesmente:
this;

Estamos chamando o construtor padrão, que não recebe parâmetros.
Fazendo:
this(2112);

Estamos invocando o construtor que recebe um inteiro como parâmetro.
Lembrando que quando criamos um construtor que não é o padrão, o Java não vai mais criar o construtor padrão vazio.
Esse construtor padrão vazio só é criado automaticamente quando não criamos nenhum construtor.

Como invocar métodos de objetos que criamos

Vamos criar um método, dentro da classe "Funcionário", que exibe todas as informações de um objeto dessa classe. Vamos chamar de 'exibir':

public void exibir(){
System.out.printf("O funcionário %s, de número %d recebe %.2f por mês", this.nome,this.ID,this.salario);
}


Para invocar, basta colocar '.exibir()' após o nome do objeto, que fará com que este método rode.
Note, porém, que conforme explicamos em nosso artigo sobre Classes e Objetos, essa classe é apenas uma abstração.
Ou seja, esse método não existe de verdade! Ele só vai passar a existir quando criarmos um objeto dessa classe!
(Na verdade ele pode existir, caso a classe fosse estática. Estudaremos isso em breve).

Para ilustrar a chamada de métodos de um objeto e o uso do 'this', vamos criar um funcionário - um objeto - de nome 'chefe'.
O código ficará assim:

thisMetodo.java

public class thisMetodo{
    
    public static void main(String[] args){
        String nome = "Neil Peart";
        int ID=2112; 
        double salario = 1000000;
        
        Funcionario chefe = new Funcionario(nome, ID, salario);
        
        chefe.exibir();
    }

}

Funcionario.java

public class Funcionario {
    private String nome;
    private int ID;
    private double salario;
    
    public Funcionario(){
        System.out.println("Método construtor padrão invocado!");
    }

    public Funcionario( String nome, int ID, double salario){
        this();
        System.out.println(this);

        this.nome = nome;
        this.ID = ID;
        this.salario = salario;
    }

    
    public String toString(){
        return "Foi usado : System.out.println(this)";
    }

    public void exibir(){
        System.out.printf("O funcionário %s, de número %d recebe %.2f por mês", this.nome,this.ID,this.salario);

}

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.

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?