09 Java Heranca Polimorfismo 07

LEEC@IST Java – 1/52

Programação por Objectos

Java

Parte 6: Herança e Polimorfismo


Herança – revisão

• A herança é um mecanismo em que a subclasseconstitui uma especialização da superclasse. A superclasse pode ser vista como generalização das subclasses.

• A herança é dita como uma relação “is-a”.

• As subclasses herdam os atributos e métodos das superclasses. Os métodos herdados podem ser modificados. Novos atributos e métodos podem ser adicionados às subclasses.



• O polimorfismo ocorre quando há múltipladefinição, ou redefinição, de métodos dasuperclasse nas subclasses, com a mesmaassinatura.

• Em OO o polimorfismo é normalmente implementadoatravés de ligação dinâmica, i.e., o método a ser executado é determinado apenas em tempo de execução (e não em tempo de compilação).



• Na herança simples cada subclasse tem apenas uma superclasse (directa).

• Na herança múltipla uma subclasse pode ter mais do que uma superclasse (directa).


Herança (1)• O Java adopta as seguintes estratégias na herança:

– Só há herança simples de classes.– Todas as classes são subclasses de Object (explícita ou

implicitamente).– A subclasse herda todos os atributos e métodos das superclasses.

• Os construtores não são métodos, e por isso não são herdados.

– Os atributos private não são visiveis na subclass, os atributos protected e public mantem a mesma visibilidade.

• No caso de atributos e métodos sem qualificador de visibilidade (visibilidade de pacote), a subclasse herda estes atributos e métodos se estiver definida no mesmo pacote que a superclasse, e apenas neste caso.


Herança (2)

– Se a subclasse declarar um método com o mesmo identificador e parâmetros (número e tipo) que uma das superclasses, então a subclasseredefine esse método.

– Se a subclasse declarar um atributo com o mesmo identificador que uma das superclasses, então o atributo da subclasse esconde o atributo da superclasse (mas continua a existir!)


Herança (3)

SintaxeQualif* class Ident

[ extends IdentC] [ implements IdentI [,IdentI]* ] {

[ Atributos | Métodos ]*

}

• Qualif: qualificador (visibilidade, entre outros)• Ident: identificador da classe• extends IdentC: especialização de superclasse• implements IdentI: realização de interfaces


Herança (4)

public class ContaPrazo extends Conta {

private static float juro=0.05;

private long inicio;

private int intervalo;

public void vencimentoJuros() {

long today = System.currentTimeMillis();

if(today==inicio+intervalo) {

quantia *= (1+juro);

inicio = today;

}

}

}


Construtores em subclasses (1)

• É da responsabilidade da subclasse inicializar os atributos definidos na sua classe, assim como os atributos que herda das suas superclasses.

• O construtor da subclasse pode delegar a inicialização dos atributos herdados para a superclasse, chamando, implicita ou explicitamente, o construtor da superclasse.

• Um construtor da subclasse pode fazer uma chamada explícitadum construtor da superclasse através do super().

• Se o construtor da superclasse tiver N parâmetros, estes devem ser passados na chamada explícita: super(param1,...,paramN).

• Se existir, a chamada explícita do construtor da superclassedeve ser a primeira instrução no construtor.


Construtores em subclasses (2)• Pode se chamar outro construtor da classe usando o

this(parametros).• Se nenhum construtor da superclasse é chamado, ou

se nenhum construtor da classe é chamado, como primeira instrução do construtor, o construtor sem argumentos da superclasse é implicitamente chamado antes de qualquer instrução no construtor.

• Se a superclasse não tiver um construtor sem argumentos, é necessário chamar explicitamente um construtor da superclasse.– Note que um construtor implícito éautomaticamente criado se não existir mais nenhum construtor, mas apenas neste caso.



public class A {

protected int a;

A() {

a = 5;

}

A(int var) {

a = var;

}

}

public class DuplicaA extends A {

DuplicaA () {

a *= 2;

}

DuplicaA (int var) {

super(var);

a *= 2;

}

}

Não é necessário chamarexplicitamente super()pois super() éimplicitamente chamado!



public class A {

protected int número;

A(int num) {

número=num;

}

} public class B extends A {

protected String nome=“não-definido”;

B() {

super(-1);

}

B(int num) {

super(num);

}

B(int num, String str) {

this(num);

nome = str;

}

}

É necessário chamar explicitamente super(-1) pois a superclasse não tem construtor sem argumentos!



