Assim, a POO disponibiliza um mecanismo de herança que vai facilitar a reutilização do código através da construção de uma hierarquia de classes.

Transcrição

1 HERANÇA É muito útil o encapsulamento de dados fornecido pela classe, mas ainda o será mais se o programador puder adaptar a classe para outra aplicação, acrescentando, modificando, subtraindo métodos da classe dada. Assim, a POO disponibiliza um mecanismo de herança que vai facilitar a reutilização do código através da construção de uma hierarquia de classes. Num mundo ideal um analista teria uma biblioteca de objectos com código já implementado, à sua disposição, especificaria quais os necessários ao novo produto e a implementação do sistema seria a simples tarefa de escolher e colocá-los todos juntos. Infelizmente, no mundo real as coisas não são tão simples. Um dos maiores problemas, para que só um pequeno conjunto de software possa ser reutilizado, é o facto de que geralmente, um módulo já implementado faz quase o que queremos mas nunca tudo o que precisamos. O trabalho de o alterar para o que pretendemos é dificil e exige muito tempo. Em alguns casos o módulo é inteiramente implementado, o que se torna mais rápido do que proceder a alterações que obrigariam ao estudo da implementação com a documentação existente. Dispondo de mecanismos de herança, a especificação de uma classe pode ser retirada de uma biblioteca existente e uma nova classe pode ser criada a partir dela, através do processo de derivação. A classe existente será a classe pai, base e a nova a classe filho, derivada. A nova classe especifica simplesmente as características que são diferentes das da classe pai. Uma instanciação da classe filho, conduz a um objecto que contem as funcionalidades e caracteristicas do filho e as do pai. Diz-se então, que uma instância da classe filho herda características e funcionalidades, ou seja, a estrutura e comportamento da classe pai. Como já foi referido nas páginas da introdução, a herança pode ser simples, ou múltipla, conforme a classe filho tem uma ou várias classes pai. A POO, é geralmente mais difìcil do que a programação convencional e exige, pelo menos um passo no projecto antes de realizar o algoritmo, que é a hierarquização de tipos que serão úteis para o problema. Engª Informática do ISEP 1

2 A solução orientada a objectos fica assim mais robusta, mais fácil de manter e alterar e claro, mais reutilizável. Todos estes benefícios são especialmente úteis e importantes para projectos com grande quantidade de código, que exigem coordenação entre programadores. No caso da linguagem que temos vindo a considerar, o C++, a possibilidade de ter header files, especifica interfaces gerais para diferentes classes, permite a cada programador trabalhar com segmentos de código individual com grande grau de independência e integridade. Engª Informática do ISEP 2

3 HERANÇA EM C++ HERANÇA SIMPLES No caso da linguagem C++ o utilizador pode construir classes com herança do tipo simples ou do tipo múltipla. A declaração em C++ de uma classe derivada pode fazer-se do seguinte modo: class <nome da classe derivada> : <nome da classe pai> class <nome da classe derivada> : private <nome da classe pai> class <nome da classe derivada> : public <nome da classe pai> A seguir aos 2 pontos, o nome da classe pai pode ser precedido pelas palavras chave private ou public. Quando essas palavras chave não existem, a classe derivada será por defeito, privadamente derivada. Se a classe filho foi publicamente derivada, então tudo o que é público aos utilizadores da classe pai, será público para os utilizadores da classe filho, a não ser que seja sobrecarregado na função filho. Se o filho é uma classe privadamente derivada, então nada do pai pode ser público para os utilizadores da classe filho. Quer o filho seja pública ou privadamente derivado pode sempre aceder aos membros públicos do pai. A classe derivada não pode aceder aos dados privados da classe pai, para que a protecção da classe não seja quebrada só pelo processo de derivação. Pode no entanto, ser especificamente autorizada para isso. Assim, existem 2 processos: Construção de funções friend (ou a classe inteira ou alguns métodos). ou Membros declarados na parte protegida que são acedidos pelas classes derivadas. Assim é criado um nível de acesso adicional, protected. Um membro protegido comporta-se como um membro público para a classe derivada, mas é considerado privado para o resto do programa.. Engª Informática do ISEP 3

