linguagem de programação iwiki.cbatista.net/lib/exe/fetch.php/lpi-aula12-he... · herança...

Linguagem de Programação I

Carlos Eduardo Batista

Centro de Informática - UFPB bidu@ci.ufpb.br

Herança e composição

Herança simples

Composição

Combinando composição e herança

Polimorfismo e funções virtuais

Classes abstratas

Herança múltipla (!!!)

2

C++ e POO

Herança e composição em C++ ◦ Classes abstratas

◦ Herança múltipla

3

Encapsulamento e Composição 4

Carro

private: String modelo; String chassis; Motor m;

public: liga(); acelera(int); freia(int); private: liberaCombustivel(int); freioABS(int);

Herança

Hierarquia de classes

Classes mais especializadas herdam das mais genéricas

Atributos e métodos são herdados

Classe filha é um “tipo de” Classe Pai

5

Herança 6

Polígono

Cor c;

desenhar(); apagar(); definirCor(Cor c); area();

Retângulo

desenhar(); apagar(); area();

Triângulo

desenhar(); apagar(); area();

Círculo

desenhar(); apagar(); area();

Herança simples 7

Animal

int idade;

come() dorme()

Ave

botaOvo()

Mamífero

mama()

Cachorro

late() morde()

Curió

canta() voa()

Herança privada

Herança privada ◦ o que era publico na classe base passa a ser privado na classe derivada

◦ A classe derivada é implementada em termos da classe base, e nao é um tipo da classe base

◦ Pode-se expor alguns nomes na interface publica utilizando-se a palavra chave using

8

Herança privada 9

class Pet {

public:

char eat() const { return 'a'; }

int speak() const { return 2; }

float sleep() const { return 3.0; }

float sleep(int) const { return 4.0; }

};

class Goldfish : Pet { // Private inheritance

public:

using Pet::eat; // Name publicizes member

using Pet::sleep; // Both overloaded members exposed

};

int main() {

Goldfish bob;

bob.eat();

bob.sleep();

bob.sleep(1);

//! bob.speak();// Error: private

}

Atributos protegidos

Especificadores de acesso ◦ public

◦ private

◦ protected

Herança ◦ Algo privado para os usuarios da classe, mas acessivel para os membros da propria classe e de suas classes derivadas

Encapsulamento protected

10

Atributos protegidos 11

include <fstream>

using namespace std;

class Base {

int i;

protected:

int read() const { return i; }

void set(int ii) { i = ii; }

public:

Base(int ii = 0) : i(ii) {}

int value(int m) const { return m*i; }

};

class Derived : public Base {

int j;

public:

Derived(int jj = 0) : j(jj) {}

void change(int x) { set(x); }

};

int main() {

Derived d;

d.change(10);

}

Polimorfismo e funções virtuais

12

Polimorfismo e funções virtuais

13

class Shape{

// ...

virtual void draw( );

};

class Triangle : public Shape {

// ...

virtual void draw( ); // virtual é opcional

};

void teste(Shape & a) {

a.draw();

}

int main() {

Triangle t;

teste(t); // Agora, chama draw de Triangle!

}

Herança 14

Classes abstratas

Classe abstrata é uma classe que não tem instâncias diretas ◦ Subclasses podem possuir instâncias

Classe concreta é uma classe instanciável

Método abstrato = método sem implementação (pure virtual) ◦ virtual void metodoAbstrato(...)=0;

15

Classes abstratas

Operações abstratas são definidas através de acoplamento dinâmico

Classes abstratas ◦ Obrigatoriamente não possuem instâncias e podem possuir métodos abstratos

A classe que define uma função virtual pura é uma classe abstrata pois não se pode declarar objetos dela.

Pode ser manuseada com ponteiros para manipular objetos de classes derivadas.

16

Classes abstratas 17

Classes abstratas 18

Classes abstratas 19

•#include <iostream>

•using namespace std;

•

•class Animal

•{

•public:

• virtual void comer() = 0;

• // Superclasses devem

• // ter o destrutor virtual

• virtual ~Animal()

• {

• }

•};

•

•class Lobo: public Animal

•{

•public:

• void comer()

• {

• cout << "Eu me alimento como um

lobo!" << endl;

• }

•};