• Quando um objecto é criado, é afectada memória para todos os seus atributos, incluindo os herdados das superclasses.

• Os atributos são inicializados com um valor por omissão, dependendo do seu tipo.

• Após isto a construção tem 3 fases:1. Chamar o construtor da superclasse (através de uma

chamada implícita ou explícita).• Se uma chamada a this(parametros) é encontrada

então esta é efectuada e o processo reinicia-se no novo construtor.

• Se houver uma chamada super(parametros) éencontrada então é chamado o construtor da super classe correspondente. Caso contrário e chamado o constructorpor defeito da super class.

• Este processo é repetido até chegar a object.



• Nesta fase, qualquer expressão que é passada como argumento ao construtor explícito não deve incluir nem atributos nem métodos do objecto a ser criado.

2. Inicializar os atributos (inicialização na declaração dos mesmos e através de blocos de inicialização).• Nesta fase, referências para outros membros do objecto a ser

criado são permitidas, desde que estas já tenham sido declaradas.

3. Chamar o corpo do construtor.



public class A {

protected int a=1;

protected int total;

A() {

total=a;

}

}

public class B extends A {

protected int b=2;

B () {

total+=b;

}

}

a b total

1. Atributos com valores por omissão 0 0 0

2. Construtor de B é chamado 0 0 0

3. Constructor de A é chamado (super()) 0 0 0

4. Construtor Object é chamado 0 0 0

5. Inicialização dos atributos de A 1 0 0

6. Execução do construtor de A 1 0 1

7. Inicialização dos atributos de B 1 2 1

8. Execução do construtor de B 1 2 3

• Quando é criado um objecto do tipo B…


Herança e redefinição

• Numa classe derivada podem:– ser adicionados novos atributos e métodos à classe.

– ser redefinidos métodos na classe.



• Um método da subclasse é considerado uma redefinição dum método da superclasse se:

– Ambos têm o mesmo identificador e parâmetros (número e tipo).

– O tipo de retorno é covariante:• Se o tipo de retorno é uma referência, então o método

redefinido pode declarar como tipo de retorno um subtipo do tipo de retorno do método da superclasse.

• Se o tipo de retorno é um tipo primitivo, então o tipo de retorno do método redefinido tem que ser idêntico ao tipo de retorno do método da superclasse.



• Um método só pode ser redefinido na subclasse

se for visível da superclasse para a subclasse.– Se um método definido na superclasse não é visível na

subclasse então não é herdado.

– Se um método não é herdado, mesmo que um método com o mesmo identificador, mesmos parâmetros (número e tipo) e retorno covariante seja definido na subclasse, este método não é uma redefinição do método na superclasse.



• A visibilidade dos métodos redefinidos pode ser diferente da dos métodos da superclasse, mas apenas para dar mais acesso.– Por exemplo, um método declarado na superclasse como protected pode ser redefinido protected ou public, mas não private ou com visibilidade de pacote.



• Um método de instância não pode ter o mesmo

identificador tipo e número de parâmetros que

um método estático herdado, e vice-versa, ou

seja não podemos passar um método para

estático ou não estático.

• Um método redefinido pode ser declarado

abstracto, mesmo que o método da superclasse

não o seja.



• A propriedade final dos parâmetros dum método

duma superclasse, pode ser retirada ou colocada

num método redefinido (trata-se apenas um detalhe de implementação).

• Um método redefinido pode ser declarado final, mas obviamente o método na superclasse não o poderia ser.



• A redefinição de métodos que substituem uma sequência de parâmetros por uma tabela é possível, mas é desanconselhável.– Um método de argumento variável, com uma sequência de

parâmetros T…, tem a mesma assinatura que um método que converte essa última sequência de parâmetros na tabela T[].



• Se um método definido numa subclasse tiver– o mesmo identificador, – mas diferente número ou tipo de parâmetros,

que um método (visível) da superclasse então é uma sobreposição.

• Se um método definido numa subclasse tiver– o mesmo identificador,– mesmos número e tipo de parâmetros, – mas o retorno não for covariante

relativamente a um método (visível) da superclasseentão existe um erro de compilação.



• Um atributo da superclasse que é declarado na subclasse com o mesmo nome (independentemente do tipo) é escondido.– Não há redefinição de atributos, estes são sempre escondidos.

– O atributo da superclasse continua a existir, mas deixa de ser possível à subclasse aceder-lhe directamente.

– É necessário usar a referência super, ou outra referência para o objecto da superclasse, para aceder ao atributo escondido.


