¿Diferencia entre abstracción y encapsulación?


Respuestas:


263

La mayoría de las respuestas aquí se centran en la POO, pero la encapsulación comienza mucho antes:

  • Cada función es una encapsulación ; en pseudocódigo:

    point x = { 1, 4 }
    point y = { 23, 42 }
    
    numeric d = distance(x, y)
    

    Aquí, distanceencapsula el cálculo de la distancia (euclidiana) entre dos puntos en un plano: oculta los detalles de implementación. Esto es encapsulación, pura y simple.

  • La abstracción es el proceso de generalización : tomar una implementación concreta y hacerla aplicable a diferentes tipos de datos, aunque algo relacionados. El ejemplo clásico de abstracción es laqsortfunciónde Cpara ordenar datos:

    La cuestión qsortes que no le importan los datos que clasifica; de hecho, no sabe qué datos clasifica. Más bien, su tipo de entrada es un puntero sin tipo ( void*), que es solo la forma en que C dice "No me importa el tipo de datos" (esto también se llama borrado de tipo). El punto importante es que la implementación de qsortsiempre permanece igual, independientemente del tipo de datos. Lo único que tiene que cambiar es la función de comparación, que difiere de un tipo de datos a otro. qsortpor lo tanto, espera que el usuario proporcione dicha función de comparación como argumento de función.

La encapsulación y la abstracción van de la mano de tal manera que se puede decir que son realmente inseparables. Para fines prácticos, esto es probablemente cierto; Dicho esto, aquí hay una encapsulación que no es una gran abstracción:

class point {
    numeric x
    numeric y
}

Encapsulamos la coordenada del punto, pero no los abstraemos materialmente, más allá de agruparlos lógicamente.

Y aquí hay un ejemplo de abstracción que no es encapsulación:

T pi<T> = 3.1415926535

Esta es una variable genérica pi con un valor dado (π), y a la declaración no le importa el tipo exacto de la variable. Es cierto que sería difícil encontrar algo como esto en el código real: la abstracción prácticamente siempre usa la encapsulación. Sin embargo, lo anterior qué existen realmente en C ++ (14), a través de plantillas variables (= plantillas genéricas para las variables); con una sintaxis un poco más compleja, por ejemplo:

template <typename T> constexpr T pi = T{3.1415926535};

26
Aunque cada método es una encapsulación, también es una abstracción, porque cada vez que juntas algunas cosas y le das un nombre creas un nuevo concepto (abstracto). La encapsulación sin abstracción es inútil. Por lo tanto, no es cierto que no tengan nada en común.
proskor

@proskor Mantengo que los conceptos son ortogonales incluso si sus dominios se superponen. Incluso puede ser cierto que cada encapsulación es una abstracción (aunque no estoy convencido), pero incluso entonces creo que esto sería incidental más que una propiedad inherente de cualquiera de los conceptos.
Konrad Rudolph

8
Son distintos, pero no ortogonales. De hecho, creo que la encapsulación es de hecho un tipo especial de abstracción, es decir, estructural. Al considerar algo compuesto como un todo, básicamente ignoramos (abstraemos) los detalles de cómo está formado por otra cosa, es decir, ignoramos su estructura interna.
Proskor

La abstracción es cuando ocultamos los detalles del nivel de implementación del usuario y le damos acceso solo a los valores necesarios, como Sum (1,10) lo resumirá. No sabemos como. Hemos abstraído el proceso de suma del usuario. Mientras que la definición estándar de encapsulación sugiere cuándo encapsulamos, es decir, hacemos un dato y el método que actúa sobre él. Algo parecido a la clase. Encuadernándolos en una sola entidad. El punto que estoy tratando de traer aquí es que nada es una línea dura, ambos se necesitan mutuamente para existir. Sin uno no hay otro.
Saras Arya

2
@psylogic Supongo que se omite el "por qué" porque parece muy trivial: sin abstracción y encapsulación no podríamos escribir sistemas complejos. Incluso los problemas moderadamente complejos requerirían un código de programa tan complejo que fallarían desde el principio. Sin abstracción, ni siquiera podría escribir un programa para imprimir un número: el concepto "imprimir" implica innumerables abstracciones (¿qué es una pantalla? ¿Qué es un personaje? ¿Qué es un píxel? ...)
Konrad Rudolph

130

La encapsulación está ocultando los detalles de implementación que pueden ser o no para comportamientos genéricos o especializados.

La abstracción es proporcionar una generalización (por ejemplo, sobre un conjunto de comportamientos).

Aquí hay una buena lectura: Abstracción, encapsulación e información oculta por Edward V. Berard de la Agencia de Objetos.


66
El vínculo de Neha también se rompió ahora, pero sí. Siempre podemos buscar en Google el nombre del artículo. este es el que me topé con tonymarston.co.uk/php-mysql/abstraction.txt
Abhijeet Apsunde

1
Cita que me dejó en claro: "Por lo general, la abstracción no se define en términos de ocultar información, por ejemplo, tenga en cuenta el uso de palabras como" ignorar "y" extraer ". Sin embargo, también debemos tener en cuenta el uso de las palabras" suprimir "y" suprimir "en algunos de los ejemplos anteriores. En resumen, se podría decir que la abstracción dicta que cierta información es más importante que otra información, pero (correctamente) no especifica un mecanismo específico para manejar la información sin importancia".
Chiel ten Brinke

