Universidade Federal de Mato Grosso do Sul. Propriedades da Programação Orientada a Objetos

Transcrição

1 Universidade Federal de Mato Grosso do Sul Facom - Faculdade de Computação Linguagem de Programação Orientada a Objetos Prof. Me. Liana Duenha Propriedades da Programação Orientada a Objetos Neste tópico da disciplina, abordaremos as principais propriedades da programação orientada a objetos. Esse material é baseado nas notas de aula dos professores Paulo Pagliosa e Anderson Bessa, e livro texto How To Program (Deitel). 1 Encapsulamento Encapsular significa esconder, na definição da classe, os membros que representam a estrutura e o comportamento interno dos objetos da classe. Geralmente, são escondidos todos os atributos, enquanto os métodos são tornados públicos. Entretanto, podese esconder também os métodos, bem como tornar públicos alguns atributos; tudo depende das suas decisões de projeto e do bom senso. Esconder um membro em C++ significa declará-lo na seção privada (definida pela palavra reservada private) ou protegida (definida por protected) da classe. Um membro privado só pode ser acessado em métodos da classe onde foi declarado. Um membro protegido pode ser acessado por métodos da própria classe e de classes derivadas publicamente, direta ou indiretamente, da classe onde foi declarado. Membros declarados na seção pública (definida pela palavra reservada public) da classe, podem ser acessados por quaisquer métodos e definem a interface da classe. O acesso a um atributo privado ou protegido só pode ser efetuado de forma indireta, por meio de métodos declarados na classe chamados setters e getters. Um setter é utilizado para atribuição de um novo valor para um atributo, enquanto um getter é utilizado para obtenção do valor corrente do atributo. Um atributo para o qual há um getter e/ou um setter é uma propriedade do objeto. Embora aconselhável esconder um atributo, seu acesso por getters ou setters, além em do acréscimo de métodos na interface da classe, pode adicionar ineficiência a um programa. Em C++, tal ineficiência é evitada com o uso de métodos inline. Em uma mensagem na qual um método inline é acoplado, não há o overhead de uma chamada de função; ao invés disso, o corpo do méetodo é expandido em linha no local da mensagem. Com isso, o código gerado fica maior, dependendo do tamanho do corpo do método, como visto anteriormente. Como exemplo, podemos utilizar a classe DoubleList modelada em sala de aula. Um objeto desta classe possui um atributo chamado numberofnodes. Esse atributo 1

2 não pode ser acessado ou modificado diretamente por métodos ou funções que não sejam da classe DoubleList. Contudo, é útil para o usuário saber o valor desse atributo; sendo assim, podemos definir um método público getter que retorna uma cópia do valor desse atributo para o usuário, da seguinte maneira: template <typename T> inline int DoubleList<T>::size() const return numberofnodes; Métodos setter normalmente servem para validar os valores antes de aplicar modificações em atributos do objeto. Por exemplo, antes da atribuição de um valor arbitrário ao campo info do objeto, podemos usar um método setter e uma função de validação (no exemplo, isvalid) para evitar erros: template <typename T> inline int DoubleNode<T>::setInfo(T value) if (isvalid(value)) info = value; As vantagens do encapsulamento são: Melhor organização do código. Segurança: atributos encapsulados não podem ter seus valores inadvertida ou maliciosamente modificados por métodos que não têm acesso aos atributos. Manutenibilidade: alterações na estrutura de dados e em métodos encapsulados de uma classe não são refletidas nos métodos de outros objetos usuários da classe (a não ser que essas alterações modifiquem a interface da classe). Há situações em que certos membros privados ou protegidos de objetos de uma classe A devem ser acessados não por métodos quaisquer, mas somente por métodos acoplados a mensagens cujos receptores são objetos de uma classe B. Casos assim podem ocorrer quando há um relacionamento forte entre objetos das classes A e B. Nestas circunstâncias, a classe A pode declarar que a classe B é sua amiga, o que significa que métodos executados por objetos de B podem acessar membros protegidos ou privados de objetos de A. 2

3 Um método friend de uma classe é definido fora do escopo dessa classe, ainda que tenha o direito de acessar membros não-public (e public) da classe. Funções independentes ou classe inteiras podem ser declaradas como friends de outras classes. Para declarar um método method ou função como friend de uma classe, preceda o protótipo de função na definição de classe com a palavra-chave friend. class Class1 friend void method(); private: Para declarar todas as funções-membro da classe Class2 como amigas da classe Class1, inclua na definição da classe Class1 uma declaração na forma class Class1 friend class Class2; private: É considerada uma boa prática de programação que as classes friend sejam declaradas logo no início do corpo de definição de uma classe, sem a necessidade de precedê-las com especificadores de acesso (public, private,etc). 2 Herança Herança é o mecanismo através do qual um objeto de uma classe Y herda todos os membros de uma classe X. A classe X e chamada superclasse (ou classe base, em C++) e a classe Y é chamada subclasse (ou em C++). Uma classe base representa uma generalização; uma representa uma especialização. C++ admite herança múltipla, isto é, uma classe pode ser derivada de duas ou mais classes-base. Há várias maneiras de uma especializar uma classe base: 3

