TA345/531 TP257 Informática Aplicada à Engenharia de Alimentos.


 

 Aula 4. Parte B – Mais sobre Métodos

 

4.1. Polimorfismo ou sobrecarga

O polimorfismo é um dos princípios básicos da orientação a objetos, fazendo referência ao poder que os objetos  de classes distintas têm de invocar um mesmo método e obter comportamentos distintos. O polimorfismo está diretamente relacionado a métodos.

 

Os métodos em Java podem ser sobrecarregados, ou seja, podem-se criar métodos com o mesmo nome, mas com diferentes assinaturas (parâmetros) e diferentes definições. Quando se chama um método em um objeto, o Java casa o nome do método, o número de argumentos e o tipo dos argumentos e escolhe qual a definição do método a executar. Para criar um método sobrecarregado, é necessário criar diferentes definições de métodos na sua classe, todos com o mesmo nome, mas com diferentes parâmetros (número de argumentos ou tipos).

 

No exemplo a seguir, veremos a definição da classe MyRect, a qual define um retângulo plano. A classe MyRect tem quatro variáveis para instanciar, as quais definem o canto superior esquerdo e o canto inferior direito do retângulo: x1, y1, x2 e y2.

 

public static int x1 = 0,y1 = 0, x2 = 0, y2 = 0;

 

Quando uma nova instância da classe MyRect for criada, todos as suas variáveis são inicializadas com 0. Definindo um método MyRect buildRect( ): este método recebe quatro inteiros e faz um “resize” do retângulo de acordo com as novas coordenadas e retorna o objeto retângulo resultante (note que os argumentos possuem o mesmo nome das variáveis instanciáveis, portanto deve-se usar o this para referenciá-las):

   

MyRect buildRect(int x1, int y1, int x2, int y2)

this.x1 = x1;  this.y1 = y1;

this.x2 = x2;  this.y2 = y2;

return this;

 }

 

Querendo-se definir as dimensões do retângulo de outra forma, por exemplo, pode-se usar o objeto Point ao invés de coordenadas individuais.

Faremos a sobrecarga do método MyRect buildRect ( ), passando agora como parâmetro dois objetos Point:

 

MyRect buildRect(Point topLeft, Point bottomRight)

{  

x1 = topLeft.x; y1 = topLeft.y;

           x2 = bottomRight.x; y2 = bottomRight.y;

           return this;

 }

 

Entretanto, querendo-se definir um retângulo usando somente o canto superior esquerdo e uma largura e altura do retângulo pode-se ainda definir mais um método MyRect buildRect ( ):

 

 MyRect buildRect(Point topLeft, int w, int h)

x1 = topLeft.x; y1 = topLeft.y;

x2 = (x1 + w); y2 = (y1 + h);

            return this;

}

 

O Programa completo ficaria assim:

import java.applet.Applet;

import java.applet.*;

import java.awt.*;

import java.awt.Point;

 

public class MyRect extends Applet

{

  TextArea ta;

  public static int x1 = 0,y1 = 0, x2 = 0, y2 = 0;

 

  public void init()

  {

     ta = new TextArea(16,62); add(ta);

     MyRect rect = new MyRect( );

 

     ta.append(" A função buildRect() pode ser chamada, dentro de um programa,\n");

     ta.append(" usando 3 formas diferentes nos argumentos da função.  \n");

     ta.append(" A cada tipo de chamada responde de forma diferente \n");

     ta.append(" pois foi construida para ser sobrecarregada \n");

 

     ta.append(" \n Chamada a buildRect com coordenadas 25,25, 50,50:");

     rect.buildRect(25, 25, 50, 50);

     ta.append("\n MyRect: <" + x1 + ", " + y1 +", " + x2 + ", " + y2 + ">");

     ta.append("\n -----------------------------------------------");

 

 

     ta.append("\n Chamada a buildRect com os pontos (10,10), (20,20):");

     rect.buildRect(new Point(10,10), new Point(20,20));

     ta.append("\n MyRect: <" + x1 + ", " + y1 + ", " + x2 + ", " + y2 + ">");

     ta.append("\n -----------------------------------------------");

 

     ta.append("\n Chamada a buildRect com o point (10,10), largura (50), altura (50):");

     rect.buildRect(new Point(10,10), 50, 50);

     ta.append("\n MyRect: <" + x1 + ", " + y1 +", " + x2 + ", " + y2 + ">");

     ta.append("\n -----------------------------------------------");

   }

 

    MyRect buildRect(int x1, int y1, int x2, int y2)

    {

       this.x1 = x1;  this.y1 = y1;

       this.x2 = x2;  this.y2 = y2;

       return this;

    }       

 

    MyRect buildRect(Point topLeft, Point bottomRight)

    {  

        x1 = topLeft.x; y1 = topLeft.y;

        x2 = bottomRight.x; y2 = bottomRight.y;

        return this;

    }

 

    MyRect buildRect(Point topLeft, int w, int h)

    {  

        x1 = topLeft.x; y1 = topLeft.y;

        x2 = (x1 + w); y2 = (y1 + h);

        return this;

    }

}

 

Como resultado, obtemos o seguinte Applet:

 

 

 

Veja agora uma forma mais clássica de escrevermos esse programa:

 

import java.awt.*;

import java.awt.Point;

import java.applet.*;

import java.applet.Applet;

 

class MyRect {

    int x1 = 0;

    int y1 = 0;

    int x2 = 0;

    int y2 = 0;

 

    MyRect buildRect(int x1, int y1, int x2, int y2) {

        this.x1 = x1;

        this.y1 = y1;

        this.x2 = x2;

        this.y2 = y2;

        return this;

    }

 