4 ACESSO DOS UTILIZADORES DE OBJECTOS DE CLASSES DERIVADAS class base private: protected: Utilizadores da classe base class derivada : public base private: protected: Utilizadores da classe derivada class base private: protected: Utilizadores da classe base class derivada : private base private: protected: Utilizadores da classe derivada Engª Informática do ISEP 4

5 Assim as funções membro do filho podem aceder, por exemplo, a uma variável declarada na zona protegida da classe pai, mas os utilizadores da classe pai ou da classe filho não podem Para melhor entendermos estes mecanismos de visualização consideremos um exemplo em que a uma classe base designada por pai, derivamos 2 outras subclasses, filho1, privadamente derivada e filho2, publicamente derivada. Sempre que uma classe derivada redefine uma função membro pública da classe base, se pretendemos fazer actuar sobre um objecto da classe derivada, o método da classe pai que foi redefinido, teremos que usar o operador de âmbito de resolução :: ( ver no exemplo que se segue d2.pai::display(); ). #include <stdio.h> class pai private: int pv1,pv2; void atribui(int p1,int p2) pv1=p1; pv2=p2; int increm1() return ++pv1; int increm2() return ++pv2; void display() printf("\n pv1=%d pv2=%d",pv1,pv2); class filho1 : pai // privadamente derivada private: int pv3; filho1 (int p3) pv3=p3; void atribui(int p1,int p2) // há que usar o operador :: para identificar qual atribui é pai::atribui(p1,p2); int increm1() return pai::increm1(); int increm3() return ++pv3; Engª Informática do ISEP 5

6 void display() pai::display(); printf("\n pv3= %d \n\n",pv3); class filho2 : public pai //publicamente derivada private: int pv4; filho2(int p4) // construtor pv4=p4; int increm1() int temp=pai::increm1(); temp=pai::increm1(); temp=pai::increm1(); return (pai::increm1()); int increm4() return ++pv4; void display() pai::display(); printf("\n pv4=%d",pv4); main() pai p; p.atribui(-2,-4); p.display(); } filho1 d1(-4); d1.atribui(20,21); d1.increm1(); // d1.increm2(); seria erro, porque d1 é um objecto de uma classe derivada privadamente, logo o utilizador dessa classe não tem acesso às funções da classe base d1.display(); filho2 d2(5); d2.atribui(-7,-8); d2.display(); d2.increm1(); d2.increm2(); d2.display(); d2.pai::increm1(); // actua o método da classe pai e não o redefinido em filho2 d2.display(); Engª Informática do ISEP 6

7 O resultado seria: pv1=-2 pv2=-4 pv1=21 pv2=21 pv3=-4 pv1=-7 pv2=-8 pv4=5 pv1=-3 pv2=-7 pv4=5 pv1=-2 pv2=-7 pv4=5 Uma classe derivada pode ainda ser objecto de derivação. Poder-se-ia por exemplo construir uma classe neto derivada de fillho2. class neto: public filho neste caso, a classe neto, herda de ambos os antecessores, filho2 e pai. A programação adicional requerida é só para aquelas operações que aumentam ou substituem os membros herdados. HERANÇA E CONSTRUTORES Os objectos das classes derivadas, contêm uma cópia dos dados da classe pai, logo também terão que ter um mecanismo para inicializar estes dados herdados do pai. Isso será feito através do construtor da classe derivada. Assim, sempre que se cria um objecto derivado, é invocado o construtor da respectiva classe e este por sua vez, invoca o construtor da classe base para se inicializarem os componentes da classe base no objecto derivado. Primeiro é executado o construtor da classe base, seguindo-se o da classe derivada. Se na lista de inicializações do construtor da classe derivada, não é especificada uma chamada ao construtor da classe base, o construtor sem argumentos é automàticamente invocado. Contudo, se a classe base tem um construtor que aceita argumentos e não tem construtor sem argumentos, o construtor da classe derivada tem forçosamente que explicitar a chamada do construtor base na lista de inicializações da classe derivada. Engª Informática do ISEP 7