Polimorfismo

• Numa hierarquia de classes, quando há redefinição de um método a sua implementação é substituída.– Na presença de uma referência para um objecto na hierarquia

de classes, a chamada sobre esse objecto ao método redefinido refere-se ao método de que classe?

• Quando um método é chamado através de uma

referência para um objecto, a classe de

instânciação do objecto (não necessariamente a

classe de declaração) dita a implementação a ser

usada.SuperClasse sub = new SubClasse();

classe de declaração de sub classe de instanciação de sub


Polimorfismo

• A classe de declaração de um objecto édeterminada em tempo de compilação.– O compilador tem acesso a essa informação na própria

declaração da referência.

Conta conta;

...

//num outro ponto do programa

conta = new ContaOrdem();

Conta conta = new ContaOrdem();


Polimorfismo

• A classe de instânciação de um objecto é

determinada apenas em tempo de execução.– A classe de instânciação pode sempre ser de uma classe

mais abaixo na hierarquia, relativamente à classe

declarada.

– A instanciação de um objecto pode ser feita num ponto do programa completamente diferente do ponto onde a declaração foi feita.

– Apenas o fluxo do programa dirá qual a classe de instanciação.

Conta conta;

...

//num outro ponto do programa

Conta = new ContaOrdem();


Polimorfismo

public class Conta {

protected String str = “Conta”;

public void imprime() {

System.out.println(“ComtaImprime(): “+str);

}

}

public class ContaOrdem extends Conta {

protected String str = “ContaOrdem”;

public void imprime() {

System.out.println(“ContaOrdemImprime(): “+str);

}


Polimorfismo//... Continuação do slide anterior

public static void main(String[] args) {

ContaOrdem contaOrdem = new ContaOrdem();

Conta conta = contaOrdem;

conta.imprime();

contaOrdem.imprime();

System.out.println(“conta.str = “+conta.str);

System.out.println(

“contaOrdem.str = ”+contaOrdem.str

);

}

}

ContaOrdemImprime(): ContaOrdem

ContaOrdemImprime(): ContaOrdem

conta.str = Conta

contaOrdem.str = ContaOrdem

No terminal é impresso:Notar que os métodos são redefinidos

mas não os atributos


Polimorfismo

• Relativamente ao slide anterior:– A classe de declaração e instanciação de contaOrdem écontaOrdem.

• contaOrdem é tipo contaOrdem.

• contaOrdem contem um objecto contaOrdem.

– A classe de declaração de conta é Conta mas a instanciação de conta é contaOrdem.

• conta é tipo conta.

• Conta contem um objecto contaOrdem definido em memória.


Polimorfismo

• Exemplo: – num jogo existem três objectos Nave, Asteróide e Meteoro.

Para uma das nove colisões possíveis pretende-se chamar um método diferente, determinado em tempo de compilação:

Public abstract Classe ObjectoJogo {

abstract colisão(ObjectoJogo outro);

}


PolimorfismoPublic abstract Classe Nave {

colisão(ObjectoJogo outro){ outro.colisãoComNave(this);}

colisãoComNave(Nave outro){ … }

colisãoComAsteroide(Asteroide outro){ … }

colisãoComMeteoro(Meteoro outro){ … }

}

Public abstract Classe Asteroide {

colisão(ObjectoJogo outro){ outro.colisãoComAsteroide(this);}




}

Public abstract Classe Meteoro {

colisão(ObjectoJogo outro){ outro.colisãoComMeteoro(this);}




}


Referência super (1)

• A referência super está disponível em todos os métodos de instância duma subclasse.

• No acesso a atributos e chamada de métodos, a referência super funciona como uma referência vista como uma instância da superclasse.

• A chamada super.método usa sempre a implementação do método da superclasse (definido ou herdado).



public class SuperClasse {

protected void nome() {

System.out.println(“SuperClasse”);

}

}

public class SubClasse extends SuperClasse {

protected void nome() {

System.out.println(“SubClasse”);

}



//... Continuação do slide anterior

protected void imprimeNome() {

SuperClasse sup = (SuperClasse) this;

System.out.print(“this.nome(): ”);

this.nome();

System.out.print(“sup.nome(): ”);

sup.nome();

System.out.print(“super.nome(): ”);

super.nome();

}

}

No terminal é impresso this.nome(): SubClasse

sup.nome(): SubClasse

super.nome(): SuperClasse


Membros estáticos (1)

• Os membros estáticos duma classe, atributos ou

