Linguagem de Programação I

Transcrição

1 Linguagem de Programação I Carlos Eduardo Batista Centro de Informática - UFPB bidu@ci.ufpb.br

2 Herança simples Composição Combinando composição e herança Polimorfismo e funções virtuais Classes abstratas Herança múltipla (!!!) Herança e composição 2

3 Herança e composição em C++ Classes abstratas Herança múltipla C++ e POO 3

4 Carro private: String modelo; String chassis; Motor m; public: liga(); acelera(int); freia(int); private: liberacombustivel(int); freioabs(int); Encapsulamento e Composição 4

5 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 Herança 5

6 Polígono Cor c; desenhar(); apagar(); definircor(cor c); area(); Retângulo desenhar(); apagar(); area(); Círculo desenhar(); apagar(); area(); Triângulo desenhar(); apagar(); area(); Herança 6

7 Animal int idade; come() dorme() Ave botaovo() Mamífero mama() Curió canta() voa() Herança simples Cachorro late() morde() 7

8 Herança privada o que era pu blico na classe base passa a ser privado na classe derivada A classe derivada é implementada em termos da classe base, e na o é um tipo da classe base Pode-se expor alguns nomes na interface pu blica utilizando-se a palavra chave using Herança privada 8

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 } Herança privada 9

10 Especificadores de acesso public private protected Herança Algo privado para os usua rios da classe, mas acessi vel para os membros da pro pria classe e de suas classes derivadas Encapsulamento protected Atributos protegidos 10

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); } Atributos protegidos 11

12 Polimorfismo e funções virtuais 12

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! } Polimorfismo e funções virtuais 13

14 Herança 14

15 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; Classes abstratas 15

16 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. Classes abstratas 16

17 Classes abstratas 17

18 Classes abstratas 18

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; } Classes abstratas 19

20 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 Herança múltipla 20

21 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. Herança múltipla 21

22 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 Herança múltipla 22

23 Herança múltipla 23

24 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 Herança múltipla 24

25 Herança múltipla 25

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;} }; 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 } class SwissKnife: public Knife, public CorkScrew { public: SwissKnife(int blade, int screw) : Knife(blade),CorkScrew(screw) {} } Herança múltipla 26

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; Herança múltipla 27

28 Templates Exceções (2ª. Prova e trabalho) STL Programação Orientada a Eventos Programação concorrente (Threads) (3ª. Prova e trabalho) Próximas aulas 28

29 Notas de aula do Prof. Renato Maia (Unimontes) Notas de aula do Prof. Renato Mesquita (UFMG) Notas de aula do Prof. Rodrigo Mello (USP) Referências 29

30 Linguagem de Programação I Carlos Eduardo Batista Centro de Informática - UFPB bidu@ci.ufpb.br