05 poo-ii

Programação Orientada a
Objetos – Parte 2
Técnicas de Programação
Prof. Iális Cavalcante
Engenharia da Computação
2011.1

Tópicos a serem trabalhados
Polimorfismo
Sobrecarga
Herança múltipla (interface e classes
abstratas)

Introdução
Mensagem: “Desenha!”

Objeto da classe Objeto da classe Objeto da classe
Quadrado Circulo Triangulo

Introdução
Objeto da classe
Quadrado

Mensagem: Mensagem: Mensagem:
“Desenha Quadrado!” “Desenha Quadrado “Desenha Quadrado
Preenchido!” Preenchido e
com Rotação de 30°!”

Polimorfismo
Projetar 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

Universal Ad-Hoc

Paramétrico Inclusão Sobrecarga Coerção

Polimorfismo
Polimorfismo 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 elementos
vetor.length( ); // número máximo de elementos armazenados
vetor[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.

Polimorfismo
Polimorfismo 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.

(sem redefinição de métodos)
ContaCorrente
-nome titular
-numero
ContaCorrente c = new ContaCorrente(...);
-senha
-saldo c.debitaValor(...);
+creditaValor // c pode também referenciar uma conta especial
+debitaValor
+getSaldo
c = new ContaEspecial(...);
c.debitaValor(...); // Ok
c.alteraLimite(...); // Erro
ContaEspecial ((ContaEspecial) c).alteraLimite(...); // Ok
-limite

+alteraLimite
+getCreditoUtilizado

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 debitaValor
de ContaCorrente não está em ContaEspecial.
Portanto, esse método deve ser redefinido na
ContaCorrente classe ContaEspecial, podendo assumir
comportamento diferente.
+creditaValor ContaCorrente c1 = new ContaCorrente( );
+debitaValor
+getSaldo 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
ContaEspecial um tipo diferente (isto é, tipo ContaEspecial) do
seu tipo estático.
+alteraLimite
+getCreditoUtilizado
Em princípio, seria uma violação de tipo atribuir
+debitaValor 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.

Polimorfismo de Inclusão (com
redefinição de métodos)
No entanto, se ContaEspecial é um subtipo de
ContaCorrente 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
Superclasse
Forma

Circulo Triangulo Retangulo Quadrado
Subclasses
public void desenha() { (...) }

Polimorfismo - Exemplo
public 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

public 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

public 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

public class Teste {
public static void main(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:

Chefe: Joao Lopes ganhou R$ 800.0
Chefe: Joao Lopes ganhou R$ 800.0
Trabalhado por produção: Roberto Carlos ganhou R$ 500.0
Trabalhado por produção: Roberto Carlos ganhou R$ 500.0

Coerção e Sobrecarga
Coerçã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 Java
Em 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 Java
Sobrecarga 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.

Sobrecarga
Quadrado

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
Para 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últipla
Herança múltipla pode ser perigoso: “Losango Mortal” –
DDD (Deadly Diamond of Death):
DigitalRecorder
int i
burn( )

CDBurner DVDBurner

burn( ) burn( )

ComboDriver

Herança Múltipla
Utilizando 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 - Exemplo
public 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);
}

public 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 double multiplicacao(double valor1, double valor2){
return valor1*valor2; }
public double divisao(double valor1, double valor2){ return valor1/valor2; }
(...)

(...)
// 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 void main(String args[]){
Calculadora app = new Calculadora();
System.out.println(“fatorial: ”+app.fatorial(3));
}
}

05 poo-ii

Mais conteúdo relacionado

Mais procurados (20)

Destaque (15)

Semelhante a 05 poo-ii (20)

Mais de Ialis Cavalcante (15)

Último (20)

05 poo-ii