1
La encapsulación en OOP no se trata de ocultar algo. Se trata de combinar estado y comportamiento para proteger a los invariantes.
Eugene Khudoy

121

Muchas respuestas y sus ejemplos son engañosos.

La encapsulación es el paquete de datos y funciones que operan en esos datos en un solo componente y restringe el acceso a algunos de los componentes del objeto.
La encapsulación significa que la representación interna de un objeto generalmente está oculta a la vista fuera de la definición del objeto.

La abstracción es un mecanismo que representa las características esenciales sin incluir detalles de implementación.

Encapsulación: - Ocultación de información .
Abstracción: - Implementación oculta .

Ejemplo:

class foo{
    private:
        int a, b;
    public:
        foo(int x=0, int y=0): a(x), b(y) {}

        int add(){    
            return a+b;   
        } 
}  

La representación interna de cualquier objeto de fooclase está oculta fuera de la clase. -> Encapsulación.
Cualquier miembro accesible (datos / función) de un objeto fooestá restringido y solo ese objeto puede acceder a él.

foo foo_obj(3, 4);
int sum = foo_obj.add();

La implementación del método addestá oculta. -> Abstracción.


¿Puede actualizar su respuesta y mostrar un ejemplo de Encapsulación que está en contra / no de Abstracción y un ejemplo de Abstracción que está en contra / no de Encapsulación?
bjan

1
@bjan; Usar la qsortfunción en C es un ejemplo de abstracción. No conoces los detalles de su implementación. No hay encapsulación involucrada aquí. El uso de constructores para inicializar los campos de datos de un objeto en C ++ es un ejemplo de encapsulación (acceso controlado del componente del objeto a través del constructor).
piratea el

"Abstracción: - Implementación oculta". ¿Ocultar la implementación de qué?
Arun Raaj

@ArunRaaj; De otros objetos que lo están usando.
piratea el

3
Esta debería ser la mejor respuesta. simple, claro y tener ejemplos simples junto con ellos.
Don Dilanga el

99

la encapsulación pone algunas cosas en una caja y te da una mirilla; Esto evita que te metas con los engranajes.

la abstracción ignora los detalles que no importan, como si las cosas tienen engranajes, trinquetes, volantes o núcleos nucleares; ellos simplemente "van"

ejemplos de encapsulación:

  • calzoncillos
  • caja de herramientas
  • billetera
  • bolso
  • cápsula
  • carbonita congelada
  • una caja, con o sin botón
  • un burrito (técnicamente, la tortilla alrededor del burrito)

ejemplos de abstracción:

  • "grupos de cosas" es una abstracción (que llamamos agregación)
  • "cosas que contienen otras cosas" es una abstracción (que llamamos composición)
  • "contenedor" es otro tipo de abstracción de "cosas que contienen otras cosas"; tenga en cuenta que todos los ejemplos de encapsulación son tipos de contenedores, pero no todos los contenedores exhiben / proporcionan encapsulación. Una canasta, por ejemplo, es un contenedor que no encapsula su contenido.

12
¿Por qué se rechazó esto? Es una de las únicas descripciones correctas en este gran mar de respuestas incorrectas.
Konrad Rudolph el

3
En la encapsulación al proporcionar solo la mirilla, ¿no hemos ignorado los detalles que no le importan al usuario? Esta es la abstracción [como usted dijo]. ¿Cómo son las dos cosas diferentes? Puede ser que puedas elaborar más.
Sanjeev Kumar Dangi

63
La encapsulación de @Sanjeev es concreta, la abstracción es ... ¡abstracta! ;-) la encapsulación es un objeto que puedes usar, la abstracción es un ideal del que solo puedes hablar. encapsulación es la razón por la que usa ropa interior, la abstracción es cómo explica la diferencia entre ropa interior y trajes de baño
Steven A. Lowe

66
@psylogic abstraction es cómo nosotros, como seres pensantes, tratamos con la complejidad: ignoramos detalles irrelevantes, enfatizamos patrones comunes relevantes, usamos símbolos como sustitutos de objetos reales y caracterizamos cosas similares por cómo se comportan (entre otros patrones de abstracción). La abstracción no fue inventada por la informática, es antigua: los jeroglíficos son abstracciones, las palabras son abstracciones, los pensamientos son abstracciones. La encapsulación también es antigua (ropa interior, armaduras, cajas). Puede estar tratando de hacer estos conceptos mucho más difíciles de lo que realmente son.
Steven A. Lowe

1
@bjan: no dije que no fueran contenedores; son. Agregué algunos que son menos obvios contenedores, pero 'contención' está implícito en la noción de encapsulación. "contenedores" es una abstracción. Una canasta es un contenedor, pero no encapsula (cubre, oculta, protege) su contenido. ¿Eso ayuda?
Steven A. Lowe

64

La encapsulación significa ocultar datos como usar getter y setter, etc.

