O encapsulamento é um dos três principaisrecursos de programação orientada a objetos (OOP). Os outros dois são polimorfismo e herança. Juntos, eles constituem uma estrutura OOP que define uma gama de possibilidades para escrever programas em diferentes linguagens usando esses três princípios. Linguagens orientadas a objetos, por sua vez, são obrigadas a segui-los claramente.
OOP básico
A programação orientada a objetos é baseada em três pilares de seu universo:
- Polimorfismo, que responde à questão de como uma determinada linguagem de programação trata objetos que estão relacionados entre si de maneira semelhante.
- Herança, que fornece uma resposta sobre como a reutilização de código é estimulada.
- Encapsulamento, que é a resposta à questão de como a implementação é oculta e, portanto, a integridade dos dados é preservada.
Terminologia
Encapsulamento (programação) éo uso de modificadores de acesso para ocultar partes do código do programa do usuário final. Por sua vez, significa o desenvolvedor ou o objeto herdado.
A essência do conceito de "encapsulamento"
Definição define o que está sob encapsulamentoocultar todo ou parte do código do programa está implícito. A essência do conceito de "encapsulamento" é a manipulação de modificadores de acesso. Isso significa que o próprio desenvolvedor decide quais propriedades, métodos e classes serão expostos à classe do cliente e quais serão ocultados.
Modificadores de acesso
- public ("public" - public, open, access) - acesso público para objetos e classes atuais e para o mundo exterior;
- privado ("privado" - acesso privado, privado, oculto) - acesso fechado, cuja essência é completamente oposta à anterior. Fornece acesso apenas da classe atual;
- protegido ("protegido" - protegido, semi-oculto, acesso) - acesso para a classe atual e seus derivados;
- default - modificador de acesso não especificado implica que o campo / método é visível para todo o pacote de classe atual.
Na linguagem C # ("C Sharp"), além dos indicados (excluindo o último), também existem os seguintes modificadores:
- interno ("interno" - acesso interno) - disponibilidade geral na coleção atual, acesso fechado em todos os outros casos;
- protegido interno ("protegido interno" - acesso protegido interno) - a combinação de dois modificadores em um, no qual as propriedades de ambos são manifestadas.
O papel do encapsulamento
O mecanismo de encapsulamento permite excluir a influência externa no código do programa e o uso incorreto dos dados nele contidos. Ele faz isso combinando código e dados em um único todo.
Objeto e encapsulamento
Combinando a implementação do módulo de software eos dados embutidos no código são chamados de objeto na programação. A essência da sua ligação com o encapsulamento reside no facto de ser precisamente esta técnica que permite manter e garantir o funcionamento integral do mecanismo em consideração.
A vantagem do encapsulamento
O encapsulamento é uma forma de simplificar o processo de codificação. Numerosas linhas de código permanecem "nos bastidores" e, na classe principal, o trabalho é feito com instâncias de objeto.
A ideia de proteção de dados
O encapsulamento também é um mecanismo queimplementa a ideia de proteção de dados. A lógica de programação da programação orientada a objetos é baseada no fato de que a maioria dos dados serão ocultados pelo modificador de acesso privado (privado) ou protegido (protegido). O mundo externo, o cliente, acidentalmente ou intencionalmente, não pode prejudicar a implementação do módulo de software. Como é realmente muito fácil fazer isso, mesmo que não seja propositalmente, o encapsulamento é um princípio muito bom.
Unidades de encapsulamento
Classe, como unidade principal de encapsulamento,descreve os dados e contém um código que pode operar com esses dados. É também a base para a construção do objeto. Este, por sua vez, é representado como uma instância da classe.
- membros são o código e os dados que vão para a classe;
- campos ou variáveis de instância - este é o nome dos dados que a classe define;
- funções de membro - eles contêm o próprio código. Funções de membro são um nome comum. Os métodos são um caso especial.
Encapsulamento com um exemplo específico
Exemplo de encapsulamento (programação):
* Observação:
descrição é a descrição de um método / propriedade / variável, ou seja, comenta o que realmente acontece no programa. Demonstrado com tags de abrir / fechar
using System;
namespace OOPLibrary.Auto
{
///
/// Esta classe tem como objetivo descrever as propriedades e ações do carro
///
public class Auto
{
///
/// Uma variável criada para escrever nela a idade do carro, já que o desenvolvedor considera a interferência externa nesta propriedade supérflua
/// é marcado com o modificador privado, ou seja, fechado, acesso privado (veja a descrição acima).
///
private int _age;
///
/// Variável booleana (apenas dois valores possíveis - sim ou não) que descreve se o carro está em movimento
/// Também não deve ser aberto ao usuário final, seja ele quem for. É por isso que o modificador de acesso privado "privado" é atribuído a esta variável.
///
private bool _isMoving;
///
/// Esta variável de string deve conter informações sobre a cor do carro. Pode estar sujeito a mudanças de influências externas
/// portanto, o modificador de acesso aberto "público" é selecionado para a cor.
///
public string Color;
///
/// Neste caso particular, assumimos que o nome do carro também pode ser alterado
/// o modificador público é atribuído (acesso aberto a todos, independentemente da classe ou montagem).
///
public string Name;
///
/// O construtor da classe é aberto e todas as propriedades expressas por variáveis e definidas um pouco antes recebem seus valores
///
public Auto ()
{
_age = 5;
_isMoving = false;
Cor = "Roxo";
Nome = "Skoda Octavia";
}
///
/// O método implementa o retorno do valor da idade do carro. Por que isso é necessário?
/// um modificador de acesso privado evita que ele seja modificado pelo cliente.
///
/// Retorna a idade do carro.
public string GetAge ()
{
return "A máquina atualmente selecionada" + _age + "tem anos.";
}
///
/// Se o carro não está se movendo, este métodoimplementa o início do movimento. É feita uma verificação em uma variável que indica o estado do carro (se está dirigindo ou não) e, dependendo dos resultados, uma ação apropriada é executada / uma mensagem correspondente é exibida.
///
public void Start ()
{
if (_isMoving)
{
Console.WriteLine ("O movimento já começou");
}
senão
{
_isMoving = true;
Console.WriteLine ("Pronto, atenção .. Vamos! Vamos!");
}
}
///
/// Se o movimento foi iniciado, este método o interrompe. A mesma lógica de programa do caso considerado anterior.
///
public void Stop ()
{
if (_isMoving)
{
_isMoving = false;
Console.WriteLine ("Pare, carro");
}
senão
{
Console.WriteLine ("Erro. O carro já está parado, sem movimento");
}
}
///
/// Vira para a esquerda se o veículo estiver em movimento
///
public void MoveLeft ()
{
if (_isMoving)
{
Console.WriteLine ("Virou à esquerda");
}
senão
{
Console.WriteLine ("Erro. O carro está parado. A função de virar não está disponível no momento");
}
}
///
/// Um método semelhante com virar para a direita
///
public void MoveRight ()
{
if (_isMoving)
{
Console.WriteLine ("Virada à direita com sucesso");
}
senão
{
Console.WriteLine ("Erro. O carro ainda não se moveu. Virar para a direita é atualmente uma ação que não pode ser executada.");
}
}
}
}
