4

MÓDULO 3
Conceitos básicos II
Iniciação à Programação orientada a Objetos

Herança
4 Herança

Conteúdo
4.1 Agregação e composição 05

4.2 Conversão implícita e explícita com referências a objetos 06

4.3 Ligação estática e ligação dinâmica 08

4.4 O operador Instanceof 09

4.5 O método Finalize() 10

4. Herança

A herança aplica-se sobre as classes e indica que estas podem ter descendência a que cederão propriedades e
métodos. Desta forma, é gerada uma estrutura hierarquizada.

Cor
Motor
------------------
Acelerar()
Travar()

Classe Carro
Cor =”Vermelha”
Motor =”Diesel”
Portas
Portas =5
ABS
ABS =”sim”
------------------
Acelerar()
Virar()
Travar()
Girar()
Classe Seat

Objeto Seat Cordoba

Observemos que o objeto Seat Cordoba, por pertencer à classe Seat, adquire todas as suas propriedades e métodos,
mas, por sua vez, como a classe Seat herda da classe Carro, o objeto também apresenta todas as propriedades
e métodos desta. Além disso, como podemos ver na imagem, continua a ser no objeto e não nas classes onde
as propriedades obtêm valor.

04 MÓDULO 3 • Iniciação à Programação orientada a Objetos

4. Herança

4.1 Agregação e composição

• Agregação. Consiste em criar um objeto a partir de uma classe denominada objeto contentor e que incluirá
referências a objetos de outra classe a que chamamos objetos contidos. A vida dos objetos contidos não
está limitada à vida do contentor.

• Composição. Neste caso, existe um objeto que chamamos contentor, formado por objetos de outra classe,
a que chamamos contidos, de forma que a vida dos contidos está limitada à do contentor.

Iniciação à Programação orientada a Objetos • MÓDULO 3 05

4. Herança

4.2 Conversão implícita e explícita com

referências a objetos
Ponto p = new Ponto();
Data f = new Data();
p = f; // Erro, são classes diferentes.
p = (Ponto) f; // Erro, com casting também não é válido.

Se as classes estiverem relacionadas através de herança, podem realizar-se conversões.

O Java permite converter uma referência à classe derivada numa referência à classe base implicitamente, assim
como converter uma referência à classe base, numa referência à classe derivada, utilizando casting:

Animal a;
Cão
a = new Cão(); //Correto
Animal
Cão p;
Cavalo
p = new Animal(); // Erro

Ponto p = new Ponto();

Ponto Ponto px = new Pixel();
p = px; // Correto, conversão implícita.
px = p; // Erro, necessita de casting.
Pixel
px = (Pixel) p; // Correto.
px.x = 3; px.y = 5; px.color = 1;
p.x = 3; p.y = 5; // Não pode aceder a cor.

Ponto p = new Ponto();

Pixel px = new Pixel();
p = px; // Converte-se a referência e não o objeto.
....
// Perde-se px.
....
// Pretende-se aceder a cor.
p.color = 3; // Erro, p apenas pode aceder a x e y.
Pixel px2 = (Pixel) p;
px2.color = 3; // Correto utilizando casting.
Ponto p = new Ponto (1,3);
Pixel px = new Pixel (2, 4, 1);
px = (Pixel) p; // Compila com casting.
px.color = 5; // Engana-se na compilação, mas em tempo
// de execução produz uma exceção.

06 MÓDULO 3 • Iniciação à Programação orientada a Objetos

4. Herança

px

2 1

4
x 3
x Ponto
y y
1
cor 5

Entre classes irmãs, não se podem realizar conversões, nem sequer com o operador casting. É lógico que não
se pode efetuar a conversão, já que existirão atributos e métodos numa classe, que não estarão presentes na
outra e vice-versa.

Base Deriv1 d1 = new Deriv1();

Deriv2 d2 = new Deriv2();
Deriv1 Deriv2 d1 = d2; // Error.
d1 = (Deriv1) d2; // Error.

Em Java, não são permitidas conversões, entre as referências e os tipos fundamentais de dados, nem com casting:

int a = 3;
Ponto p = (Ponto) a; // Erro.

Para além disso, em Java não existe a herança múltipla, o que implica que uma classe apenas possa herdar de
uma só classe. Em alternativa, em linguagens como C++, esta é produzida, de modo que uma classe poderia
herdar de várias (poderia apresentar mais de um pai).

Iniciação à Programação orientada a Objetos • MÓDULO 3 07

4. Herança

4.3 Ligação estática e ligação dinâmica

class Base {
final void Método1() {
System.out.println (“Método da Classe Base”);
}

}class Derivada extends Base {

void Metodo1() {
System.out.println (“Método da Classe Derivada”);
}

Base b = new Derivada(); // Correto;

b.Metodo1(); // Qual se executa?

• Ligação estática. Consiste em decidir que método executar em função do tipo de referência com a qual
se está a apontar para o objeto (executa-se o Método1 da classe base).

A vantagem da ligação estática consiste em ser mais rápida que a ligação dinâmica porque, em tempo
de compilação já se sabe que método executar. Contudo, apresenta o inconveniente de, normalmente, se
querer executar o método do objeto apontado e não o da referência usada para apontar.

• Ligação dinâmica. Consiste em decidir que método se deve executar em função do tipo de objeto que se
está a apontar, a partir da referência (executa-se o Método1 da classe derivada).

A ligação dinâmica é mais lenta porque, até chegar o momento de executar o método, não sabe a que objeto
estará apontada a referência.

O Java utiliza, por defeito, a ligação dinâmica e, se se pretende usar a estática, deve indicar-se o modificador
final ao método.

08 MÓDULO 3 • Iniciação à Programação orientada a Objetos

4. Herança

4.4 O operador Instanceof

Serve para perguntar se um objeto ao que se está a apontar, com uma referência, pertence a uma determinada
classe. O formato é o seguinte:

<Referência> instanceof <classe>

Exemplo:

Pixel px = new Pixel();

if (px instanceof Pixel) {

// px es Píxel. Cumpre-se.
}

if (px instanceof Data) {

// px não é Data. Não entra.
}

if (px instanceof Ponto) {

// px não é Ponto, mas Píxel deriva de Ponto. Cumpre-se.
}

if (px instanceof Object) {

// px ao derivar de Ponto, Ponto deriva de Object.
// Cumpre-se.
}

Iniciação à Programação orientada a Objetos • MÓDULO 3 09

4. Herança

4.5 O método Finalize()

Este método executa-se precisamente antes de o coletor de lixo do Java libertar a memória do objeto. Pode
redefinir-se para indicar as operações que se queiram realizar, antes de destruir o objeto:

class Ponto p = new Ponto (2,3);

p.finalize() // Executaria as operações de desinicialização,
// mas não da biblioteca memória.

class Ponto {
int x, y;

protected void finalize() throws Throwable {

//Operações de desinicialização.

• É executado unicamente por JVM.

• Encontra-se vazio na classe Object; é nas classes derivadas que se redefine.

super.finalize();

Exemplo:

class Pixel {
int x, y, color;

protected void finalize() throws Throwable {

super.finalize(); // Ponto à Object.
}
}

10 MÓDULO 3 • Iniciação à Programação orientada a Objetos

4. Herança

Iniciação à Programação orientada a Objetos • MÓDULO 3 11