La abstracción significa la implementación de ocultar usando clases abstractas e interfaces, etc.


Cómo se relaciona su respuesta con "La abstracción es el proceso de generalización" - Cómo podemos lograr la generalización con la ayuda de una clase y una interfaz abstractas. ¿Tienes algún ejemplo?
N Sharma

43

La abstracción es término generalizado. es decir, la encapsulación es un subconjunto de abstracción.

ingrese la descripción de la imagen aquí

  • Ejemplo 2:
    El arquitecto de la solución es la persona que crea el diseño técnico abstracto de alto nivel de toda la solución, y este diseño se entrega al equipo de desarrollo para su implementación .

    Aquí, el arquitecto de soluciones actúa como un resumen y el equipo de desarrollo actúa como una encapsulación.

  • Ejemplo 3: encapsulación (redes) de datos de usuario

ingrese la descripción de la imagen aquí

Cortesía

Abstracción (o modularidad): los tipos permiten a los programadores pensar a un nivel superior al bit o byte, sin molestarse con la implementación de bajo nivel. Por ejemplo, los programadores pueden comenzar a pensar en una cadena como un conjunto de valores de caracteres en lugar de una simple matriz de bytes. Aún más, los tipos permiten a los programadores pensar y expresar interfaces entre dos de subsistemas de cualquier tamaño. Esto permite más niveles de localización para que las definiciones requeridas para la interoperabilidad de los subsistemas permanezcan consistentes cuando esos dos subsistemas se comuniquen. Fuente


Esta es la explicación "más simple" de todas las demás respuestas y también debería haber sido aceptada.
vikramvi

31

Se proporcionan muchas buenas respuestas anteriormente, pero voy a presentar mi punto de vista (Java) aquí.

La encapsulación de datos simplemente significa envolver y controlar el acceso de datos agrupados lógicamente en una clase. Generalmente se asocia con otra palabra clave: ocultación de datos . Esto se logra en Java utilizando modificadores de acceso .

Un ejemplo simple sería definir una variable privada y dar acceso a ella utilizando métodos getter y setter o hacer que un método sea privado, ya que su único uso es dentro de la clase. No es necesario que el usuario conozca estos métodos y variables.

Nota : No debe entenderse mal que la encapsulación se trata solo de ocultar datos. Cuando decimos encapsulación, el énfasis debe estar en agrupar o empaquetar o agrupar datos y comportamientos relacionados.

La abstracción de datos, por otro lado, es un concepto de generalización para que la lógica compleja subyacente no esté expuesta al usuario. En Java esto se logra mediante el uso de interfaces y clases abstractas .

Ejemplo

Digamos que tenemos una interfaz Animal y tiene una función makeSound () . Hay dos clases concretas de perros y gatos que implementan esta interfaz. Estas clases concretas tienen implementaciones separadas de la función makeSound (). Ahora digamos que tenemos un animal (lo obtenemos de algún módulo externo). Todo lo que el usuario sabe es que el objeto que está recibiendo es un animal y es responsabilidad del usuario imprimir el sonido del animal. Una forma de fuerza bruta es comprobar el objeto recibido para identificar su tipo, entonces encasillado a ese tipo de animal y luego llamar makeSound () sobre ella. Pero una forma más ordenada es abstraer la cosa . Usar animal comoreferencia polimórfica y llame a makeSound () en él. En el tiempo de ejecución, según cuál sea el tipo de objeto real, se invocará la función adecuada.

Más detalles aquí .

ingrese la descripción de la imagen aquí

La lógica compleja está en la placa de circuito que está encapsulada en un panel táctil y se proporciona una buena interfaz (botones) para abstraerla al usuario.

PD: los enlaces anteriores están a mi blog personal.


2
Tu blog es muy bueno !! ¡Todos mis conceptos de Oops están completamente claros ahora con las aplicaciones!
minigeek

2
La mejor respuesta hasta ahora. Gracias.
Mario Levesque

29
  • La abstracción te permite concentrarte en lo que hace el objeto en lugar de cómo lo hace
  • La encapsulación significa ocultar los detalles internos o la mecánica de cómo un objeto hace algo.

Al igual que cuando conduce un automóvil, sabe lo que hace el pedal del acelerador, pero es posible que no conozca el proceso detrás de él porque está encapsulado.

Permítanme dar un ejemplo en C #. Supongamos que tiene un número entero:

int Number = 5;
string aStrNumber = Number.ToString();

puede usar un método como Number.ToString () que le devuelve la representación de caracteres del número 5 y lo almacena en un objeto de cadena. El método le dice qué hace en lugar de cómo lo hace.


Casi me upvoted esto para el corto, respuesta precisa, pero luego vi que el coche metáfora de nuevo, que me hacen vomitar - Oh, bueno, soy un buen tipo: P 1
CWAP

Lo siento amigo jeje, agregué una mejor explicación.
jasonco

Entonces, ¿funciones en C también abstracción?
Reddy el

Se pueden construir abstracciones independientemente del lenguaje o paradigma que se utilice. En una respuesta corta, SÍ, puede haber abstracciones en C. ¿Por qué no?
jasonco