8 Notar que neste caso, o C++ não gera automàticamente um construtor sem argumentos, porque a classe tem um explicitamente especificado. Essa geração só é feita se a classe base não tiver nenhum construtor. Suponhamos: class B B (int a) // construtor class D : public B D (int x) // construtor da classe derivada --- na criação de um objecto vamos ter erro Neste exemplo, ao criar um objecto do tipo D, obriga a ser invocado o construtor da classe D, que por sua vez invoca o construtor da classe B. Uma vez que não foi explicitada nenhuma invocação do construtor B na definição do construtor D, o C++ tenta invocar um construtor de B sem argumentos, mas por outro lado, B não tem tal construtor, só tem um com um argumento, o resultado será erro. Para evitar este tipo de erro teremos que tomar uma das seguintes opções: Definir para B um construtor sem argumentos ou Colocar explicitamente uma chamada ao construtor da classe base B, na lista de inicializações do construtor da classe D. Os construtores da classe derivada contêm a declaração de parâmetros que dizem respeito ao seus dados privados e aos dados privados do construtor da classe base. Assim, no exemplo abaixo, apareceria a definição do construtor de D (derivada) e a invocação do construtor de B (base) do seguinte modo: class B B (int a) // construtor Engª Informática do ISEP 8

9 class D : public B D (int x, int y) : (y) // O valor de x será atribuido a um dado privado de D e //o valor de y será o correspondente valor do parâmetro //do construtor da classe base B OU class D : public B D (int x, int y) : B(y) Na declaração de um objecto derivado, D, far-se-á a indicação dos valores dos dados privados desse objecto, que afinal são os herdados do pai, mais os próprios dele. A seguir transcreve-se o exemplo anterior, mas utilizando construtores em todas as classe e mais uma classe derivada, derivada3, que por sua vez é derivada da derivada2. #include <stdio.h> class pai private: int pv1,pv2; pai(int p1,int p2) pv1=p1; pv2=p2; int increm1() return ++pv1; int increm2() return ++pv2; void display() printf("\n pv1=%d pv2=%d",pv1,pv2); Engª Informática do ISEP 9

10 class derivada1 : pai private: int pv3; derivada1 (int p3,int p1,int p2):(p1,p2) // passagem de argumentos ao construtor pai pv3=p3; int increm1() return pai::increm1(); int increm3() return ++pv3; void display() pai::display(); printf("\n pv3= %d \n\n",pv3); class derivada2 : public pai private: int pv4; derivada2(int p4,int p1,int p2):(p1,p2) // passagem de argumentos ao construtor pai pv4=p4; int increm1() int temp=pai::increm1(); temp=pai::increm1(); temp=pai::increm1(); return (pai::increm1()); int increm4() return ++pv4; void display() pai::display(); printf("\n pv4=%d",pv4); class derivada3 : public derivada2 int pv5; derivada3(int p):derivada2(11,9,0)// valores explícitos dos dados do construtor pai pv5=p; void escreve()printf("pv5=%d\n pv4=%d\n",pv5,increm4()); main() Engª Informática do ISEP 10

11 } pai p(0,0); p.display(); derivada1 d1(-4,1,2); d1.increm1(); d1.display(); derivada2 d2(5,-5,6); d2.display(); d2.increm1(); d2.increm2(); d2.display(); d2.pai::increm1(); d2.display(); derivada3 d3(10); d3.pai::increm1(); d3.escreve(); Nota1: Não são herdados nem construtores, nem destrutores nem operadores de atribuição. Nota2: Quando se faz delete de um ponteiro para uma classe derivada, primeiro é executado o destrutor da classe derivada e seguidamente o destrutor da classe base. Engª Informática do ISEP 11

