Encapsulamento (programação de computador)

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

Na programação orientada a objetos (OOP), o encapsulamento refere-se ao agrupamento de dados com os métodos que operam nesses dados ou à restrição de acesso direto a alguns dos componentes de um objeto. [1] O encapsulamento é usado para ocultar os valores ou o estado de um objeto de dados estruturados dentro de uma classe , impedindo o acesso direto a eles pelos clientes de uma forma que poderia expor detalhes de implementação ocultos ou violar a invariância de estado mantida pelos métodos.

Esse mecanismo não é exclusivo da OOP. Implementações de tipos de dados abstratos , por exemplo, módulos , oferecem uma forma semelhante de encapsulamento. A semelhança foi explicada pelos teóricos da linguagem de programação em termos de tipos existenciais . [2]

Significado

Em linguagens de programação orientadas a objetos e outros campos relacionados, encapsulamento refere-se a uma de duas noções relacionadas, mas distintas, e às vezes à combinação delas: [3] [4]

  • Um mecanismo de linguagem para restringir o acesso direto a alguns dos componentes do objeto . [5] [6]
  • Uma construção de linguagem que facilita o agrupamento de dados com os métodos (ou outras funções) que operam nesses dados. [1] [7]

Alguns pesquisadores e acadêmicos de linguagem de programação usam o primeiro significado sozinho ou em combinação com o segundo como uma característica distintiva da programação orientada a objetos , enquanto algumas linguagens de programação que fornecem fechamentos lexicais veem o encapsulamento como um recurso da linguagem ortogonal à orientação a objetos.

A segunda definição é motivada pelo fato de que em muitas linguagens orientadas a objetos e outros campos relacionados, os componentes não são ocultados automaticamente e isso pode ser substituído; assim, a ocultação de informações é definida como uma noção separada por aqueles que preferem a segunda definição.

Os recursos de encapsulamento são suportados usando classes na maioria das linguagens orientadas a objetos, embora também existam outras alternativas.

Encapsulamento e herança

Os autores de Design Patterns discutem detalhadamente a tensão entre herança e encapsulamento e afirmam que, em sua experiência, os designers abusam da herança. Eles afirmam que a herança geralmente quebra o encapsulamento, uma vez que a herança expõe uma subclasse aos detalhes da implementação de seu pai. [8] Conforme descrito pelo problema do ioiô , o uso excessivo de herança e, portanto, encapsulamento, pode se tornar muito complicado e difícil de depurar.

Ocultação de informações

Sob a definição de que o encapsulamento "pode ​​ser usado para ocultar membros de dados e funções de membro", a representação interna de um objeto geralmente é ocultada fora da definição do objeto. Normalmente, apenas os próprios métodos do objeto podem inspecionar ou manipular diretamente seus campos. Ocultar as partes internas do objeto protege sua integridade, impedindo que os usuários definam os dados internos do componente em um estado inválido ou inconsistente. Um suposto benefício do encapsulamento é que ele pode reduzir a complexidade do sistema e, assim, aumentar a robustez , permitindo ao desenvolvedor limitar as interdependências entre os componentes de software. [ citação necessária ]

