Post on 06-Jun-2015
Programação Orientada a Objetos – Parte 2Técnicas de ProgramaçãoProf. Iális CavalcanteEngenharia da Computação2011.1
Tópicos a serem trabalhados
PolimorfismoSobrecargaHerança múltipla (interface e classes abstratas)
Introdução
Objeto da classeQuadrado
Objeto da classeCirculo
Objeto da classeTriangulo
Mensagem: “Desenha!”
IntroduçãoObjeto da classe
Quadrado
Mensagem:“Desenha Quadrado!”
Mensagem:“Desenha Quadrado
Preenchido!”
Mensagem:“Desenha Quadrado
Preenchido ecom Rotação de 30°!”
POLIMORFISMO
PolimorfismoProjetar sistemas mais extensíveis.No decorrer da hierarquia, modificar métodos:◦ Alterando seu comportamento de acordo com o
objetivo da classe;◦ Mantendo a estrutura definida na hierarquia.
Mesma mensagem para diferentes objetos assume “diferentes formas” de resultados.
Polimorfismo
Classificação de Polimorfismo
Polimorfismo
CoerçãoSobrecargaParamétrico Inclusão
Ad-HocUniversal
PolimorfismoPolimorfismo Paramétrico◦ Java não oferece um mecanismo generalizado que implemente o
polimorfismo paramétrico de tipos.
◦ Exemplo: tipo array pré-definido em Java.
◦ O tipo array possui um conjunto de funções características:int vetor [ ];vetor = new int[11]; // cria um vetor com 11 elementosvetor.length( ); // número máximo de elementos armazenadosvetor[int i]; // obtém a referência do i-ésimo elemento armazenado em vetor
◦ O tipo array é declarado através do símbolo [ ] , int funciona como parâmetro para a construção do array.
◦ Proposta de polimorfismo paramétrico de tipos em Java: Generics (Genéricos).
Disponível na versão 1.5 do Java SDK.
PolimorfismoPolimorfismo de Inclusão◦ É o estilo de polimorfismo encontrado em todas as
linguagens orientadas a objetos.◦ Ele está relacionado com a existência da hierarquia de
generalização/especialização e com o conceito de subtipo.◦ Definição de Subtipo: Um tipo S é um subtipo de
T se e somente se S proporciona pelo menos o comportamento de T.◦ A noção de subtipo implica que elementos do
subconjunto também pertencem ao superconjunto.
Polimorfismo de Inclusão(sem redefinição de métodos)
ContaCorrente c = new ContaCorrente(...);
c.debitaValor(...);
// c pode também referenciar uma conta especial
c = new ContaEspecial(...);
c.debitaValor(...); // Ok
c.alteraLimite(...); // Erro
((ContaEspecial) c).alteraLimite(...); // Ok
ContaCorrente
-nome titular-numero-senha-saldo
+creditaValor+debitaValor+getSaldo
ContaEspecial
-limite
+alteraLimite+getCreditoUtilizado
Polimorfismo de Inclusão
O polimorfismo de inclusão foi batizado com esse nome porque as operações polimórficas de um tipo estão “incluídas” nos seus subtipos.A classe Object é a raiz de qualquer classe criada em Java.Os métodos da classe Object são exemplos de polimorfismo de inclusão, pois eles são capazes de operar uniformemente sobre objetos de qualquer tipo em Java.
Polimorfismo de Inclusão (com redefinição de métodos)
O que está implantado no método debitaValorde ContaCorrente não está em ContaEspecial.
Portanto, esse método deve ser redefinido na classe ContaEspecial, podendo assumir comportamento diferente.
ContaCorrente c1 = new ContaCorrente( );
ContaEspecial c2 = new ContaEspecial( );
c1 = c2; // atribuição válida
A atribuição c1 = c2 acopla dinamicamente àvariável c1 do tipo ContaCorrente um objeto de um tipo diferente (isto é, tipo ContaEspecial) do seu tipo estático.
Em princípio, seria uma violação de tipo atribuir um objeto de um tipo diferente à variável c1 que, de acordo com a sua especificação de tipo, deve referenciar apenas objetos do tipo ContaCorrente.
ContaCorrente
+creditaValor+debitaValor+getSaldo
ContaEspecial
+alteraLimite+getCreditoUtilizado+debitaValor
Polimorfismo de Inclusão (com redefinição de métodos)
No entanto, se ContaEspecial é um subtipo deContaCorrente a atribuição é válida.
c1.debitaValor( ); //ativa ContaCor :: debitaValor()
c1 = c2;
c1.debitaValor( ); // ativa ContaEsp :: debitaValor()
Em Java, a operação da classe base deve ser apenas redefinida na classe derivada.Ponto Crucial: Todas as operações redefinidas na classe derivada tem a responsabilidade de manter a mesma semântica dos serviços oferecidos pela classe base.
Polimorfismo
FormaSuperclasse
Triangulo Quadrado
Subclasses
Circulo Retangulo
public void desenha() { (...) }
Polimorfismo - Exemplopublic abstract class Empregado {
private String primeiroNome;
private String ultimoNome;
/** construtor */
public Empregado (String primeiro, String ultimo) {
primeiroNome = primeiro; ultimoNome = ultimo; }
public String getPrimeiroNome(){ return primeiroNome; }
public String getUltimoNome(){ return ultimoNome; }
public String toString(){ return primeiroNome+“ ”+ultimoNome; }
public abstract double lucros();
} // fim da classe Empregado
Polimorfismo - Exemplopublic final class Chefe extends Empregado {
private double salarioSemanal;
/** construtor */
public Chefe(String primeiro, String ultimo, double salario) {
super(primeiro,ultimo);
setSalarioSemanal(salario);
}
public void setSalarioSemanal(double salario){
salarioSemanal = ( salario>0 ? salario : 0.0 );
}
public double lucros(){ return salarioSemanal; }
public String toString(){
return “Chefe: ”+super.toString();
}
} // fim da classe Chefe
Polimorfismo - Exemplopublic final class TrabalhadorPorProducao extends Empregado {
private double pagamentoPorPeca;
private int quantidade;
/** construtor */
public TrabalhadorPorProducao(String primeiro, String ultimo,
double pagamento, int numeroDeItens) {
super(primeiro, ultimo);
setPagamento (pagamento);
setQuantidade(numeroDeItens);
}
public void setPagamento(double pagamento){
pagamentoPorPeca = (pagamento>0.0 ? pagamento : 0.0); }
public void setQuantidade(int numeroDeItens){
quantidade = (numeroDeItens>0 ? numeroDeItens : 0); }
public double lucros(){ return pagamentoPorPeca * quantidade; }
public String toString(){
return “Trabalhado por produção: ”+super.toString();}
} // fim da classe TrabalhadorPorProducao
Polimorfismo - Exemplopublic class Teste {
public static voidmain(String args[]) {
Empregado empregado; // referência para a superclasse
String output = “ ”;
Chefe chefe = new Chefe(“João”, “Lopes”,800.0);
TrabalhadorPorProducao porProducao =
new TrabalhadorPorProducao(“Roberto”, “Carlos”,2.5,200);
empregado = chefe; // referencia Empregado para um Chefe
output += empregado.toString()+“ ganhou R$ ” +empregado.lucros()+“\n”+
chefe.toString()+“ ganhou R$ ”+chefe.lucros()+“\n”;
empregado = porProducao; // referência Empregado para um TrabalhadorPorProducao
output += empregado.toString()+“ ganhou R$ ”+empregado.lucros()+“\n”+
porProducao.toString()+“ ganhou R$ ”+porProducao.lucros()+“\n”;
System.out.println(output);
}
}
Saída:
Polimorfismo - Exemplo
Chefe: Joao Lopes ganhou R$ 800.0Chefe: Joao Lopes ganhou R$ 800.0Trabalhado por produção: Roberto Carlos ganhou R$ 500.0Trabalhado por produção: Roberto Carlos ganhou R$ 500.0
SOBRECARGA
Coerção e SobrecargaCoerção: A linguagem tem um mapeamento interno entre tipos. Forma limitada de polimorfismo. Se num contexto particular o tipo requerido é diferente do tipo dado, a linguagem verifica se existe uma coerção (conversão de tipos).◦ Exemplo: se uma função soma( ) é definida como tendo 2
parâmetros reais, e um inteiro e um real são passados, o inteiro é convertido para real.
Sobrecarga: Permite que um “nome de função” possa ser usado mais de uma vez com diferentes tipos de parâmetros.◦ Exemplo: uma função soma com 2 parâmetros inteiros e uma
função soma com 2 parâmetros reais. A informação sobre os tipos dos parâmetros é usada para selecionar a função apropriada.
Exemplos de Coerção em JavaEm Java são executadas as seguintes conversões implicitamente :◦ byte para short, int, long, float ou double◦ short para int, long, float ou double◦ char para int, long, float ou double◦ int para long, float ou double◦ long para float ou double◦ float para double
Todas essas conversões são consideradas promoções de tipo, isto é, o valor inicial é um tipo cujo domínio está contido no domínio do tipo resultante. Não pode haver truncamento no resultado.Conversão entre inteiros (short, int ou long) e entre reais (float ou double) pode resultar em perda de precisão.
Exemplos de Sobrecarga em JavaSobrecarga de métodos construtores:◦ public ContaCorrente ( ); // construtor default
◦ public ContaCorrente (String nome, float val, int num, int pwd) { ...}
Sobrecarga de Operadores: quando um operador da linguagem pode ter diferentes significados, dependendo do tipo do parâmetro aplicado.Exemplo: a + = b◦ Significado (1) : “adicione o valor b ao atributo a”.
◦ Significado (2) : “inclua o elemento b no conjunto a”.
Java não permite sobrecarga de operadores, apenas de métodos.C++ permite sobrecarga de operadores e de métodos.
SobrecargaQuadrado
public void desenhaQuadrado() { (...) }
public void desenhaQuadrado(boolean preenchido) { (...) }
public void desenhaQuadrado(boolean preenchido, double rotacionado) { (...) }
Redefinição x Sobrecarga de Métodos
Redefinição: o novo método deve ter a mesma assinatura do método herdado, isto é, eles devem ser idênticos quanto ao nome da operação e à lista de parâmetros (mesmo número de parâmetros, com os mesmos tipos e declarados na mesma ordem).O tipo do resultado de retorno não faz parte da assinatura do método e não pode ser mudado.Sobrecarga: Ocorre quando existe apenas coincidência nos nomes dos métodos; isto é, as listas de parâmetros não são idênticas.
HERANÇA MÚLTIPLA*
Herança MúltiplaPara começo de conversa, não se permite herança múltipla em Java.A herança utiliza a relação “é um”:◦ Carro “é um” Veículo;◦ Fusca “é um” Carro;◦ Círculo “é um” Ponto;◦ Cilindro “é um” Círculo;
Herança múltipla pode provocar redundância na definição de métodos, exigindo regras especiais;Java não suporta este recurso mas permite uma alternativa: uso de interfaces.
Herança MúltiplaHerança múltipla pode ser perigoso: “Losango Mortal” –DDD (Deadly Diamond of Death):
DigitalRecorder
int i
burn( )
CDBurner
burn( )
DVDBurner
burn( )
ComboDriver
Herança MúltiplaUtilizando interfaces, permite-se os benefícios polimórficos (já que interface é com uma classe 100% abstrata) sem a ameaça do Losango Mortal.Todos os métodos de uma interface são abstratos:◦ Cada subclasse deve implementar o método herdado;◦ Evita a confusão da JVM de qual versão herdada deve
utilizar;◦ Uma classe pode implementar diversas interfaces;◦ Pode ainda uma mesma classe herdar de outra classe
e implementar uma interface ao mesmo tempo.
Herança Múltipla - Exemplopublic interface Padrao {
public double soma(double valor1, double valor2);
public double subtracao(double valor1, double valor2);
public double multiplicacao(double valor1, double valor2);
public double divisao(double valor1, double valor2);
}
public interface Cientifica {
public double exponencial(double valor);
public double logaritmo(double valor);
public int fatorial(int valor);
}
Herança Múltipla - Exemplopublic class Calculadora implements Padrao, Cientifica {
// atributos privados
private double numero1; private double numero2;
// sobrecarga dos construtores
public Calculadora(double num1, double num2) {
this.numero1 = num1; this.numero2 = num2; }
public Calculadora(double num1) { this.numero1 = num1; this.numero2 = 0; }
public Calculadora() { this.numero1 = 0.0; this.numero2 = 0.0; }
// métodos implementados de Padrao
public double soma(double valor1, double valor2){ return valor1+valor2; }
public double subtracao(double valor1, double valor2){ return valor1‐valor2; }
public doublemultiplicacao(double valor1, double valor2){
return valor1*valor2; }
public double divisao(double valor1, double valor2){ return valor1/valor2; }
(...)
Herança Múltipla - Exemplo(...)
// métodos implementados de Cientifica
public double exponencial(double valor){ return Math.exp(valor); }
public double logaritmo(double valor){ return Math.log(valor); }
public int fatorial(int valor){
int fatorial = 1;
for(int ind = 1; ind <= valor; ind++){ fatorial *= ind; }
return fatorial; /* retorna o fatorial (n!) de valor */
}
// método principal
public static voidmain(String args[]){
Calculadora app = new Calculadora();
System.out.println(“fatorial: ”+app.fatorial(3));
}
}