5 Encapsulamento

12/04/2019
Introdução
▪ Abstração
▪ Simplificação de um problema difícil
Programação e Desenvolvimento de Software 2 ▪ É o ato de representar as características
Programação Orientada a Objetos (Encapsulamento) essenciais sem incluir os detalhes por trás
Prof. Douglas G. Macharet
douglas.macharet@dcc.ufmg.br ▪ Ocultação de dados
▪ Informações desnecessárias devem ser
escondidas do mundo externo
▪ Usuário do TAD x Programador do TAD
PDS 2 - Programação Orientada a Objetos (Encapsulamento) 2
Introdução Introdução
▪ Encapsulamento
▪ Mecanismo que coloca juntos os dados e suas
funções associadas, mantendo-os controlados
em relação ao seu nível de acesso
▪ Proporciona abstração
▪ Separa a visão externa da visão interna
▪ Protege a integridade dos dados do Objeto
PDS 2 - Programação Orientada a Objetos (Encapsulamento) 3 PDS 2 - Programação Orientada a Objetos (Encapsulamento) 4
Introdução Introdução
▪ Escopo de uma variável class ClasseTeste { ▪ Quais escopos?

▪ Classe, Método, If
▪ Região de um programa dentro da qual uma public:
int var1;
variável pode ser referenciada pelo seu nome std::string var2; ▪ O que acontece quando:
▪ Entra/sai do if?
▪ Relação com a memória?
void metodo(int param) {
int x = 1;
int y = 9; ▪ result entra/sai da pilha
▪ O escopo define quando o sistema aloca e if (param % 2 == 0) { ▪ O método termina?
libera memória para armazenar uma variável }
int result = 12;
▪ param,x e y saem da pilha
▪ Variáveis alocadas no heap continuam lá mesmo } ▪ A classe é destruída?
fora do escopo (se não forem desalocadas) }; ▪ var1 e var2 saem da pilha
1
12/04/2019
Encapsulamento Encapsulamento
▪ Encapsulamento ocorre nas classes ▪ Informações encapsuladas em uma Classe

▪ O comportamento e a interface de uma ▪ Estado (dados)
classe são definidos pelos seus membros ▪ Comportamento (métodos)
▪ Atributos
▪ Métodos
Mensagens Método
▪ Fazem uso dos modificadores de acesso Método Dados
Método
Benefícios C++
▪ Desenvolvimento ▪ Modificadores de acesso

▪ Melhor compreensão de cada classe ▪ Public
▪ Facilita a realização de testes ▪ Protected
▪ Manutenção/Evolução ▪ Private
▪ Impacto reduzido ao modificar uma classe ▪ Membros declarados após o modificador
▪ Interface deve ser o mais constante possível ▪ Checagem em tempo de compilação
https://en.cppreference.com/w/cpp/language/access
Modificadores de acesso Modificadores de acesso – Public
▪ Permite que os membros públicos sejam

public acessados de qualquer outra parte do código
protected
▪ Mais liberal dos modificadores
private
▪ Fazem parte (definem) o contrato da classe
▪ Deve ser usado com responsabilidade
▪ Não é recomendado
▪ Por que?
2
12/04/2019
Modificadores de acesso – Public Modificadores de acesso – Protected
▪ Permite que os membros possam ser

class Ponto { acessados apenas por outras classes que
public: ▪ Fazem parte da hierarquia (derivadas)
int x;
▪ Classes “amigas”
Membros públicos.
int y;
Ponto(int x, int y) { ▪ Algo bem específico em C++

this->x = x;
this->y = y;
}
};
Modificadores de acesso – Protected Modificadores de acesso – Private
▪ Permite que os membros privados sejam

class Base { acessados por métodos da mesma classe
protected:
▪ O mais restritivo dos modificadores
int i = 99; int main() {
}; Base b;
Erro!
cout << b.i << endl;
class Derived : public Base {
▪ Deve ser empregado sempre que possível
▪ Utilizar métodos auxiliares de acesso
public: Derived d;
int f() { cout << d.f() << endl;
i++;
return i; return 0; ▪ Quando não há declaração explícita
}
};
}
▪ Nível padrão (implícito)
https://wandbox.org/permlink/I91umA4d5fxhaxbb ▪ Structs → Padrão é público
Modificadores de acesso – Private Modificadores de acesso – Private (Exemplo 1)
class Ponto { class Base {

int i = 99; int main() {
private: }; Base b;
int _x; cout << b.i << endl;
class Derived : public Base {
int _y;
public: Derived d;
int f() { cout << d.f() << endl;
public: i++;
Ponto(int x, int y) : _x(x), _y(y) {} return i; return 0;
} }
}; };
3
12/04/2019
Modificadores de acesso – Private (Exemplo 2) Modificadores de acesso – Private (Exemplo 3)
class Ponto {
private:
class Ponto { class EstruturaPonto {
public:
double x;
private: double y;
int _x; };
int _y;
EstruturaPonto p;
Ponto(int x, int y) : _x(x), _y(y) {}
public:
Ponto(int x, int y) {
}; p.x = x;
p.y = y;
}
};
Modificadores de acesso Modificadores de acesso
▪ Considere a visibilidade dos membros da Alpha de

acordo com o modificador de acesso
Módulo A Módulo B
Alpha AlphaSub Classe Subclasse Mundo