17
Sus definiciones de abstracción y encapsulación son las mismas. Esto es lo que entiendo: cómo se hace está oculto y lo que se hace está expuesto. En su ejemplo de car y Number.ToString (), ¿podría señalar con precisión qué es la abstracción y la encapsulación? Esto ayudará a aclarar las cosas.
Sanjeev Kumar Dangi

28

Estos son conceptos algo confusos que no son exclusivos de la informática y la programación. Me gustaría ofrecer algunas ideas adicionales que pueden ayudar a otros a comprender estos conceptos importantes.


Respuesta corta

Encapsulación : Ocultar y / o restringir el acceso a ciertas partes de un sistema, al tiempo que expone las interfaces necesarias.

Abstracción : considerar algo con ciertas características eliminadas, aparte de realidades concretas, objetos específicos o instancias reales, lo que reduce la complejidad.

La principal similitud es que estas técnicas tienen como objetivo mejorar la comprensión y la utilidad.

La principal diferencia es que la abstracción es un medio de representar las cosas de manera más simple (a menudo para hacer que la representación sea más ampliamente aplicable), mientras que la encapsulación es un método para cambiar la forma en que otras cosas interactúan con algo.


Respuesta larga

Encapsulamiento

Aquí hay un ejemplo de encapsulación que, con suerte, aclara las cosas:

Encapsulación Arduino

Aquí tenemos un Arduino Uno y un Arduino Uno dentro de un recinto. Un recinto es una gran representación de lo que se trata la encapsulación.

La encapsulación tiene como objetivo proteger ciertos componentes de las influencias externas y el conocimiento, así como exponer componentes con los que otras cosas deberían interactuar. En términos de programación, esto implica ocultar información a través de modificadores de acceso , que cambian la medida en que ciertas variables y / o propiedades pueden leerse y escribirse.

Pero más allá de eso, la encapsulación también tiene como objetivo proporcionar esas interfaces externas de manera mucho más efectiva. Con nuestro ejemplo de Arduino, esto podría incluir los botones y la pantalla agradables que hacen que la interacción del usuario con el dispositivo sea mucho más simple. Proporcionan al usuario formas sencillas de afectar el comportamiento del dispositivo y obtener información útil sobre su funcionamiento que de otro modo sería mucho más difícil.

En la programación, esto implica el agrupamiento de diversos componentes en una construcción separable, tal como una function, classo object. También incluye proporcionar los medios para interactuar con esos constructos, así como métodos para obtener información útil sobre ellos.

La encapsulación ayuda a los programadores de muchas maneras adicionales, entre las cuales se encuentra la mejora de la capacidad de mantenimiento y la capacidad de prueba del código.

Abstracción

Aunque muchas otras respuestas aquí definieron la abstracción como generalización, personalmente creo que esa definición está equivocada. Diría que la generalización es en realidad un tipo específico de abstracción, no al revés. En otras palabras, todas las generalizaciones son abstracciones, pero todas las abstracciones no son necesariamente generalizaciones.

Así es como me gusta pensar en la abstracción:

Árbol de píxeles

¿Dirías que la imagen hay un árbol? Lo más probable es que lo haría. ¿Pero es realmente un árbol? ¡Pues claro que no! Es un montón de píxeles hechos para parecerse a algo que podríamos llamar un árbol. Podríamos decir que representa una abstracción de un árbol real. Tenga en cuenta que se omiten varios detalles visuales del árbol. Además, no crece, consume agua ni produce oxígeno. Como podria son solo un montón de colores en una pantalla, representados por bytes en la memoria de su computadora.

Y aquí está la esencia de la abstracción. Es una forma de simplificar las cosas para que sean más fáciles de entender. Cada idea que pasa por tu cabeza es una abstracción de la realidad. Su imagen mental de un árbol no es más un árbol real que este JPEG.

En programación, podríamos usar esto para nuestra ventaja al crear una Treeclase con métodos para el cultivo simulado, el consumo de agua y la producción de oxígeno. Nuestra creación sería algo que representa nuestra experiencia de árboles reales, y solo incluye aquellos elementos que realmente nos interesan para nuestra simulación particular. Usamos la abstracción como una forma de representar nuestra experiencia de algo con bytes y matemáticas.

Clases abstractas

La abstracción en la programación también nos permite considerar elementos comunes entre varios tipos de objetos "concretos" (tipos que realmente existen) y definir esos elementos comunes dentro de una entidad única. Por ejemplo, nuestra Treeclase puede heredar de un abstract class Plant, que tiene varias propiedades y métodos que son aplicables a todas nuestras clases de plantas, pero elimina aquellos que son específicos para cada tipo de planta. Esto puede reducir significativamente la duplicación de código y mejora la capacidad de mantenimiento.

La diferencia práctica de an abstract classy plain classes que conceptualmente no hay instancias "reales" del abstract class. No tendría sentido construir un Plantobjeto porque no es lo suficientemente específico. Cada "real" Plantes también un tipo más específico de Plant.