•class Peixe: public Animal

•{

•public:

• void comer()

• {

• cout << "Eu me alimento como um

peixe!" << endl;

• }

•};

•

•int main(void)

•{

• Animal *a = new Lobo();

• Animal *b = new Peixe();

•

• a->comer();

• b->comer();

•

• return 0;

•}

Herança múltipla

A herança múltipla é a capacidade de uma classe derivada ter mais de uma classe base.

Permitir que que sejam definidas novas classes que herdem características de várias classes base (não relacionadas).

Reusabilidade ◦ Otimização o tempo de desenvolvimento

Organização ◦ Facilita o desenvolvimento e a interpretação na

manutenibilidade

20

Herança múltipla

A declaração do construtor de uma classe que é derivada de várias classes bases deve especificar os argumentos para as funções construtoras de todas as classes base

Pode ser manuseada com ponteiros para manipular objetos de classes derivadas.

21

Herança múltipla

A herança múltipla traz alguns novos problemas: ◦ Declaração de métodos de mesmo nome em duas superclasses distintas

Suponha dois métodos m() declarados tanto na classe

Vendedor quanto na Gerente ◦ Um objeto da Classe VendedorGerente que tenta invocar m() não saberia como fazer

◦ Indicar um caminho

22

Herança múltipla 23

Herança múltipla

No mesmo exemplo, haverá duas instâncias (ou objetos) da classe Empregado. Assim, um objeto da classe VendedorGerente não saberá qual deles utilizar ◦ indicar o caminho

◦ utilizamos a palavra virtual na herança

24

Herança múltipla 25

Herança múltipla 26

•class Knife

•{

•int d_blade;

•public:

•Knife(int blade):d_blade(blade){};

•int blade() const{ return d_blade; }

•void setBlade(int blade){ blade=blade;}

•};

•class CorkScrew

•{ int d_screw;

•public:

•CorkScrew(int screw):d_screw(screw){};

•int screw() const{ return d_screw; }

•void setScrew(int blade){ d_screw=screw;}

};

•class SwissKnife: public Knife, public

CorkScrew

•{ public:

•SwissKnife(int blade, int screw)

•: Knife(blade),CorkScrew(screw) {}

•}

•int main()

•{

• SwissKnife k(5,3);

• k.Knife::increase(2); // aumenta a lamina

• k.CorkScrew::increase(2);

•// aumenta o saca rolhas

• //SwissKnife k(5,3);

• Knife f(10);

• f=k; // possıvel, d_blade de f = 5

•}

Herança múltipla 27

•int lbs_weight(Vehicle const &v)

•// converte peso em libras

•{ return v.weight()*4.86;}

•int main()

•{

• Land l(1200, 130);

• Truck t(2600, 120, 6000);

• cout << lbs_weight(l) << "\n";

• << lbs_weight(t) << "\n";

•}

•Land l(1200, 130);

•Truck t(2600, 120, 6000);

•Vehicle *vp;

•vp = &l; // conv. implıcita para Vehicle

•vp = &t; // conv. implıcita para Vehicle

•Truck t(2600,120, 6000);

•Vehicle *vp;

vp = &t; // vp aponta para Truck

cout << pt->weight() << "\n"; // 2600

•Truck *pt;

•pt = reinterpret_cast<Truck *>(vp);

•cout << pt->weight() << "\n"; // 8600

•// Aqui a conversao (reinterpret

//cast<Truck*>)

•//transforma vp em Truck;

•//eh preciso ter cuidado,

•//só funciona se vp

•//apontar para um Truck;

Próximas aulas

Templates

Exceções ◦ (2ª. Prova e trabalho)

STL

Programação Orientada a Eventos

Programação concorrente (Threads) ◦ (3ª. Prova e trabalho)

28

Referências

Notas de aula do Prof. Renato Maia (Unimontes)

Notas de aula do Prof. Renato Mesquita (UFMG)

Notas de aula do Prof. Rodrigo Mello (USP)

http://www.rafaeltoledo.net

29

Linguagem de Programação I

Carlos Eduardo Batista

Centro de Informática - UFPB bidu@ci.ufpb.br