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));

}

}