Además, si queremos que nuestro programa sea más realista, podríamos considerar el hecho de que nuestra Treeclase podría ser demasiado abstracta en sí misma. En realidad, cada Treees un tipo más específico de Tree, por lo que podríamos crear clases para esos tipos, tales como Birch, Maple, etc., que heredamos de nuestros, quizás ahora abstract, Treeclase.

JVM

Otro buen ejemplo de abstracción es la Java Virtual Machine (JVM) , que proporciona una computadora virtual o abstracta para que se ejecute el código Java. Básicamente elimina todos los componentes específicos de la plataforma de un sistema y proporciona una interfaz abstracta de "computadora" sin tener en cuenta ningún sistema en particular.

La diferencia

La encapsulación difiere de la abstracción en que no tiene nada que ver con cuán "real" o "preciso" es algo. No elimina los componentes de algo para hacerlo más simple o más ampliamente aplicable. Más bien, puede ocultar ciertos componentes para lograr un propósito similar.


22

Encapsulación : está ocultando detalles de implementación no deseados / no esperados / de propiedad de los usuarios reales del objeto. p.ej

List<string> list = new List<string>();
list.Sort(); /* Here, which sorting algorithm is used and hows its 
implemented is not useful to the user who wants to perform sort, that's 
why its hidden from the user of list. */

Abstracción : es una forma de proporcionar generalización y, por lo tanto, una forma común de trabajar con objetos de gran diversidad. p.ej

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

44
Su ejemplo de encapsulación es, de hecho, un ejemplo de abstracción.
hackea

13

Diferencia entre abstracción y encapsulación.

Diferencia entre abstracción y encapsulación


¿Alguien más puede confirmar que la diferencia es que la abstracción está en el nivel de diseño, la encapsulación está en el nivel de implementación? ¡Si es así, esto realmente me ha aclarado las cosas!
Adam Carter

12

Abstracción: La idea de presentar algo de una manera simplificada / diferente, que es más fácil de entender y usar o más pertinente a la situación.

Considere una clase que envía un correo electrónico ... utiliza la abstracción para mostrarse como una especie de mensajero, para que pueda llamar a emailSender.send (correo, destinatario). Lo que realmente hace: elige POP3 / SMTP, llamar a los servidores, la traducción MIME, etc., se abstrae. Solo ves a tu mensajero.

Encapsulación: la idea de proteger y ocultar datos y métodos que son privados de un objeto. Se trata más de hacer algo independiente e infalible.

Tómame, por ejemplo. Encapsulo mi ritmo cardíaco del resto del mundo. Porque no quiero que nadie más cambie esa variable, y no necesito que nadie más la configure para que funcione. Es de vital importancia para mí, pero no necesitas saber qué es, y probablemente no te importe de todos modos.

Mira a tu alrededor y encontrarás que casi todo lo que tocas es un ejemplo de abstracción y encapsulación. Su teléfono, por ejemplo, le presenta la abstracción de poder llevar lo que dice y decirlo a otra persona: encubrir GSM, arquitectura de procesador, frecuencias de radio y un millón de otras cosas que no entiende o no le importan. También encapsula ciertos datos suyos, como números de serie, números de identificación, frecuencias, etc.

Todo hace del mundo un lugar más agradable para vivir: D


10

Abstracción: solo se muestra la información necesaria. Centrémonos en el ejemplo de encender una computadora. El usuario no tiene que saber qué sucede mientras el sistema todavía se está cargando (esa información está oculta para el usuario).

Tomemos otro ejemplo, el del cajero automático. El cliente no necesita saber cómo la máquina lee el PIN y procesa la transacción, todo lo que necesita hacer es ingresar el PIN, tomar el efectivo y salir.

Encapsulación: se ocupa de ocultar los datos confidenciales de un clas, por lo tanto, privatizar parte de él. Es una forma de mantener cierta información privada para sus clientes al no permitir el acceso desde fuera.


2
Creo que "la forma de mantener la información privada" es ocultar información. La encapsulación es solo información envolvente, que puede ser privada o pública.
No es un error

La encapsulación se malinterpreta con la ocultación de datos.
thesummersign

8

Otro ejemplo:

Supongamos que creé una clase de rectángulo inmutable como esta:

class Rectangle {
 public:
  Rectangle(int width, int height) : width_(width), height_(height) {}
  int width() const { return width_; }
  int height() const { return height_; }

 private:
  int width_;
  int height_;
}

Ahora es obvio que he encapsulado ancho y alto (el acceso está de alguna manera restringido), pero no he extraído nada (está bien, tal vez he ignorado dónde está ubicado el rectángulo en el espacio de coordenadas, pero esto es un defecto del ejemplo).

Una buena abstracción generalmente implica una buena encapsulación.

Un ejemplo de buena abstracción es una clase de conexión de base de datos genérica. Su interfaz pública es independiente de la base de datos, y es muy simple, pero me permite hacer lo que quiero con la conexión. ¿Y ves? También hay encapsulación allí, porque la clase debe tener todos los identificadores y llamadas de bajo nivel dentro.


8

Abstractiony Encapsulationusando un solo ejemplo generalizado

-------------------------------------------------- -------------------------------------------------- --------------------------------

¡Todos usamos calculadora para el cálculo de problemas complejos!

imagen