4 Adicionando novos métodos e/ou atributos; Redefinindo a implementação de métodos da classe base; Não fazendo nada. O grande benefício da herança é a reutilização de código, o que evita a replicação e pode, mas nem sempre, facilitar a manutenção, desde que alterações ou extensões sejam feitas somente em nas classes bases. Como exemplo, considere a classe Employee definida abaixo. Essa classe representa um funcionário de uma empresa e possui os atributos firstname, lastname e cpf. Além dos métodos públicos getters e setters, essa classe possui um método de impressão dos atributos ou propriedades dos objetos desta classe (método print()). class Employee Employee(const string &first, const string &last, const string &cpf) setfirstname(first); setlastname(last); setcpf(cpf); ; ~Employee(); void setfirstname(const string &); string getfirstname() const; void setlastname(const string &); string getlastname() const; void setcpf(const string &); string getcpf() const; void print() const; private: string firstname; //nome string lastname; // sobrenome string cpf; // cpf A classe CommissionEmployee é definida abaixo como de Employee, e assim, uma instância da classe CommissionEmployee é um objeto Employee e herda todos os seus membros não privados. 4

5 class CommissionEmployee : public Employee CommissionEmployee (const string &first, const string &last, const string &c, do :Employee(first,last,c) setgrosssales( sales ); setcommissionrate( rate ); ~CommissionEmployee(); void setgrosssales( double ); double getgrosssales() const; void setcommissionrate( double ); double getcommissionrate() const; double earnings() const; void print() const; private: double grosssales; // vendas brutas semanais double commissionrate; // porcentagem da comiss~ao ; // fim da classe CommissionEmployee O construtor de CommissionEmployee recebe todos argumentos necessários para inicilialização dos seus atributos (próprios e herdados), invoca explicitamente o construtor de Employee passando os parãmetros corretos para inicialização de firstname, lastname e cpf, e finaliza como a inicialização dos atributos grosssales e commissionrate. O método earnings() é responsável por calcular os rendimentos semanais do funcionário comissionado, levando em consideração o valor de vendas brutas (grosssales) e taxa de comissão (comissionrate). Segue abaixo um exemplo de instanciação e utilização de objetos da classe CommissionEmployee e Employee: // Instancia um objeto Employee Employee emp ("Joao", "da Silva", " "); // Instancia um objeto CommissionEmployee CommissionEmployee comemp ("Camila", "Miranda", " ", 10000, 0.06); Employee *empptr = &emp; // empptr aponta para objeto Employee Employee *comempptr = &emp; // comempptr aponta para objeto comempptr que // também é um Employee 5

6 emp.print(); // método print() da classe Employee será executado comemp.print(); // método print() da classe CommissionEmployee será executado 2.1 Tipos de Herança Ao derivar uma classe de uma classe base, os membros da classe base podem ser herdados pela herança public, private ou protected. O tipo de herança define a acessibilidade de membros da classe base pela. O mais comum é o uso de herança public, já exemplificada nesse material. Os tipos de herança private e protected são usados raramente e deve ser implementados com critério. A tabela 2.1 resume as regras de acessibilidade de membros da classe base pela, considerando diferentes tipos de herança. Especificador de Herança public acesso de membro da classe base public public na classe derivada protected protected na private private na Herança protected protected na protected na private na Herança private private na private na private na Tabela 1: Tipos de herança e acessibilidade de membros 3 Polimorfismo Polimorfismo descreve a capacidade de um código de programação comportar-se de diversas formas dependendo do contexto. Uma das formas mais simples de polimorfismo é permiteir que operadores ou métodos com o mesmo nome implementem várias operações distintas ou a mesma operação sobre dados de tipos distintos. Em C++, por exemplo, o operador + é usado para adição de dois inteiros, de dois reais, de um real e um inteiro, etc. Em Java, o operador também é usado para concatenação de strings. Esse tipo simples de polimorfismo é baseado em sobrecarga. Em C++, é possível a sobrecarga de operadores, ou seja, a definição de funções cujo nome simples é dado pela palavra reservada operator seguida do símbolo do operador (os argumentos da função devem ser compatíveis com o número e tipo de argumentos exigidos pelo operador), conforme visto anteriormente. Assim, pode-se escrever, para uma classe X qualquer: 6

7 X operator +(const X&, const X&); Com isso, o operador + passa a ser usado também para a adição de dois objetos da classe X: X x1; X x2; X x3; x3 = x1 + x2; // ou x3 = operator +(x1, x2); No caso de polimorfismo envolvendo funções que não sejam operadores, podemse ter funções ou métodos com o mesmo identificador, mas que são diferenciados pelo número e/ou tipo dos parâmetros. Considere o exemplo abaixo. Na classe A, há quatro versões do método f(), porém o compilador pode distingui-las pelo número e tipo dos parâmetros e/ou tipos de retorno. class A int a; int f(); void f(int); void f(int, float); int f(float, int); ; Nesse exemplo, os métodos acoplados às respectivas mensagens são determinado em tempo de compilação em função do número e/ou tipo da mensagem. Quando o acoplamento mensagem/método é resolvido em tempo de compilação, é chamado acoplamento estático, vinculação estática ou jução anterior. 4 Vinculação/Acoplamento estático x dinâmico Em C++, para mensagens enviadas a objetos criados estaticamente, o acoplamento sempre será estático. Considere novamente os exemplos utilizando as classes Employee e ComissionEmployee. Os métodos print() foram executados em resposta à mensagem enviada a um objeto criado estaticamente. Isto quer dizer que o compilador 7

8 decide qual método deve ser executado em resposta à invocação realizada baseado no tipo do objeto. Embora o método print() tenha sido definido tanto em Employee quanto em CommisionEmployee, emp.print() acarretará a execução do método print definido na classe Employee e comemp.print() acarretará a execução do método print definido na classe CommissionEmployee. O mesmo não ocorre quando uma mensagem é enviada a um objeto através de um ponteiro (ou referência). Em C++, um ponteiro (ou referência) para uma classe base pode receber o endereço (referência) de um objeto desta classe ou de qualquer classe que dela deriva, direta ou indiretamente. Assim, no código abaixo, pode-se perguntar qual método será acoplado à mensagem, uma vez que o ponteiro ptr pode receber o endereço de um objeto da classe Employee, da classe CommissionEmployee ou de qualquer outra que derive de Employee. Nesse exemplo, como o ponteiro ptr foi definido como um ponteiro para objetos da classe Employee, o método print() de Employee será executado, mesmo que o objeto para o qual ptr aponta seja um objeto CommissionEmployee. CommissionEmployee comemp ("Camila", "Miranda", " ", 10000, 0.06); Employee *ptr = &comemp; // ptr aponta para objeto Employee ptr -> print(); // método print() da classe Employee será executado Na maioria das vezes em que usamos ponteiros para manipular objetos, desejamos que a escolha do método a ser executado seja realizada em tempo de execução (e não em tempo de compilação). Isso é chamado acoplamento dinâmico, vinculação dinâmica ou junção posterior. Para determinar que a vinculação seja dinâmica, devemos definir os métodos Employee::print() e CommissionEmployee::print() como métodos virtual. Se o método for virtual, então o método a ser acoplado a mensagem será aquele da classe do objeto cujo endereço, em tempo de execução, for atribuído ao ponteiro ptr. Em uma, a redefinição de um método não virtual herdado de uma classe base esconde o método da classe base. A redefinição de um método virtual em uma sobrepõe o método da base. Note a diferença: métodos com o mesmo nome mas parâmetros diferentes declarados na mesma classe são métodos sobrecarregados, enquanto que métodos declarados em uma com o mesmo nome, mesmos parâmetros e mesmo tipo de retorno de méetodos herdados de uma classe base sã métodos redefinidos. Um método redefinido sobrepõe ou esconde o método da base. Métodos definidos como virtual permitem acoplamento dinâamico. Acoplamento dinâmico tem um custo em termos de eficiência. Em C++, a jução posterior é implementada através de tabelas de ponteiros de métodos virtuais. Toda classe que tiver declarado pelo menos um método virtual terá associada uma tabela cujas entradas serao os endereços do código de cada um dos métodos virtuais 8

9 declarados na classe. Todo método virtual possui como atributo um índice para a entrada correspondente na tabela de ponteiros de métodos virtuais (TPMV) de sua classe. A TPMV de uma copia a TPMV da classe base, ajustando as entradas para apontar para aqueles métodos que foram sobrepostos e adicionando novas entradas se novos métodos virtuais forem declarados na. Um método abstrato ou virtual puro é um método virtual que não será implementado na classe onde foi definido. Um método que tenha =0 no final da sua declaração na classe é um método virtual puro. Uma classe que declare pelo menos um método virtual puro é uma classe abstrata. Uma classe abstrata não admite instância. Uma de uma classe base abstrata não será abstrata se sobrecarregar os métodos abstratos herdados da base (e não declarar novos métodos abstratos). Vamos modificar o nosso exemplo de tal forma a tornar a classe Employee uma classe abstrata. Vamos declarar o método earnings() como virtual puro na clase base (Employee), e sobrecarregá-lo na (CommissionEmployee). O método print() de Employee não será declarado como virtual puro na classe base pois desejamos manter sua implementação, mas será declarado como virtual para garantir sua vinculação em tempo de execução. // classe abstrata pois contém um método virtual puro class Employee virtual double earnings() const = 0; // virtual puro virtual void print() const; // virtual ; class CommissionEmployee : public Employee virtual double earnings() const; // virtual virtal void print() const; // virtual ; 9