métodos, não podem ser redefinidos, são sempre

escondidos.

• Se uma referência é usada para aceder aos membros estáticos, o membro a aceder é sempre determinado pela classe de declaração da referência.



public class SuperClasse {

protected static String str = “SupCStr”;

public static void imprime() {

System.out.println(“SuperCImprime(): “+str);

}

}

public class SubClasse extends SuperClasse {

protected static String str = “SubCStr”;

public static void imprime() {

System.out.println(“SubCImprime(): “+str);

}



//... Continuação do slide anterior

public static void main(String[] args) {

SubClasse sub = new SubClasse();

SuperClass sup = sub;

sup.imprime();

sub.imprime();

System.out.println(“sup.str = ”+sup.str);

System.out.println(“sub.str = ”+sub.str;

}

}

No terminal é impresso SupCImprime(): SupCStr

SubCImprime(): SubCStr

sup.str = SupCStr

sub.str = SubCStr


Conversão explícita (1)

• Um cast é usado para dizer ao compilador que uma expressão deve ser vista como tendo o tipo espeficicado pelo cast.– Upcast: cast de um classe para outra acima na hierarquia

de classes (de subclasse para superclasse, não necessariamente directa).

– Downcast: cast de uma classe para outra abaixo na hierarquia de classes (de superclasse para subclasse, não necessariamente directa).•• Se o objecto não pertencer a classe especificada Se o objecto não pertencer a classe especificada éé gerado um gerado um excepexcepçção de tempo de execuão de tempo de execuçção.ão.

• O upcast é também conhecido como cast seguro, porque é sempre válido. No o downcast é verificado em tempo de execução.



• No Java, um atributo ou variável local de uma superclassesuperclasse pode pode

referenciar qualquer das suas subclassesreferenciar qualquer das suas subclasses. • No entanto, só podem ser (directamente) chamados os atributos e

métodos definidos na superclasse.• Ou seja o objecto é tratado como se fosse da superclasse.

public class B extends A {

void b() {...}

...

}

public class A {

void foo() {...}

...

}

public class Armazem {

A var[] = new A[2];

void xpto(){

var[0] = new A();

var[0].foo();

var[1] = new B();

var[1].foo();

}

}



• Relativamente ao exemplo anterior:– Tanto var[0] como var[1] não têm acesso (directo) ao

método foo() de B (mesmo tendo sido var[1] instanciado como um objecto de tipo B).

– No entanto, var[1] pode aceder ao método b() através dum downcast:((B)var[1]).b();

– Se a subclasse B redefinir o método foo(), qual o código executado na chamada var[1].foo()?

• Executa-se sempre o método mais abaixo na hierarquia de classes, portanto a resposta correcta seria foo() de B (ver slide 25).


Herança e sobreposição (1)

• Uma classe X diz-se compatível (assignment compatible) com uma classe Y se:– X=Y, ou

– X é uma subclasse de Y (directa ou indirecta)

• Uma classe X é mais específica que classe Y – X é uma subclasse de Y (directa ou indirecta)

Z

Y

X

• A compatibilidade também pode ser aplicada a tipos primitivos, usando-se neste caso a ordenação dada na conversão implícita dos mesmos:

byte->short->int->long->float->double



• Quando um método é chamado e há sobreposição de métodos, de tal forma que o tipo dos parâmetros dos métodos sobrepostos se encontram numa mesma hierarquia, o compilador escolhe o mméétodo mais espectodo mais especííficofico (se existir).– A determinação do método a chamar é feita em tempo de compilação, baseada no tipo declarado das referências passadas aos métodos, e no valor dos argumentos.

– Este processo determina apenas qual o método a chamar, não qual a implementação. Em tempo de execução, a classe de instanciação do objecto sobre o qual o método é chamado é que vai determinar qual a implementação do método, escolhido em tempo de compilação, que vai ser usada.



• Determinação do método mais específico:1. Determinar a classe sobre a qual procurar pelo método.

2. Determinar todos os métodos dessa classe que possam ser aplicados:a) Métodos com visibilidade correcta.

b) Métodos com o mesmo identificador.

c) Métodos que possam receber o número de argumentos passados.

d) Métodos cujos tipos dos parâmetros sejam compatíveis com os tipos declarados das referências passadas como argumento.



2. (cont.)A compatibilidade dos tipos em 2.d) é feita em 3 fases:i. A compatibilidade é considerada sem tentar nenhuma