2
@NehaChoudhary, creo que quieres decir Your both example tell about just encapsulation, not abstraction; porque la abstracción no tiene nada que ver hidingmás bienGeneralizing
Rahul

@Rahul ¡Ahora, no creo que ambos expliquen la encapsulación!
Neha Choudhary

3
@Devrath Si desea contar la abstracción usando calulcator, puede querer ir así: Hay un concepto abstracto de Calculadora que calcula cuál es generalizado y puede usarse como un concepto base para hacer diferentes tipos de calculadora. Por ejemplo, BasicCalculator y ScientificCalculator, ambos implementan sus propias formas de cálculo pero al final cumplen los criterios de Calculadora generalizada.
Neha Choudhary

hasta ahora la mejor respuesta en el mar de la respuesta incorrecta
Aman

7

Un mecanismo que evita que los datos de un objeto en particular estén a salvo del mal uso intencional o accidental por parte de funciones externas se denomina " Encapsulación de datos"

El acto de representar características esenciales sin incluir detalles de fondo o explicaciones se conoce como abstracción.


7

Abstracción: Abstracción significa mostrar Whatparte de la funcionalidad.

Encapsulación: la encapsulación significa ocultar la Howparte de la funcionalidad.

Tomemos un ejemplo muy simple.

/// <summary>
/// We have an Employee class having two properties EmployeeName and EmployeeCode
/// </summary>
public class Employee
{
    public string EmplpyeeName { get; set; }
    public string EmployeeCode { get; set; }

    // Add new employee to DB is the main functionality, so are making it public so that we can expose it to external environment
    // This is ABSTRACTION
    public void AddEmployee(Employee obj)
    {
        // "Creation of DB connection" and "To check if employee exists" are internal details which we have hide from external environment
        // You can see that these methods are private, external environment just need "What" part only
        CreateDBConnection();
        CheckIfEmployeeExists();
    }


    // ENCAPLUSATION using private keyword
    private bool CheckIfEmployeeExists()
    {
        // Here we can validate if the employee already exists
        return true;
    }

    // ENCAPLUSATION using private keyword
    private void CreateDBConnection()
    {
        // Create DB connection code
    }
}

Clase de programa de aplicación de consola

class Program
{
    static void Main(string[] args)
    {
        Employee obj = new Employee();
        obj.EmplpyeeName = "001";
        obj.EmployeeCode = "Raj";

        // We have exposed only what part of the functionality
        obj.AddEmployee(obj);
    }
}

6

Tomemos el ejemplo de una pila. Se podría implementar utilizando una matriz o una lista vinculada. Pero las operaciones que admite son push y pop.

Ahora la abstracción está exponiendo solo las interfaces push y pop. La representación subyacente está oculta (¿es una matriz o una lista vinculada?) Y se proporciona una interfaz bien definida. Ahora, ¿cómo se asegura de que no se realice un acceso accidental a los datos abstraídos? Ahí es donde entra la encapsulación . Por ejemplo, las clases en C ++ usan los especificadores de acceso que aseguran que se evite el acceso accidental y la modificación. Y también, al hacer públicas las interfaces mencionadas anteriormente, asegura que la única forma de manipular la pila es a través de una interfaz bien definida. En el proceso, ha acoplado los datos y el código que puede manipularlos (no involucremos las funciones de amigo aquí). Es decir, el código y los datos están unidos, unidos o encapsulados.


5

La encapsulación está envolviendo la complejidad en una cápsula que es clase y, por lo tanto, encapsulación ... Mientras que la abstracción es las características de un objeto que se diferencia de otro objeto ...

La abstracción se puede lograr haciendo un resumen de clase con uno o más métodos abstractos. Lo cual no es más que la característica que debe implementar la clase extendiéndola. por ejemplo, cuando inventa / diseña un automóvil, define características como que el automóvil debe tener 4 puertas, freno, volante, etc., por lo que cualquiera que use este diseño debe incluir estas características. La implementación no es la cabeza de cada abstracción. Solo definirá las características que deben incluirse.

La encapsulación se logra manteniendo los datos y el comportamiento en una cápsula que es de clase y mediante el uso de modificadores de acceso como públicos, privados, protegidos junto con herencia, agregación o composición. Entonces, solo muestra las cosas requeridas, eso también, solo en la medida en que desea mostrar. es decir, ka funda pública, protegida, amigable y privada ... por ejemplo, GM decide utilizar el diseño abstracto del automóvil anterior. Pero tienen varios productos que tienen las mismas características y tienen casi la misma funcionalidad. Entonces escriben una clase que extiende la clase abstracta anterior. Dice cómo debería funcionar la caja de cambios, cómo debería funcionar la rotura, cómo debería funcionar el volante. Entonces todos los productos solo usan esta funcionalidad común. No necesitan saber cómo funciona la caja de engranajes o los trabajos de rotura o la rueda dentada.

Ambos son poderosos; pero el uso de la abstracción requiere más habilidades que la encapsulación y las aplicaciones / productos más grandes no pueden sobrevivir sin la abstracción.


¿"utilizar la abstracción requiere más habilidades que la encapsulación"? Cita necesaria.
Johnsyweb