    MyRect buildRect(Point topLeft, Point bottomRight) {

        x1 = topLeft.x;

        y1 = topLeft.y;

        x2 = bottomRight.x;

        y2 = bottomRight.y;

        return this;

    }

 

    MyRect buildRect(Point topLeft, int w, int h) {

        x1 = topLeft.x;

        y1 = topLeft.y;

        x2 = (x1 + w);

        y2 = (y1 + h);

        return this;

    }

 

    String printRect() {

        String text = ("MyRect: <" + x1 + "," + y1 +"," + x2 + "," + y2 + ">");

        return text;

    }

}

 

public class TestRect extends Applet

{

            public void init()

            {

              resize (500, 250);

             MyRect rect = new MyRect();

             TextArea ta = new TextArea(10,60); add(ta);

 

              ta.append ("\n --------- 1 -----------\n");

              ta.append ("Chamando construaRetang com coordenadas 25,25,50,50:\n");

              rect.buildRect(25, 25, 50, 50);

             ta.append(rect.printRect());

 

             ta.append ("\n --------- 2 -----------\n");

              ta.append ("Chamando construaRetang com os pontos (10,10),(20,20):\n");

             rect.buildRect(new Point(10,10), new Point(20,20));

             ta.append(rect.printRect());

 

            ta.append ("\n --------- 3 -----------\n");

            ta.append ("Chama construaRetang com (10,10), largura (50) e altura (50):\n");

            rect.buildRect(new Point(10,10), 50, 50);

            ta.append(rect.printRect());

          }

}

 

Obtemos o seguinte resultado:

 

 

4.2. Métodos construtores

Os métodos construtores costumam adquirir vários recursos do sistema e têm duas características marcantes:

1.    Eles devem ter o mesmo nome da classe;

2.    Eles não devem indicar um tipo de dado de retorno.

 

Um método construtor é um tipo especial de método que determina como um objeto é inicializado quando ele é criado. Diferente dos métodos normais, um método construtor não pode ser chamado diretamente, ao invés disto, os métodos construtores são chamados automaticamente pelo Java. No momento em que o objeto é instanciado, ou seja, quando se usa new o Java faz três coisas:

 

Com relação a métodos construtores, podemos adicionar outra informação: quando um objeto é instanciado, o construtor da superclasse, se houver é chamado antes do construtor da subclasse.

 

4.3. Métodos destruidores

Quando não são mais necessários, devem ser destruídos. Em vez de deixar a cargo do programador a tarefa de liberar memória, Java torna a coleta de lixo uma operação implícita do sistema. Dessa maneira, os desperdícios de memória são menos freqüentes em Java.

 

Os métodos destruidores são chamados logo antes do coletor de lixo passar e sua memória ser liberada. O métodos destruidor é chamado de finalize( ). A classe Object define um método destruidor padrão, que não faz nada. Para criar um método destruidor para suas próprias classes, basta sobrepor o método finalize ( ) com o seguinte cabeçalho:

protected void finalize ( ) {

            …

}

 

Dentro do método finalize, você pode colocar tudo que você precisa para fazer a limpeza do seu objeto.

 

Quando o programador chama explicitamente o método finalize( ), nenhuma ação é realizada sobre o objeto até que a Maquina Virtual Java faça uma completa inspeção para verificar a existência de outras ligações com o objeto, procurando desfazê-las todas antes de determinar o descarte do objeto.

 

4.4. Outras informações importantes

Os métodos são particularmente interessantes quando uma determinada ação deve ser repetida várias vezes no programa e não queremos escrever o mesmo código diversas vezes.

 

Observe o seguinte exemplo:

 

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import java.text.*;

 

class dato

{

    int codigo;

    String nome;

    String telefone;

    int idade;

 

    public dato(int c, String n, String t, int i)

    {

       codigo = c;

       nome = n;

       telefone = t;

       idade = i;

    }

}

 

public class mostralista extends Applet implements ActionListener

{

  Label rotulo;

  Button botao;

  TextArea ta;

  dato[] dados = new dato[4];

 

  public void init()

  {

    dados[0] = new dato(10, "        Maria Rita ", "   222-1234   ", 25);

    dados[1] = new dato(11, "        Carolina    ", "   992-1122   ", 27);

    dados[2] = new dato(12, "        Carlos       ", "   325-4518   ", 31);

    dados[3] = new dato(13, "        Enrique     ", "   389-2397   ", 61);

 

    rotulo= new Label("Para ver a listagem");add(rotulo);

    botao = new Button("Aperte aqui!");add(botao);botao.addActionListener(this);

    ta = new TextArea(10,36); add(ta);

  }

 

  public void actionPerformed(ActionEvent e)

  {

    if (e.getSource() == botao)

    {

              ta.append("\n Código    Nome     Telefone     Idade \n");

             for(int i=0;i<dados.length;i=i+1)

             ta.append(dados[i].codigo + dados[i].nome + dados[i].telefone + dados[i].idade + "\n");

    }

  }

}

Agora veja a página Notas dos Alunos.

Talvez você tenha pensado: "Nossa! Quantas contas deve ter neste código!", mas se você prestou atenção nas últimas linhas que leu já deve saber onde queremos chegar... Sim!! Usamos métodos! Assim só precisávamos chamá-los nas horas que eram utilizados sem precisar escrever tudo de novo.

Nós simplificamos um pouco o código do Applet para você poder observar com mais clareza.

http://www.unicamp.br/fea/ortega/info/cursojava/image003.jpg
 

Executando o código do applet notas da forma que lhe foi apresentado você vai observar a mensagem indicando que este código está defasado. Modifique-o da mesma maneira que fizemos com o Applet areatri de forma a eliminar este problema. Compare-o com Notas2.

 

Volta para a pagina principal

 

 

Última atualização:  27/março/2009