12 Vejamos agora um outro exemplo mais concreto que faz uso de classes derivadas. Seja a classe veiculo da qual se faz uma derivação pública para a classe terrestre. #include <iostream.h> class veiculo int peso; veiculo(int p=22) cout<<'1'<<'\n'; peso=p; void setpeso(int p) peso=p; int getpeso() return peso; void escreve() cout<< PESO= <<peso<<'\n'; class terrestre : public veiculo int veloc; terrestre(int vel=33) cout<<'2'<<'\n'; veloc=vel; terrestre(int p,int vel):veiculo(p) cout<<'3'<<'\n'; veloc=vel; void setvel(int v) veloc=v; int getpeso() return veiculo::getpeso(); // teve que recorrer-se ao método da classe base para poder obter o dado Engª Informática do ISEP 12

13 int getvel() return veloc; void escreve() cout << PESO= <<getpeso() <<'\n'; cout << VELOCIDADE= <<veloc <<'\n'; peso uma vez que peso é um membro privado dessa classe, logo não pode ser acedido pela classe derivada main() veiculo v; terrestre t(44); terrestre t1(5,88); v.escreve(); //v.setvelocidade(100); ERRO,este método não é membro da classe base t1.escreve(); t.escreve(); } A saída deste programa seria: 1 //Construtor com parâmetro por defeito, equivalente ao construtor sem parâmetros 1 //Construtor do objecto t, executando 1º o construtor da classe base ( construtor 2 // por defeito) e depois o construtor da classe derivada 1 //Construtor do objecto t1, executando 1º o construtor da classe base ( construtor 3 //com um argumento) e depois o construtor da classe derivada, com dois argumentos. PESO=22 PESO=5 VELOCIDADE=88 PESO=22 VELOCIDADE=44 Engª Informática do ISEP 13

14 HERANÇA MÙLTIPLA Este tipo de herança permite que conceitos diferentes, implementados como classes possam ser combinados para formar uma nova classe, representando um conceito mais especializado. O C++ suporta herança múltipla, permitindo que uma classe seja derivada de várias classes base. Para tal a definição da classe derivada, terá a seguinte configuração: class <nome da classe > : [public] <nome da classe>,..., [public] <nome da classe > derivada base1 base n Quando se utilizam construtores, como já vimos no caso de herança simples, quando se faz a declaração do construtor da classe derivada, listam-se os construtores das classes base com os valores dos argumentos. Exemplo: A classe derivada D terá como classes base a classe B1, cujo construtor tem um argumento e B2 cujo construtor tem, por exemplo, 2 argumentos. O construtor da classe D tem 2 argumentos. Assim quando se define o construtor da classe derivada aparecerá: D :: D (int x,int y, int z, int w, int t) : B1 (z), B2 (w,t) NOTA: Se uma classe derivada declara com a mesma designção uma função membro pública que uma função membro da classe base da parte pública, então a função da classe derivada esconde a função da classe base, mesmo que tenham argumentos de tipos diferentes (overriding). Vejamos o seguinte: class A int f (int x); Engª Informática do ISEP 14

15 class B : public A public : int f (A y); main() B b; b.f(3); // erro, porque a função f da classe B não admite como argumento um inteiro. Se f não tivesse sido declarada na função derivada o erro não surgiria, aplicaria o método definido na classe base, também acessível à classe derivada Engª Informática do ISEP 15