5

Abstracción --- Ocultación de la implementación - en el diseño --- Uso de la interfaz / Cálculos abstractos

Encapsulación - Ocultar datos - En desarrollo --- Usar modificadores de acceso (públicos / privados)


4

De esto

Diferencia entre encapsulación y abstracción en OOPS

La abstracción y la encapsulación son dos conceptos importantes de programación orientada a objetos (OOPS). Encapsulación y abstracción son términos interrelacionados.

Diferencia de la vida real entre encapsulación y abstracción

Encapsular significa esconderse. La encapsulación también se llama ocultación de datos. Puede pensar que la encapsulación es como una cápsula (tableta de medicina) que oculta la medicina dentro de ella. La encapsulación es envolvente, solo oculta propiedades y métodos. La encapsulación se usa para ocultar el código y los datos en una sola unidad para proteger los datos del exterior del mundo. La clase es el mejor ejemplo de encapsulación.

La abstracción se refiere a mostrar solo los detalles necesarios al usuario deseado. Como su nombre indica, la abstracción es la "forma abstracta de cualquier cosa". Usamos abstracción en lenguajes de programación para hacer una clase abstracta. La clase abstracta representa una vista abstracta de los métodos y propiedades de la clase.

Diferencia de implementación entre encapsulación y abstracción

  1. La abstracción se implementa mediante la interfaz y la clase abstracta, mientras que la encapsulación se implementa mediante un modificador de acceso privado y protegido.

  2. OOPS hace uso de la encapsulación para hacer cumplir la integridad de un tipo (es decir, para asegurarse de que los datos se usen de manera adecuada) al evitar que los programadores accedan a los datos de una manera no deseada. A través de la encapsulación, solo un grupo predeterminado de funciones puede acceder a los datos. El término colectivo para tipos de datos y operaciones (métodos) agrupados junto con restricciones de acceso (público / privado, etc.) es una clase.


4

Intentaré demostrar la encapsulación de una manera simple ... Veamos ...

  • La envoltura de datos y funciones en una sola unidad (llamada clase) se conoce como encapsulación. Encapsulación que contiene y oculta información sobre un objeto, como estructuras de datos internos y código.

La encapsulación es -

  • Complejidad oculta,
  • Vinculando datos y función juntos,
  • Hacer que el método complicado sea privado,
  • Hacer que la instancia Variable sea privada,
  • Ocultar datos y funciones innecesarios del usuario final.

La encapsulación implementa la abstracción.

Y la abstracción es ...

  • Mostrando lo que es necesario,
  • Los datos deben abstraerse del usuario final,

Veamos un ejemplo.

La siguiente imagen muestra una GUI de "Detalles del cliente que se AGREGARÁN a una base de datos".

GUI de la pantalla del cliente

Al mirar la imagen, podemos decir que necesitamos una clase de cliente.

Paso - 1: ¿Qué necesita mi clase de cliente?

