Encapsulación (programación)

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 21 de septiembre de 2016; las comprobaciones requieren 79 ediciones .

Encapsulación ( ing.  encapsulation , del lat.  in capsula ) - en informática , el proceso de separar los elementos de las abstracciones que determinan su estructura (datos) y comportamiento (métodos); la encapsulación tiene por objeto aislar las obligaciones contractuales de una abstracción (protocolo/interfaz) de su implementación. En la práctica, esto significa que una clase debe constar de dos partes: una interfaz y una implementación. La implementación de la mayoría de los lenguajes de programación ( C++ , C# , Java y otros) proporciona un mecanismo de ocultación que le permite diferenciar el acceso a las diferentes partes del componente.

La encapsulación a menudo se ve como un concepto exclusivo de la programación orientada a objetos (OOP) , pero de hecho se encuentra ampliamente en otros (ver subtipificación de registros y polimorfismo de registros y variantes ). En OOP, la encapsulación está estrechamente relacionada con el principio de abstracción de datos (que no debe confundirse con los tipos de datos abstractos, cuyas implementaciones proporcionan encapsulación pero son de naturaleza diferente). Esto, en particular, implica diferencias en la terminología en diferentes fuentes. En la comunidad de C++ o Java , la encapsulación sin ocultar generalmente se considera inferior. Sin embargo, algunos lenguajes (p. ej. , Smalltalk , Python ) implementan la encapsulación pero no prevén la ocultación en absoluto. Otros ( Standard , OCaml ) separan rígidamente estos conceptos como ortogonales y los proporcionan de una manera semánticamente diferente (ver ocultar en el lenguaje del módulo ML ).

Detalles

En general, en diferentes lenguajes de programación, el término "encapsulación" se refiere a una o ambas de las siguientes notaciones al mismo tiempo:

La palabra "encapsulación" proviene del latín in capsula  - "colocación en el caparazón". Por lo tanto, la encapsulación puede entenderse intuitivamente como aislamiento, cerrando algo extraño para excluir la influencia en el entorno, asegurando la disponibilidad del contenido principal, resaltando el contenido principal colocando todo lo que interfiere, secundario en alguna cápsula condicional ( caja negra ).

Ejemplos

Adá

el paquete Stacks es tipo Stack_Type es privado ; procedimiento Push ( Stack : in out Stack_Type ; Val : Integer ); privado tipo Stack_Data es una matriz ( 1 .. 100 ) de Integer ; tipo Stack_Type es registro Máx .: Entero : = 0.3 ; Datos : Stack_Data ; registro final ; pilas finales ;

C++

clase A { público : int a , b ; // datos de la interfaz pública int Return_Something (); // método de interfaz pública privado : int Aa , Ab ; //datos ocultos void Hacer_Algo (); // método oculto };

La clase A encapsula las propiedades Aa, Ab y el método Do_Something(), que representan la interfaz externa Return_Something, a, b.

C#

El propósito de la encapsulación es asegurar que el estado interno de un objeto sea consistente. En C#, las propiedades públicas y los métodos de un objeto se usan para la encapsulación. Las variables, con raras excepciones, no deben estar disponibles públicamente. La encapsulación se puede ilustrar con un ejemplo simple. Supongamos que necesitamos almacenar un valor real y su representación de cadena (por ejemplo, para no convertir cada vez en caso de uso frecuente). Un ejemplo de implementación sin encapsulación es el siguiente:

class NoEncapsulation { public double ValueDouble ; Cadena de valores pública ; }

Al mismo tiempo, podemos cambiar por separado tanto el Valor en sí como su representación de cadena, y en algún momento pueden no coincidir (por ejemplo, como resultado de una excepción). Ejemplo de implementación usando encapsulación:

class EncapsulationExample { private double valueDouble ; Cadena de valor de cadena privada ; public double ValueDouble { get { return valueDouble ; } set { valorDoble = valor ; valorCadena = valor . a la cadena (); } } public string ValueString { get { return valueString ; } establecer { doble tmp_value = Convertir . ToDouble ( valor ); //puede ocurrir una excepción aquí valueDouble = tmp_value ; valorCadena = valor ; } } }

Aquí, solo se puede acceder a las variables valueDouble y valueString a través de las propiedades ValueDouble y ValueString . Si tratamos de asignar una cadena no válida a la propiedad ValueString y se produce una excepción en el momento de la conversión, las variables internas permanecerán en el mismo estado coherente, ya que la excepción provoca la salida del procedimiento.

Delfos

En Delphi, para crear campos o métodos ocultos , basta con declararlos en el archivo private.

TMyClass = class private FMyField : Integer ; procedimiento SetMyField ( const Value : Integer ) ; función GetMyField : Integer ; public property MyField : Integer read GetMyField write SetMyField ; fin ;

Para crear una interfaz para acceder a campos ocultos, Delphi introdujo propiedades .

PHP

clase A { cadena privada $a ; // propiedad oculta private int $b ; // propiedad oculta función privada hacerAlgo () : void //método oculto { //acciones } public function returnAlgo () : int //método publico { //acciones } }

En este ejemplo, la clase A tiene sus propiedades $a y $b cerradas para evitar que estas propiedades se dañen con otro código al que se le deben otorgar permisos de solo lectura.

Java

clase primero { privado en un ; int privado b ; privado vacío hacerAlgo () { //método oculto //comportamiento } public int obtenerAlgo () { //método público devolver un ; } }

JavaScript

sea ​​A = función () { // privado dejar _propiedad ; let _privateMethod = function () { /* acciones */ } // método privado // público esto _ getProperty = función () { // interfaz pública volver _propiedad ; } esto _ setProperty = función ( valor ) { // interfaz pública _propiedad = valor ; _método privado (); } }

o

sea ​​A = función () { // privado dejar _propiedad ; let _privateMethod = function () { /* acciones */ } // método privado // público volver { } }

o usando propiedades privadas

clase A { #propiedad ; _ # metodoprivado = () => { /* acciones */ } obtener propiedad () { // captador devolver esto . #propiedad ; _ } establecer propiedad ( valor ) { // setter esto _ # propiedad = valor ; } }