¿Cuál es la diferencia precisa entre encapsulación y abstracción?

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};

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.

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.

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.

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.

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

• 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

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

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í .

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.

• 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.

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:

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:

¿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.

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**

Diferencia entre abstracción y encapsulación.

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

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.

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.

Abstractiony Encapsulationusando un solo ejemplo generalizado

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

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

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.

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);
    }
}

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.

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.

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)

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.

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".

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.

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í .

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.

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**

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.

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.

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

Creo que la encapsulación es una forma de implementar la abstracción. Echa un vistazo al siguiente enlace.

Abstracción y encapsulación

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