es decir

  • 2 variables para almacenar el Código del cliente y el Nombre del cliente.
  • 1 función para agregar el código del cliente y el nombre del cliente en la base de datos.

    espacio de nombres CustomerContent {public class Customer {public string CustomerCode = ""; cadena pública CustomerName = ""; public void ADD () {// mi código de DB irá aquí}

Ahora solo el método ADD no funcionará aquí solo.

Paso -2: ¿Cómo funcionará la validación, actuará la función ADD?

Necesitaremos el código de conexión de la base de datos y el código de validación (métodos adicionales).

public bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

public bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";
obj.CustomerName = "Mac";

obj.Validate();
obj.CreateDBObject();

obj.ADD();
}
}

Ahora no es necesario mostrar los métodos adicionales (Validate (); CreateDBObject () [Complicated and Extra method]) al Usuario final. El usuario final solo necesita ver y conocer el Código del cliente, el Nombre del cliente y el botón AGREGAR el registro. Al usuario final no le importa CÓMO AGREGARÁ los datos a la base de datos.

Paso -3: Priva los métodos extra y complicados que no implican la interacción del usuario final.

Entonces, hacer que los métodos Complicado y Extra sean privados en lugar de públicos (es decir, ocultar esos métodos) y eliminar obj.Validate (); obj.CreateDBObject (); del programa principal en la clase logramos encapsulación.

En otras palabras, simplificar la interfaz para el usuario final es la encapsulación.

Así que ahora el código se ve a continuación:

namespace CustomerContent
{
public class Customer
{
public string CustomerCode = "";
public string CustomerName = "";
public void ADD()
{
   //my DB code will go here
}

private bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

private bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";

obj.CustomerName = "Mac";

obj.ADD();
}
}

Resumen :

Paso -1: ¿Qué necesita mi clase de cliente? es abstracción

Paso -3: Paso -3: Privar los métodos extra y complicados que no implican la interacción del usuario final es la encapsulación.

PD: el código anterior es duro y rápido.


4

El siguiente párrafo me ayudó a comprender cómo difieren entre sí:

La encapsulación de datos es un mecanismo para agrupar los datos, y las funciones que los utilizan y la abstracción de datos es un mecanismo para exponer solo las interfaces y ocultar los detalles de implementación del usuario.

Puedes leer más aquí .


3

La ocultación de información no es estrictamente necesaria para la abstracción o la encapsulación. La información puede ser ignorada, pero no tiene que estar oculta.

La encapsulación es la capacidad de tratar algo como una sola cosa, a pesar de que puede estar compuesto de muchas partes o ideas complejas. Por ejemplo, puedo decir que estoy sentado en una "silla" en lugar de referirme a las diversas partes de esa silla, cada una con un diseño y una función específicos, todas juntas precisamente con el propósito de sostener cómodamente mi trasero unos pocos pies lejos del piso.

La abstracción se habilita por encapsulación. Debido a que encapsulamos objetos, podemos pensar en ellos como cosas que se relacionan entre sí de alguna manera en lugar de atascarse en los detalles sutiles de la estructura interna del objeto. La abstracción es la capacidad de considerar la imagen más grande, eliminada de la preocupación por los pequeños detalles.La raíz de la palabra es abstracta como en el resumen que aparece en la parte superior de un artículo académico, no abstracta como en una clase que solo puede ser instanciada como una subclase derivada.

Puedo decir honestamente que cuando dejo caer mi trasero en mi silla, nunca pienso en cómo la estructura de esa silla atrapará y sostendrá mi peso. Es una silla lo suficientemente decente como para no tener que preocuparme por esos detalles. Entonces puedo dirigir mi atención hacia mi computadora. Y de nuevo, no pienso en las partes componentes de mi computadora. Solo estoy mirando una parte de una página web que representa un área de texto que puedo escribir, y me estoy comunicando con palabras, apenas si pienso en cómo mis dedos siempre encuentran las letras correctas tan rápido en el teclado, y cómo la conexión finalmente se hace entre tocar estas teclas y publicar en este foro. Este es el gran poder de la abstracción. Debido a que se puede confiar en que los niveles más bajos del sistema funcionarán con consistencia y precisión, tenemos atención de sobra para un mayor trabajo.


2
class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

2

la abstracción está ocultando datos no útiles de los usuarios y la encapsulación es unir datos en una cápsula (una clase). Creo que la encapsulación es la forma de lograr la abstracción.


2

El proceso de abstracción y encapsulación generan interfaces.

Una interfaz generada mediante encapsulación oculta los detalles de implementación.

Una interfaz generada mediante abstracción se aplica a más tipos de datos, en comparación con antes de la abstracción.


2

Abstractiones un contrato para la implementación que vamos a hacer. La implementación puede cambiar con el tiempo. Las diversas implementaciones en sí pueden estar ocultas o no, pero están enmascaradas detrás de la abstracción.

Supongamos que definir todos los APIsde una clase en una interfacecontinuación, pedir a los usuarios de nuestro código para depened sobre el definido APIsdel interface. Somos libres de mejorar o modificar la implementación, solo debemos seguir el contrato establecido. Los usuarios no están unidos a nuestra implementación.

EXPONEMOS todas las Reglas NECESARIAS (métodos) en abstracción , la implementación de las reglas se deja a las entidades implementadoras, también la implementación no es parte de la abstracción. Es solo la firma y la declaración lo que hace la abstracción.

Encapsulationes simplemente OCULTAR los detalles internos al reducir el acceso de los estados y comportamientos. Una clase encapsulada puede o no tener una buena definición Abstraction.

java.util.ListEs una abstracción para java.util.ArrayList. Los estados internos de java.util.ArrayListestar marcado connon public modificadores de acceso es la encapsulación.

Editar Supongamos que una clase Container.nava implements IContainer, IContainerpuede declarar métodos como addElement, removeElements, contains, etc. Aquí IContainerrepresenta la abstracción para su clase de aplicación. La abstracción es declarar las API de la clase o un módulo o un sistema al mundo exterior. Estas API se convierten en contract. Ese sistema puede estar o no desarrollado aún. Los usuarios del sistema ahora pueden depender de las API declaradas y están seguros de que cualquier sistema que implemente dicho contrato siempre se adherirá a las API declaradas, siempre proporcionarán la implementación tge para esas API. Una vez que estamos escribiendo alguna entidad concreta, la decisión de ocultar nuestros estados internos es la encapsulación



1

En breve

Uso de abstracción -> Encapsulación y uso de encapsulación -> ocultación de datos

O

la ocultación de datos es un subconjunto de Encapsulación y la Encapsulación es un subconjunto de Abstracción

Referencia: http://www.tonymarston.co.uk/php-mysql/abstraction.txt


¿Cómo utiliza la encapsulación la ocultación de datos? Acc. para Tony marston la encapsulación es simplemente envolver entidades mientras no se menciona nada sobre el comportamiento oculto. Si la encapsulación era "lo mismo que ocultar información", entonces uno podría argumentar que "todo lo que estaba encapsulado también estaba oculto". Esto obviamente no es verdad. Por ejemplo, aunque la información puede estar encapsulada dentro de estructuras y matrices de registros, esta información generalmente no está oculta (a menos que esté oculta a través de algún otro mecanismo).
Harshul Sharma
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.