conversão de embrulho (boxing conversion), e sem considerar a possibilidade de número variável de argumento.

ii. Se 1. falhar, a compatibilidade é considerada com a possibilidade de conversão de embrulho (boxingconversion).

iii. Se 2. falhar, a compatibilidade é considerada com a possibilidade de número variável de argumentos.



São eliminados todos os mSão eliminados todos os méétodos em todos em todos os argumentos todos os argumentos sejam sejam superclassessuperclasses dos argumentos de outro mdos argumentos de outro méétodotodo. Ou seja aqueles em que exista um método com todos os argumentos mais específicos que os de outro método.

Exemplo: O Método3 éé eliminado eliminado porque todos seus argumento são super classes tanto Metodo1 como de Método2.

Método2 e Método1 não são não são eliminados porque alguns dos seus argumentos são superclasses do outro enquanto que outros são subclasses. Nenhum dos métodos é definitivamente o mais especifico que outro e um erro de compilação será gerado.

Chamada do método: foo(“123”, “abc”);

Método1: Void foo(String a, Object b);

Método2: Void foo(object a, String b);

Método3: Void foo(Object a, Object b);



4. Determinar o método a chamar:a) Se apenas um método foi escolhido em 3., esse método é o

mais específico e é chamado.b) Se foi escolhido mais de um método em 3. temos duas

hipóteses:

i. Se os métodos têm assinaturas diferentes, a chamada éambígua e o código que o chama é inválido.

ii. Se os métodos têm a mesma assinatura temos três hipóteses:– Se todos os métodos são abstractos, é escolhido um ao

acaso.– Se apenas um método não é abstracto, é escolhido esse

método.– De qualquer outra forma a chamada é ambígua e o código

que o chama é inválido.



void xpto(Sobremesa d, Scone s) {...} // 1ª forma

void xpto(Bolo c, Sobremesa d) {...} // 2ª forma

void xpto(BoloChocolate cc, Scone s) {...} // 3ª forma

void xpto(Sobremesa... ds) {...} // 4ª forma

As seguintes chamadas:• xpto(sobremesaRef, sconeRef);

• xpto(boloChocRef, sobremesaRef);

• xpto(boloChocRef, sconeAmanteigadoRef);

• xpto(boloRef, sconeRef);

• xpto(sconeRef, boloRef);

resultam na chamada de que forma do método xpto?

Sobremesa

Bolo

BoloChocolate

Scone

SconeAmanteigado



• Relativamente ao exemplo anterior:– xpto(dessertRef, sconeRef);

resulta na chamada da 1ª forma do método xpto.

– xpto(chocolateCakeRef, dessertRef);


– xpto(chocolateCakeRef,

butteredSconeRef);


– xpto(cakeRef, sconeRef);

é inválida.

– xpto(sconeRef, cakeRef);


Sobremesa

Bolo

BoloCh

ocolat

e

Scone

Scone

Amant

eigad

o



• No exemplo anterior, xpto(boloRef, sconeRef);

é uma chamada inválida, contudo:– Com o cast (Sobremesa)boloRef a chamada

xpto((Sobremesa)boloRef, sconeRef);

resultaria na chamada da 1ª forma de xpto.

– Com o cast (Sobremesa)sconeRef a chamada xpto(boloRef, (Sobremesa)sconeRef);

resultaria na chamada da 2ª forma de xpto.



void xpto(byte b) {...} // 1ª forma

void xpto(Short s) {...} // 2ª forma

void xpto(int i) {...} // 3ª forma

void xpto(Long i) {...} // 4ª forma

void xpto(float f) {...} // 5ª forma

void xpto(Double d) {...} // 6ª forma

As seguintes chamadas:• xpto(byteRef);

• xpto(shortRef);

• xpto(intRef);

• xpto(longRef);

• xpto(floatRef);

• xpto(doubleRef);

resultam na chamada de que forma do método xpto?(cuidado com conversões de boxing e unboxing)



• Relativamente ao exemplo anterior:– xpto(byteRef);

resulta na chamada da 1ª forma do método xpto.– xpto(shortRef);

resulta na chamada da 3ª forma do método xpto.– xpto(intRef);

resulta na chamada da 3ª forma do método xpto.– xpto(longRef);

resulta na chamada da 5ª forma do método xpto.– xpto(floatRef);

resulta na chamada da 5ª forma do método xpto.– xpto(doubleRef);


09 Java Heranca Polimorfismo 07

Documents

Transcript of 09 Java Heranca Polimorfismo 07