Buscar

Aula Monitoria 19 10 2010 - Aula IP CIn UFPE

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Aula de Monitoria
Redefinição de métodos
Classes abstratas
Interfaces
Redefinição de métodos
Objetivo: Adicionar novas funcionalidades aos métodos da classe pai.
Conceito importante: “Casts” dinâmicos.
Casts
Maneira de chamar os métodos de uma subclasse.
public class Pai{
   //etc
 
   public void metodoPai(){
   //alguma coisa
   }
}
public class Filho extends Pai{
   //etc
   public void   metodoFilho(){
   //alguma coisa
   }
}
public static void main(String[] args){
   Pai objeto = new Filho();
   objeto.metodoFilho(); //erro
   //esse metodo não existe para o tipo pai, mesmo a instância sendo do filho.
   //Solução: 
   ((Filho)objeto).metodoFilho(); //Ok
 
}
Casts
Sempre que possa haver erros, usar o “instanceof” para garantir que os casts não gerem exceção (ClassCastException)
if(coisa instanceof bagulho){
   ((bagulho)coisa).metodoDeBagulho();
}else{
   //Erro
}
Method Overriding
É a redefinição de métodos propriamente dita, altera o comportamento de um método do pai, sem alterar o seu código diretamente.
Muito importante na manutenção de software
public class Pai{
   //etc
 
   public void metodoPai(){
   //alguma coisa
   }
}
public class Filho extends Pai{
   //etc
 
   @Override
   public void   metodoPai(){
      super.metodoPai();
      //alguma coisa a mais 
	//Lembrar de manter a semântica 
	//do metodo pai
   }
}
public static void main(String[] args){
   Pai objeto = new Filho();
   objeto.metodoPai(); //Chama o metodo do //filho  
}
Note que não há necessidade de cast, já que as instâncias são dinâmicas(em tempo de execução)
Adicionei um novo comportamento método pai sem alterá-lo
Classes abstratas
Serve com uma classe pai mais geral ainda(por isso o nome abstrata), possui pelo menos um método abstrato(só assinatura), tem construtor, mas não pode ser instanciada. Possui métodos protected em alguns casos. 
abstract class NomeDaClasse {
   //atributos
   public NomeDaClasse(...){
   //...
   }
   //metodos "normais"
 
   abstract void metodoAbstrato(); //metodo abstrato
}
Quando usar ?
		Em programação orientada a objetos é preciso manter coerência entre classes pais e filhos, métodos dos pais tem que possuir o mesmo efeito sobre o atributo dos mesmos. Há casos em que é preciso gerar comportamentos diferentes(sobre o pai) para o mesmo método, é ai que entram os métodos abstratos.
Exemplo de classe abstrata
Fonte: http://download.oracle.com/javase/tutorial/java/IandI/abstract.html
abstract class GraphicObject {
    int x, y;
    //...
 
   //mover sempre será igual para todos os filhos
    void moveTo(int newX, int newY) { 
       //...
    }
 
   //Comportamento difere de filho para filho
 
    abstract void draw(); // desenhar depende da sua forma
    abstract void resize(); // o mesmo vale para mudar a sua escala
}
class Circle extends GraphicObject {
    //As classes filhas são OBRIGADAS a ter os métodos abstratos
   void draw() { 
        //...
    }
    void resize() {
       // ...
    }
}
class Rectangle extends GraphicObject {
    void draw() {
      //  ...
    }
    void resize() {
      //  ...
    }
}
Fonte: http://download.oracle.com/javase/tutorial/java/IandI/abstract.html
Interfaces
Função: Esconder detalhes da implementação, separar camadas de um programa.
Porque? Para facilitar o compartilhamento de código ( Só é preciso descrever o funcionamento dos métodos da interface, tudo que está embaixo “não interessa”.)
public interface BancoDeDados{
   //Não interessa a implementação desses metodos, só a sua função.
   void adicionar(...);
   void remover(...);
   void buscar(...);
}
Lembrar de garantir consistência dessas funções, se eu implemento essa interface, eu preciso manter a funcionalidade dos métodos: adicionar adiciona, remover remove, e buscar busca. 
Exemplo prático
	A biblioteca default de java possui uma interface chamada Comparable, todo objeto que implementar essa interface pode ser ordenado dentro de uma coleção.
public interface Comparable{
   int compareTo(Object o); // retorna 1 se o objeto for menor, //0 se for igual e -1 se for maior.
 
}
EXERCÍCIOS
Questão 1
Modele e crie a hierarquia entre as seguintes classes: ObjGeometrico, FiguraPlana, Poligono, Cubo, Quadrado, triangulo, piramide.
Com ObjetoGeometrico sendo uma interface, e pai de FiguraPlana e de Poligono (que serão classes abstratratas). Sendo esses duals pais das demais classes (cubo, quadrado, triangulo e piramede).
Crie métodos, para cada uma das classes. Tendo em vista que alguns métodos declarados na interface, poderão ser "descritos" tanto nas classes abstratas, ou nas classes normais.
As classes Triangulo, Quadrado e Retangulo terão os métodos: getArea() e getPerimetro().
Crie uma classe principal que instancia alguma das outras classes e teste a funcionalidade dos metodos.
Instancie objetos de forma polimórfica ou seja Pai pai = new Filho (); Teste e confira por si só o que pode e o que não se pode fazer com o polimorfismo.
Questão 2
Sabendo que toda classe de Java é filha de Object:
Crie uma classe qualquer e faça um override dos metodos toString() e Clone() de Object
O metodo clone(), Criar novos metodos uma classe filho dessa anterior e fazer override deles. Treinar Overload também.

Teste o Premium para desbloquear

Aproveite todos os benefícios por 3 dias sem pagar! 😉
Já tem cadastro?

Outros materiais