16 FORMAS DE HERANÇA O mecanismo de herança é usado de diferentes maneiras. Passaremos então a descrever algumas das utilizações mais vulgares, não pretendendo ser exaustivos, mas antes tentando agrupar os objectivos que podem levar à construção de subclasses. Assim temos: Subclasse por Especialização O uso mais vulgar da construção de subclasses é com o objectivo da especialização. A nova classe é uma forma especializada da classe pai, satisfazendo em todos os aspectos relevantes as especificações do pai. Esta é a forma ideal de herança. Exemplo: a classe janela, dispõe de operações gerais de janela como mover, redimensionar,... Uma subclasse especializada janela_de_texto, herda as operações de janela e em adição fornece ainda outras facilidades que permitem por exemplo, fazer o display de texto, editar texto,...mas mantem as propriedades de uma janela em geral. Subclasse por Especificação Outro uso frequente de herança faz-se quando as classes pai e derivadas mantêm um interface comum, isto é apresentam os mesmos métodos. A classe pai é uma combinação de operações implementadas e operações que só serão implementadas nas classes filhos. Muitas vezes não há alteração do interface entre a classe pai e a classe filho, o filho implementa o comportamento descrito, mas não implementado no pai. Nestes casos as subclasses não são refinamentos dos tipo que existe, mas antes realizações de uma especificação abstracta incompleta. Em tais casos a classe pai é conhecida como uma classe abstracta. Subclasses por especificação podem então ser reconhecidas quando, a superclasse não implementa o comportamento actual, mas descreve-o simplesmente e é implementado nas subclasses. Esta forma de subclasses é vulgar em linguagens que fazem uso de funções virtuais. Subclasses por generalização Engª Informática do ISEP 16

17 O uso de herança para fazer subclasses por generalização é de certo modo o oposto à construção de subclasses por especialização. Aqui uma subclasse estende o comportamento da classe pai para criar um objecto mais geral, é muitas vezes aplicável quando estamos a construir a partir de uma base existente que não queremos ou não podemos alterar. Consideremos por exemplo, um sistema de display de gráficos em que a classe janela foi definida para fazer o display com fundo branco e preto. Quando criamos um subtipo, classe_colorida, que permita que o fundo seja de outra cor que não branco e preto, juntamos um campo adicional para guardar a cor e sobrepomos ao código da janela herdada em que o fundo é desenhado nessa cor. Subclasses por generalização ocorrem frequentemente quando o projecto é baseado em dados e coloca para 2º lugar questões de comportamento. Subclasses por extensão Enquanto as subclasses por generalização modificam ou expandem as funcionalidades de um objecto, subclasses por extensão juntam funcionalidades completamente novas. Distingue-se da subclasse por generalização, porque esta sobrepõe pelo menos um método do pai e na extensão a funcionalidade está menos ligada à do pai. No caso de subclasses por extensão, são juntos novos métodos aos do pai e a funcionalidade é menos ligada aos métodos do pai. Exemplo, pretende-se manter os objectos de uma certa classe numa lista. Para fazer isto, podemos construir uma subclasse em que se juntam os campos necessários para construir uma lista ligada. A funcionalidade do pai permanece intocável. Subclasses por Limitação Ocorre este tipo de construção de subclasses, quando o comportamento da subclasse é menor ou mais restritivo do que o comportamento da classe pai. Como acontece com as subclasses por generalização este tipo, por limitação também ocorre quando o programador está a construir uma base de classes a partir de classes existentes que não quer ou não pode alterar. Exemplo: tínhamos uma classe que traduzia uma fila de espera dupla em que os elementos podiam ser juntos ou retirados de cada um dos lados da estrutura. O programador quer representar uma classe pilha, reforçando a Engª Informática do ISEP 17

18 propriedade de que os elementos só podem ser adicionados ou retirados de um dos lados da pilha. Consegue-se esta subclasse a partir da classe inicial, modificando ou sobrepondo métodos e eliminando os que não interessam, de modo a produzirem mensagens de erro se forem aplicados. Subclasses por Combinação Este é o mesmo mecanismo que herança múltipla, portanto a subclasse representa uma combinação de 2 ou mais classes pai. Exemplo, um professor Assistente (nos E.U.A.) tem características representativas das duas seguintes classes: Professor e Aluno. Engª Informática do ISEP 18