Algumas linguagens como Smalltalk e Ruby só permitem acesso por meio de métodos de objeto, mas a maioria das outras (por exemplo, C++ , C# , Delphi ou Java ) oferece ao programador um grau de controle sobre o que está oculto, normalmente por meio de palavras-chave como publice private. [6] O padrão ISO C++ refere-se a protected, privatee publiccomo " especificadores de acesso " e que eles não "ocultam nenhuma informação". A ocultação de informações é realizada fornecendo uma versão compilada do código-fonte que é interfaceada por meio de um arquivo de cabeçalho.

Quase sempre, há uma maneira de substituir essa proteção – geralmente via API de reflexão (Ruby, Java, C#, etc.), às vezes por mecanismo como desmembramento de nomes ( Python ) ou uso de palavras-chave especiais como friendem C++. Os sistemas que fornecem segurança baseada em capacidade de nível de objeto (aderindo ao modelo de capacidade de objeto ) são uma exceção e garantem um encapsulamento forte.

Exemplos

Restringindo campos de dados

Linguagens como C++ , C# , Java , PHP , Swift e Delphi oferecem maneiras de restringir o acesso a campos de dados.

Abaixo está um exemplo em C# que mostra como o acesso a um campo de dados pode ser restrito através do uso de uma privatepalavra-chave: 

class  Programa 
{ 
    public  class  Conta 
    { 
        private  decimal  accountBalance  =  500,00 m ;

        public  decimal  CheckBalance () 
        { 
            return  this . saldo da conta ; 
        } 
    }

    static  void  Main () 
    { 
        Conta  minhaConta  =  nova  Conta (); 
        decimal  meuSaldo  =  minhaConta . Cheque Saldo ();

        /* Este método Main pode verificar o saldo através do 
         método público * "CheckBalance" fornecido pela classe "Account" 
         * mas não pode manipular o valor de "accountBalance" */ 
    } 
}

Abaixo segue um exemplo em Java : 

public  class  Funcionário  { 
    private  BigDecimal  salário  =  new  BigDecimal ( 50.000,00 );
    
    public  BigDecimal  getSalary ()  { 
        return  this . salário ; 
    }

    public  static  void  main ()  { 
        Funcionário  e  =  new  Funcionário (); 
        BigDecimal  sal  =  e . obterSalário (); 
    } 
}

O encapsulamento também é possível em linguagens não orientadas a objetos. Em C , por exemplo, uma estrutura pode ser declarada na API pública por meio do arquivo de cabeçalho para um conjunto de funções que operam em um item de dados contendo membros de dados que não são acessíveis aos clientes da API com a palavra- externchave. [9] [10] 

// Arquivo de cabeçalho "api.h"

Entidade  ; _ // Estrutura opaca com membros ocultos          

// Funções de API que operam em objetos 'Entity' 
extern struct Entity * open_entity ( int id );      
extern int process_entity ( struct Entity * info );                 
extern void close_entity ( struct Entity * info );                
// palavras-chave externas aqui são redundantes, mas não fazem mal. 
// extern define funções que podem ser chamadas fora do arquivo atual, o comportamento padrão mesmo sem a palavra-chave

Os clientes chamam as funções de API para alocar, operar e desalocar objetos de um tipo de dados opaco . Os conteúdos deste tipo são conhecidos e acessíveis apenas para a implementação das funções da API; os clientes não podem acessar diretamente seu conteúdo. O código-fonte para essas funções define o conteúdo real da estrutura: 

// Arquivo de implementação "api.c"

#include "api.h" 

struct  Entidade { 
    int ent_id ; // Número de ID char ent_name [ 20 ]; // Nome ... e outros membros ...              
           
        
};

// Implementações da função API 
struct  Entity * open_entity ( int id )   
{ ... }  

int process_entity ( struct Entity * info )   
{ ... }  

void close_entity ( struct Entity * info )   
{ ... }

Destruição de nomes

Abaixo está um exemplo de Python , que não suporta restrições de acesso variável. No entanto, a convenção é que uma variável cujo nome é prefixado por um sublinhado deve ser considerada privada. [11] 

class  Car :  
    def  __init__ ( self )  ->  None : 
        self . _maxspeed  =  200
 
    def  drive ( self )  ->  None : 
        print ( f "A velocidade máxima é { self . _maxspeed } ." )
 
redcar  =  Carro () 
redcar . drive ()   # Isso imprimirá 'Velocidade máxima é 200.'

carro vermelho . _maxspeed  =  10 
redcar . drive ()   # Isso imprimirá 'Velocidade máxima é 10.'

Veja também

Referências

  1. ^ a b Rogers, Wm. Paulo (18 de maio de 2001). "O encapsulamento não é esconder informações" . JavaWorld . Recuperado 2020-07-20 .
  2. ^ Pierce 2002 , § 24.2 Abstração de Dados com Existenciais
  3. ^ Scott, Michael Lee (2006). Pragmática da linguagem de programação (2 ed.). Morgan Kaufmann. pág. 481. ISBN 978-0-12-633951-2. Mecanismos de encapsulamento permitem que o programador agrupe os dados e as sub-rotinas que operam neles em um só lugar e oculte detalhes irrelevantes dos usuários de uma abstração.
  4. ^ Dale, Nell B.; Weems, Chip (2007). Programação e resolução de problemas com Java (2ª ed.). Jones & Barlett. pág. 396. ISBN 978-0-7637-3402-2.
  5. ^ Mitchell, John C. (2003). Conceitos em linguagens de programação . Cambridge University Press. pág. 522. ISBN 978-0-521-78098-8.
  6. ^ a b Pierce, Benjamin (2002). Tipos e Linguagens de Programação . Imprensa do MIT. pág. 266. ISBN 978-0-262-16209-8.
  7. ^ Connolly, Thomas M.; Begg, Carolyn E. (2005). "Ch. 25: Introdução ao Object DMBS § Conceitos orientados a objetos". Sistemas de banco de dados: uma abordagem prática para projeto, implementação e gerenciamento (4ª ed.). Pearson Educação. pág. 814. ISBN 978-0-321-21025-8.
  8. ^ Gama, Erich; Helm, Ricardo; Johnson, Ralf; Vlissides, John (1994). Padrões de Projeto . Addison-Wesley. ISBN 978-0-201-63361-0.
  9. ^ Rei, KN (2008). Programação C: Uma Abordagem Moderna (PDF) (2ª ed.). WW Norton & Company. pág. 464. ISBN  978-0393979503. Recuperado em 1 de novembro de 2019 .
  10. ↑ King, Kim N. C programação: uma abordagem moderna . WW Norton & Company, 2008. Cap. 18, pág. 464, ISBN 0393979504 
  11. ^ Bader, Dan. "O significado de sublinhados em Python" . Melhore suas habilidades em Python . Recuperado em 1 de novembro de 2019 .
Recuperado de " https://en.wikipedia.org/w/index.php?title=Encapsulation_(computer_programming)&oldid=1108531856 "
0.040788173675537