Programação em C#

Curso: Lic. em Informática

Encapsulamento e Modificadores de
Acesso
Nesse momento, nossa classe Conta possui um numero , saldo e cliente titular , além de
comportamentos que permitem sacar e depositar:

class Conta
{
public int numero;
public double saldo;
public Cliente titular;
public void Saca(double valor) {
this.saldo -= valor;
}
public void Deposita(double valor) {
this.saldo += valor;
}
}
Encapsulamento e Modificadores de
Acesso cont…
Se desejamos efetuar um saque ou um depósito em uma Conta qualquer,
fazemos:
conta.Saca(100.0);
conta.Deposita(250.0);

Mas o que acontece se um membro da equipe faz:

conta.saldo -= 100.0;

Nada nos impede de acessar os atributos diretamente. Em três partes distintas

no nosso software temos tal código:
// em um arquivo
conta.saldo -= 100.0;
// em outro arquivo
conta.saldo -= 250.0;
// em outro arquivo

conta.saldo -= 371.0;
Encapsulamento e Modificadores de
Acesso cont…
Agora imagine que o banco mude a regra de saque: agora a cada saque
realizado, o banco cobrará 0.10 centavos. Ou seja, se o usuário sacar 10.0
MZN, é necessário tirar de sua conta 10.10 MZN. Temos que alterar todos os
pontos de nossa aplicação que acessam esse atributo!
O que aconteceria ao usarmos o método Saca() :
// em um arquivo
conta.Saca(100.0);
// em outro arquivo
conta.Saca(250.0);
// em outro arquivo
conta.Saca(371.0);
Como refletiríamos a alteração na regra do saque de tirar 10 centavos?
Precisamos alterar apenas uma vez o método Saca() , ao invés de alterar todas
as linhas que acessam o atributo diretamente!
Encapsulamento e Modificadores de
Acesso cont…
Na orientação a objetos, esconder os detalhes de implementação de uma
classe é um conceito conhecido como encapsulamento. Como os detalhes de
implementação da classe estão escondidos, todo o acesso deve ser feito
através de seus métodos públicos. Não permitimos aos outros saber COMO a
classe faz o trabalho dela, mostrando apenas O QUÊ ela faz.

Mas ainda não resolvemos o problema de evitar que programadores façam

uso diretamente do atributo. Qualquer um ainda pode executar o código
abaixo:

conta.saldo -= 371.0;
Encapsulamento e Modificadores de
Acesso cont…
Para isso, precisamos esconder o atributo. Queremos deixá-lo privado para
que somente a própria classe Conta possa utilizá-lo. Nesse caso queremos
modificar o acesso ao atributo para que ele seja privado, private:

class Conta
{
// outros atributos aqui
.
private double saldo;
public void Saca(double valor) {
this.saldo -= valor;
}
public void Deposita(double valor) {
this.saldo += valor;
}

}
Encapsulamento e Modificadores de
Acesso cont…
Atributos e métodos private são acessados apenas pela própria classe. Ou seja, o método Saca() ,
por exemplo, consegue fazer alterações nele. Mas outras classes não conseguem acessá-lo
diretamente! O compilador não permite!

Os atributos de uma classe são detalhes de implementação, portanto marcaremos todos

os atributos da conta com a palavra private:

class Conta
{
private int numero;
private double saldo;
private Cliente titular;
public void Saca(double valor) {
this.saldo -= valor;
}
public void Deposita(double valor) {
this.saldo += valor;
}
}
Encapsulamento e Modificadores de
Acesso cont…
Mas agora temos outro problema. Se quisermos exibir o saldo não conseguiremos. O private bloqueia
tanto a escrita, quanto a leitura!
Para resolver esse problema, o C# nos oferece as properties (propriedades). A declaração de uma
propriedade é parecida com a declaração de um atributo, porém precisamos falar o que deve ser feito
na leitura ( get ) e na escrita ( set ) da propriedade
class Conta
{
private int numero;
public int Numero
{
get
{
// código para ler a propriedade
}
set
{
// código para escrever na propriedade
}

}}
Encapsulamento e Modificadores de
Acesso cont…
Na leitura da propriedade, queremos devolver o valor do atributo numero da Conta :
class Conta
{
private int numero;
public int Numero
{
get
{
return this.numero;
}

}
}
Com isso, podemos ler a propriedade Numero com o seguinte código:

Conta c = new Conta();

MessageBox.Show("numero: " + c.Numero);
Encapsulamento e Modificadores de
Acesso cont…
Para facilitar a declaração das properties, a partir do C# 3.0, temos as
propriedades que são implementadas automaticamente pelo compilador, as
auto-implemented properties. Para declararmos uma auto-implemented
property para expor o número da conta, utilizamos o seguinte código:

class Conta
{
public int Numero { get; set; }

}
Esse código faz com que o compilador declare um atributo do tipo int (cujo
nome só é conhecido pelo compilador) e gere o código para a propriedade
Numero com um get e um set que leem e escrevem no atributo declarado. Repare
que ao utilizarmos as auto-implemented properties, só podemos acessar o
valor do atributo declarado através da propriedade.
Exercícios
1. Transforme os atributos da classe Conta em propriedades. Permita que o
saldo da conta seja lido, porém não seja alterado fora da classe, altere
também o código das classes que utilizam a conta para que elas acessem
as propriedades ao invés dos atributos diretamente.