19 DIFERENÇA ENTRE COMPOSIÇÃO E HERANÇA Para se compreender estas dois mecanismos de construção de classes, é necessário conhecer e saber aplicar as relações é_um (is_a) e tem_um (has_a). Se escrevermos a frase O X é_um Y, e a frase soar bem, estiver de acordo com a nossa experiência diária, então entre X e Y existirá uma relação é_um, ligada ao mecanismo de herança. Podemos dizer que X pertencerá a uma classe derivada da classe de Y. Se, por outro lado, existir a relação tem_um, isto é se a frase O X tem_um Y, fizer sentido, estamos diante de uma relação tem_um, ligada ao mecanismo da composição ou classes encaixadas, como foi designado anteriormente. Assim neste caso, Y será um dos campos de dados da classe a que pertence X. Vejamos o exemplo de implementação da classe conjunto quer utilizando uma composição com lista, quer derivando-a da classe lista. Composição class lista public : lista(); void junta_lista(int ); int primeiro_elemento(); int comprimento(); int inclui(int); void retira(); class conjunto private: lista dados; conjunto(); void junta(int); int tamanho(); int inclui(int); Engª Informática do ISEP 19

20 conjunto :: conjunto() : dados() } int conjunto :: tamanho() return dados.comprimento(); } int conjunto :: inclui(int valor) return dados.inclui(valor);} void conjunto :: junta (int valor) if(! inclui(valor)) dados.junta_lista(valor); } Herança class conjunto : public lista conjunto(); void junta(int); conjunto :: conjunto() : lista() } void conjunto :: junta( int valor) if(! inclui (valor)) junta_lista(valor); } As duas aproximações que foram feitas para a implementação de conjuntos permitem-nos agora comentar cada uma delas. O mecanismo da composição é o mais simples das duas técnicas e tem como vantagem, a indicação clara das operaçãoes a realizar sobre uma dada estrutura. Olhando para a declaração de conjunto fica claro que as operações Engª Informática do ISEP 20

21 a realizar sobre conjunto são: junta, inclui, tamanho. Estas operações não são tão evidentes no caso de se utilizar o mecanismo de herança, porque as herdadas não são descritas na classe, só na classe pai. Por esta razão as implementações que usam herança são quase sempre, como no caso presente consideravelmente menores em código do que implementações construídas usando composição e às vezes permitem ainda maiores funcionalidades. Por exemplo, no caso presente, a implementação por herança não torna só disponíveis os testes de inclui para conjuntos, mas também a função retira(), Contudo, a herança não evita que utilizadores manipulem a nova estrutura usando métodos da classe pai, mesmo que não sejam apropriados. Na composição, a lista foi usada como mecanismo de armazenagem para o nosso conjunto,é meramente um pormenor de implementação. A aplicação de herança pode abrir a possibilidade de usar a nova abstracção, com uma função polimórfica, o que não é possível com a composição. Conclusão: as duas aproximações têm vantagens e inconvenientes, mas um programador orientado a objectos deve estar familiarizado com as duas formas. Nos primeiros tempos da, foi dado um grande ênfase ao facto de que as técnicas de composição e de herança iriam fornecer um mecanismo para a criação de componentes de software de índole geral. Embora se tenha conseguido um certo progresso, não se avançou tanto quanto as expectativas, havendo um conjunto de razões que tal justificam: Embora seja verdade que a composição e herança fornecem os meios para produzir os componentes de software, não indicam como se fazem e produzir componentes bons e úteis é quase sempre mais difícil do que desenvolver software para resolver a tarefa que no momento temos entre mãos. Além disso, os benefícios do desenvolvimento de bons componentes, reutilizáveis, não se mede num projecto, pode até atrasar o projecto. O custo desse desenvolvimento terá que ser amortizado ao longo de vários projectos. Uma vez que os benefícios não são imediatos, os incentivos para os programadores atingirem este objectivo são pequenos. Como cada novo problema tem comportamento ligeiramente diferente é dificil de projectar componentes que à primeira vez fiquem verdadeiramente uteis e gerais. Só depois de vários projectos é que se poderá atingir uma estabilização de comportamento. Engª Informática do ISEP 21

22 Acho que podemos também afirmar que, como as alterações nas organizações são mais lentas do que as alterações tecnológicas, serão precisos alguns anos até se atingirem os verdadeiros benefícios apregoados pela aproximação orientada a objectos, no entanto, já alguns se conseguiram e por isso será inevitável considerar que a reutilização será a regra para o desenvolvimento futuro de software. Engª Informática do ISEP 22