Public
Beta Gamma Protected
Private
Alpha AlphaSub Beta Gamma
Public
Protected
Private
Acessando e modificando atributos Getters e Setters
▪ Evitar a manipulação direta de atributos ▪ Convenção de nomenclatura dos métodos

▪ Acesso deve ser o mais restrito possível ▪ Get
▪ De preferência todos devem ser private ▪ Os métodos que permitem apenas o acesso de
▪ Sempre utilizar métodos auxiliares consulta (obter) devem possuir o prefixo get
▪ Melhor controle das alterações ▪ Set
▪ Acesso centralizado ▪ Os métodos que possibilitam a alteração
(definir) devem possuir o prefixo set
4
12/04/2019
Getters e Setters Getters e Setters
▪ Todos os atributos devem possuir get e set

class Ponto {
private: ▪ Nomenclatura alternativa
double _x;
double _y; ▪ Atributos booleanos devem utilizar o prefixo
public: “is” ao invés do prefixo get
Ponto(double x, double y) : _x(x), _y(y) {}
▪ Melhora a legibilidade e entendimento
void setX(double x) { this->_x = x; }
void setY(double y) { this->_y = y; }
▪ E uma coleção, possui ‘setColecao’?
double getX() { return this->_x; }
double getY() { return this->_y; } ▪ Não!
▪ Métodos auxiliares: adicionar, remover, …
};
Encapsulamento Exercício
Getters e Setters
▪ Modelar uma conta bancária

▪ Quais atributos devem existir?
class Cliente {
private:
string _nome;
bool _ativo; ▪ Quais métodos devem existir?
public:
Cliente(string nome, bool ativo) : _nome(nome), _ativo(ativo) {}
void setNome(string nome) { this->_nome = nome; }

void setAtivo(bool ativo) { this->_ativo = ativo; }
string getNome() { return this->_nome; }

bool isAtivo() { return this->_ativo; }
};
Exercício Exercício
class Conta {
private:
int _agencia;
class Conta { int _numero;
double _saldo = 0;
public:
int agencia; public:
int numero;
double saldo; Conta(int agencia, int numero) : _agencia(agencia), _numero(numero){}
void setAgencia(int ag) { this->_agencia = ag; }

Conta(int agencia, int numero) : agencia(agencia), numero(numero){} void setNumero(int num) { this->_numero = num; }
void setSaldo(double saldo) { this->_saldo = saldo; }
};
int getAgencia() { return this->_agencia; }
int getNumero() { return this->_numero; }
double getSaldo() { return this->_saldo; }
};
5
12/04/2019
class Conta { class Conta {
private: {...}
int _agencia;
int _numero; public:
double _saldo = 0;
{...}
public:
void depositar(double valor) {
{...} this->_saldo += valor;
this->_saldo -= 0.25;
void depositar(double valor) { }
this->_saldo += valor;
} void sacar(double valor) {
this->_saldo -= valor;
void sacar(double valor) { this->_saldo -= 0.25;
this->_saldo -= valor; }
} };
};
{...} private:
{...}
public:
void _descontarTarifa() {
{...} this->_saldo -= 0.25;
}
this->_saldo += valor; public:
descontarTarifa(); {...}
}
void sacar(double valor) { this->_saldo += valor;
this->_saldo -= valor; descontarTarifa();
descontarTarifa(); }
}
void sacar(double valor) {
void descontarTarifa() { this->_saldo -= valor;
this->_saldo -= 0.25; descontarTarifa();
} }
}; };
private: private:
{...} {...}
double const _TARIFA = 0.25; static double constexpr _TARIFA = 0.25;
void _descontarTarifa() { void _descontarTarifa() {

this->_saldo -= TARIFA ; this->_saldo -= TARIFA ;
} }
public: public:
{...} {...}
}; };
https://wandbox.org/permlink/gMs86x8taTO0CLJj
https://en.cppreference.com/w/cpp/language/constexpr

5 Encapsulamento

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

5 Encapsulamento

Enviado por

Direitos autorais:

Formatos disponíveis

12/04/2019

PDS 2 - Programação Orientada a Objetos (Encapsulamento) 2

▪ Escopo de uma variável class ClasseTeste { ▪ Quais escopos?

▪ Encapsulamento ocorre nas classes ▪ Informações encapsuladas em uma Classe

▪ Desenvolvimento ▪ Modificadores de acesso

▪ Permite que os membros públicos sejam

▪ Permite que os membros possam ser

Ponto(int x, int y) { ▪ Algo bem específico em C++

▪ Permite que os membros privados sejam

class Ponto { class Base {

▪ Considere a visibilidade dos membros da Alpha de

Alpha AlphaSub Classe Subclasse Mundo

▪ Evitar a manipulação direta de atributos ▪ Convenção de nomenclatura dos métodos

▪ Todos os atributos devem possuir get e set

▪ Modelar uma conta bancária

void setNome(string nome) { this->_nome = nome; }

string getNome() { return this->_nome; }

void setAgencia(int ag) { this->_agencia = ag; }

class Conta { class Conta {

double const _TARIFA = 0.25; static double constexpr _TARIFA = 0.25;

void _descontarTarifa() { void _descontarTarifa() {

Você também pode gostar