oop - usan - ¿Diferencia entre abstracción y encapsulación?

ocultamiento de informacion en programacion (30)

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

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

`Abstraction` y `Encapsulation` usando un solo ejemplo generalizado

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

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

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 --- Uso de modificadores de acceso (público / privado)

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

La encapsulación de datos simplemente significa ajustar y controlar el acceso de datos agrupados lógicamente en una clase. En general, se asocia con otra palabra clave - Ocultar datos . Esto se logra en Java usando modificadores de acceso .

Un ejemplo simple sería definir una variable privada y darle acceso utilizando métodos de obtención y establecimiento o hacer que un método sea privado, ya que solo se usa dentro de la clase. No es necesario que el usuario conozca estos métodos y variables.

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

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

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 (Obtenemos esto de algún módulo externo). Todo lo que el usuario sabe es que el objeto que está recibiendo es algún animal y es responsabilidad del usuario imprimir el sonido del animal. Una forma de fuerza bruta es verificar el objeto recibido para identificar su tipo, luego encasillarlo en ese tipo de Animal y luego llamar a makeSound () en él. Pero una forma más ordenada es extraer los resúmenes . Utilice Animal como referencia polimórfica y llame a makeSound () en él. En tiempo de ejecución, dependiendo de lo que el tipo de objeto real es apropiado, se invocará la función.

Más detalles here .

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

Diferencia entre abstracción y encapsulación.

Estos son conceptos un tanto 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 entender estos conceptos importantes.

Respuesta corta

Encapsulación : ocultar y / o restringir el acceso a ciertas partes de un sistema, mientras se exponen 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 para 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

Encapsulacion

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.

El objetivo de la encapsulación es proteger ciertos componentes de influencias y conocimientos externos, así como exponer componentes con los que otras cosas deberían interactuar. En términos de programación, esto implica información que se oculta a través de modificadores de acceso , que cambian la medida en que ciertas variables y / o propiedades se pueden leer y escribir.

Pero más allá de eso, la encapsulación también apunta a proporcionar esas interfaces externas de manera mucho más efectiva. Con nuestro ejemplo de Arduino, esto podría incluir los bonitos botones y la pantalla que hacen que la interacción del usuario con el dispositivo sea mucho más sencilla. 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 programación, esto implica la agrupación de varios componentes en una construcción separable, como una function , class u object . También incluye proporcionar los medios para interactuar con esas construcciones, 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 capacidad de mantenimiento y la capacidad de prueba mejoradas del código.

Abstracción

Aunque muchas otras respuestas aquí definieron la abstracción como generalización, personalmente creo que esa definición es errónea. Yo 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 es un árbol? Lo más probable es que lo haría. ¿Pero es realmente un árbol? Bueno, por supuesto que no! Es un conjunto de píxeles hechos para parecerse a algo que podríamos llamar un árbol. Podríamos decir que es una abstracción de un árbol real. Observe que se omiten varios detalles visuales del árbol. Además, no crece, no consume agua ni produce oxígeno. Como pudo es 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. Tu imagen mental de un árbol no es más un árbol real de lo que es este jpeg.

En programación, podríamos usar esto para nuestra ventaja al crear una clase de Tree con métodos para el crecimiento 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 en 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 puntos en común entre varios tipos de objetos "concretos" (tipos que realmente existen) y definir esos puntos en común dentro de una entidad única. Por ejemplo, nuestra clase Tree puede heredar de una abstract class Plant , que tiene varias propiedades y métodos que son aplicables a todas nuestras clases similares a plantas, pero elimina aquellas que son específicas 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 una abstract class y una abstract class simple es que conceptualmente no hay instancias "reales" de la abstract class . No tendría sentido construir un objeto Plant porque eso no es lo suficientemente específico. Cada Plant "real" es también un tipo más específico de Plant .

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

JVM

Otro buen ejemplo de abstracción es la Máquina Virtual de Java (JVM) , que proporciona una computadora virtual o abstracta para ejecutar 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 se diferencia de la abstracción en que no tiene nada que ver con lo "real" o "exacto" que 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.

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 son las características de un objeto que se diferencia de otro objeto ...

La abstracción se puede lograr haciendo que el resumen de la clase tenga uno o más métodos abstractos. Lo que no es más que la característica que debe ser implementada por la clase que lo extiende. por ejemplo, cuando usted inventa / diseña un automóvil, define características como que el automóvil debe tener 4 puertas, rotura, volante, etc. Por lo tanto, cualquier persona 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 ser incluidas.

La encapsulación se logra manteniendo los datos y el comportamiento en una cápsula que es clase y haciendo uso de modificadores de acceso como público, privado, protegido junto con herencia, agregación o composición. Por lo tanto, solo muestra cosas requeridas, eso también, solo en la medida en que quiera mostrarlas. es decir, público, protegido, amistoso y privado ka funda …… por ejemplo, GM decide utilizar el diseño abstracto del automóvil que se muestra arriba. Pero tienen varios productos que tienen las mismas características y casi la misma funcionalidad. Así que escriben una clase que extiende la clase abstracta anterior. Dice cómo debería funcionar la caja de engranajes, 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 o cómo funciona la caja de engranajes o cómo funciona la dirección. El producto indivisual seguramente puede tener más funciones como a / c o auto lock, etc.

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.

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

Cada función es una encapsulation ; en pseudocódigo
point x = { 1, 4 } point y = { 23, 42 } numeric d = distance(x, y)
Aquí, la distance encapsula el cálculo de la distancia (euclidiana) entre dos puntos en un plano: oculta los detalles de la implementación. Esto es encapsulación, pura y simple.
Abstraction 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 la función qsort de C para ordenar los datos:
Lo que pasa con qsort es que no le importan los datos que ordena, de hecho, no sabe qué datos ordena. Más bien, su tipo de entrada es un puntero void* ( 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 qsort siempre permanece igual, independientemente del tipo de datos. Lo único que tiene que cambiar es la función de comparación, que difiere del tipo de datos al tipo de datos. qsort por lo tanto, espera que el usuario proporcione dicha función de comparación como un argumento de función.

La encapsulación y la abstracción van de la mano hasta el punto de que pueden ser realmente inseparables. Para propósitos 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 me costaría encontrar algo como esto en un código real: la abstracción casi siempre usa encapsulación. Sin embargo, lo anterior realmente existe en C ++ (14), a través de plantillas de variables (= plantillas genéricas para variables); con una sintaxis ligeramente más compleja, por ejemplo:

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

Muchas respuestas y sus ejemplos son engañosas.

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

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

Encapsulamiento: - Información oculta .
Abstracción: - Ocultación de la implementación .

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 la clase foo está oculta fuera de la clase. -> Encapsulamiento.
Cualquier miembro accesible (datos / función) de un objeto de foo está restringido y solo este objeto puede acceder a él.

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

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

Otro ejemplo:

Supongamos que he creado 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 el ancho y la altura (el acceso está restringido de alguna manera), pero no he abstraído nada (bueno, tal vez haya ignorado dónde se encuentra el rectángulo en el espacio de coordenadas, pero esto es un defecto del ejemplo).

La buena abstracción suele implicar 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 tu ves También hay encapsulación allí, porque la clase debe tener todos los manejadores de bajo nivel y las llamadas internas.

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

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

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

la abstracción de plano 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 instrumento
billetera
bolso
cápsula
carbonita congelada
una caja, con o sin botón en ella
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 "cosas que contienen abstracción de 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 cesta, por ejemplo, es un contenedor que no encapsula su contenido.

AbstractionEs un contrato para la implementación que vamos a hacer. La implementación puede cambiar a lo largo del tiempo. Las diversas implementaciones pueden estar ocultas o no, pero están enmascaradas detrás de la Abstracción.

Supongamos que definimos todo lo APIsde una clase en un lugar y interfaceluego pedimos a los usuarios de nuestro código que dependan de lo definido APIsen interface. Somos libres de mejorar o modificar la implementación solo debemos seguir el contrato establecido. Los usuarios no están acoplados con nuestra implementación.

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

Encapsulationsimplemente está OCULTANDO los detalles internos al reducir el acceso de los estados y comportamientos. Una clase encapsulada puede o no estar bien definida Abstraction.

java.util.ListEs una abstracción para java.util.ArrayList. El estado interno de java.util.ArrayListestar marcado con non publicmodificadores 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 APIs se convierten en el contract. Ese sistema puede o no estar desarrollado aún. Los usuarios del sistema ahora pueden depender de las API declaradas y están seguros de que cualquier sistema que implemente un contrato de este tipo siempre se adherirá a las API declaradas, siempre proporcionará la implementación de estas API. Una vez que estamos escribiendo una entidad concreta, luego decidir esconder nuestros estados internos es encapsulación

Encapsulation significa ocultar datos como usar getter y setter, etc.

Abstraction significa ocultar la implementación utilizando clases abstractas e interfaces, etc.

Abstracción: Abstracción significa mostrar What parte de la funcionalidad.

Encapsulación: Encapsulación significa ocultar la parte de How 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); } }

Abstracción: La idea de presentar algo de una manera simplificada / diferente, que sea 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 ... usa la abstracción para mostrarse a usted como una especie de mensajero, por lo que puede llamar a emailSender.send (correo, destinatario). Lo que realmente hace: elige POP3 / SMTP, servidores de llamadas, traducción MIME, etc., se abstrae. Sólo ves a tu mensajero.

Encapsulación: la idea de proteger y ocultar datos y métodos que son privados para 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 es necesario que sepas qué es, y probablemente no te importe.

Mira a tu alrededor y verá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 tomar lo que dice y decirlo a otra persona: cubrir GSM, la arquitectura del procesador, las frecuencias de radio y un millón de otras cosas que no entiende o no le interesan. También encapsula ciertos datos de usted, como números de serie, números de identificación, frecuencias, etc.

Todo hace que el mundo sea un lugar mejor para vivir: D

Abstracción: Sólo 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 una clase y, por lo tanto, de privatizar parte de ella. Es una forma de mantener cierta información privada para sus clientes al no permitir el acceso desde el exterior.

Encapsulación (datos y código de unión)

La encapsulación es el mecanismo que une el código y los datos que manipula, y mantiene ambos a salvo de interferencias externas y mal uso.
En un lenguaje orientado a objetos, el código y los datos se pueden combinar de tal manera que se cree una "caja negra" autocontenida. Cuando el código y los datos se vinculan de esta manera, se crea un objeto. En otras palabras, un objeto es el dispositivo que admite la encapsulación.
La encapsulación lleva al concepto de ocultación de datos, pero el concepto de encapsulación no debe restringirse a la ocultación de información.
La encapsulación representa claramente la capacidad de agrupar datos relacionados y funcionalidad dentro de una sola entidad autónoma llamada clase.

Abstracción (ocultar cómo se almacenan los datos y ocultar cómo se implementa la función)

La abstracción de datos es un proceso de representación de las características esenciales sin incluir detalles de implementación.
La abstracción es una de las características más poderosas y vitales de la programación orientada a objetos.
La idea principal detrás de la abstracción de datos es dar una clara separación entre las propiedades del tipo de datos y los detalles de implementación asociados. Esta separación se logra para que las propiedades del tipo de datos abstractos sean visibles para la interfaz de usuario y los detalles de la implementación estén ocultos.
La abstracción es separar las propiedades lógicas de los detalles de implementación. Por ejemplo, conducir el auto es una propiedad lógica y el diseño del motor es el detalle de la implementación.

Encapsulación : oculta los detalles de implementación no deseados / no esperados / 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**

La encapsulación oculta los detalles de la implementación que pueden o no ser 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 y ocultación de información por Edward V. Berard de la Agencia de Objetos.

El siguiente párrafo me ayudó a entender cómo se diferencian 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 los datos es un mecanismo para exponer solo las interfaces y ocultar los detalles de implementación del usuario.

Puedes leer más here .

Trataré de demostrar la encapsulación de una manera sencilla .. Veamos ..

El cierre 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 -

Ocultando la complejidad,
Enlace de datos y función juntos,
Haciendo el Método Complicado Privado,
Haciendo privado la instancia de instancia,
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 para agregarlos a una base de datos".

Al observar 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 de Cliente y el Nombre del Cliente.
1 Función para agregar el código de cliente y el nombre del cliente a la base de datos.
namespace CustomerContent {public class Customer {public string CustomerCode = ""; cadena pública CustomerName = ""; public void ADD () {// mi código de base de datos irá aquí}

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

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

Necesitaremos el código de conexión a 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 hay necesidad de mostrar los Métodos Extra (Validate (); CreateDBObject () [Complicated and Extra method]) al Usuario Final. El usuario final solo necesita ver y conocer el Código de Cliente, el Nombre del Cliente y el botón AÑADIR que agregará el registro. El usuario final no se preocupa por ¿CÓMO AGREGARÁ los datos a la base de datos?

Paso -3: Privar los métodos adicionales y complicados que no involucran la interacción del usuario final.

Así que convierta esos métodos Complicados y Extra como Privados en lugar de Públicos (es decir, Ocultando esos métodos) y borre el obj.Validate (); obj.CreateDBObject (); Desde el programa principal en clase conseguimos la encapsulación.

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

Así que ahora el código se ve como abajo:

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 la abstracción.

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

PS - El código de arriba es duro y rápido.

De this

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). La encapsulación y la abstracción son términos interrelacionados.

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

Encapsular significa ocultar. La encapsulación también se conoce como ocultación de datos. Se puede pensar en la encapsulación como una cápsula (tableta de medicina) que oculta la medicina en su interior. La encapsulación está envolviendo, simplemente ocultando propiedades y métodos. La encapsulación se utiliza 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 para el usuario deseado. Como su nombre lo indica, la abstracción es la "forma abstracta de cualquier cosa". Usamos la abstracción en lenguajes de programación para hacer clases abstractas. 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

La abstracción se implementa mediante la interfaz y la clase abstracta, mientras que la encapsulación se implementa utilizando un modificador de acceso privado y protegido.
OOPS hace uso de la encapsulación para imponer la integridad de un tipo (es decir, para asegurarse de que los datos se utilicen de una manera adecuada) impidiendo que los programadores accedan a los datos de manera no intencionada. 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.

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

Una interfaz generada a través de la encapsulación oculta los detalles de la implementación.

Una interfaz generada a través de la abstracción se vuelve aplicable a más tipos de datos, en comparación con la abstracción anterior.

La ocultación de información no es estrictamente necesaria para la abstracción o 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, aunque 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 diferentes partes de esa silla, cada una con un diseño y función específicos, que se ajustan exactamente con el propósito de sostener cómodamente mi trasero unos pocos pies. lejos del piso

La abstracción es habilitada por encapsulación. Debido a que encapsulamos los objetos, podemos pensar en ellos como cosas que se relacionan entre sí de alguna manera, en lugar de enredarnos en los detalles sutiles de la estructura interna del objeto. La abstracción es la capacidad de considerar el panorama general, eliminado 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.

Honestamente puedo decir que cuando coloco mi trasero en mi silla, nunca pienso en cómo la estructura de esa silla agarra y sostiene mi peso. Es una silla lo suficientemente decente como para no tener que preocuparme por esos detalles. Así que puedo dirigir mi atención hacia mi computadora. Y de nuevo, no pienso en las partes componentes de mi computadora. Solo estoy viendo una parte de una página web que representa un área de texto que puedo escribir, y me estoy comunicando con palabras, casi sin pensar en cómo mis dedos siempre encuentran las letras correctas con tanta rapidez en el teclado, y cómo En última instancia, la conexión se realiza 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 inferiores del sistema trabajen con consistencia y precisión, tenemos atención para ahorrar más trabajo.

Se podría argumentar que la abstracción es una técnica que nos ayuda a identificar qué información específica debería ser visible y qué información debería estar oculta. La encapsulación es, entonces, la técnica para empaquetar la información de tal manera que oculte lo que se debe ocultar y haga visible lo que se pretende que sea visible.

Tomemos el ejemplo de una pila. Se podría implementar utilizando una matriz o una lista enlazada. Pero las operaciones que soporta 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 es 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 resumidos? Ahí es donde entra en juego la encapsulación. Por ejemplo, las clases en C ++ utilizan los especificadores de acceso que aseguran que se evite el acceso y la modificación accidental. Y también al hacer que las interfaces mencionadas anteriormente sean públicas, garantiza que la única forma de manipular la pila sea a través de una interfaz bien definida. En el proceso, ha acoplado los datos y el código que puede manipularlos. (No permitamos las funciones de amigo involucradas aquí).Ese es el código y los datos están unidos entre sí o unidos o encapsulados

la abstracción oculta datos no útiles de los usuarios y la encapsulación es la unión de datos en una cápsula (una clase). Creo que la encapsulación es la forma en que logramos la abstracción.

La abstracción le permite concentrarse 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 sepa el proceso detrás de él porque está encapsulado.

Déjame dar un ejemplo en C #. Supongamos que tienes 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 los caracteres del número 5 y los almacena en un objeto de cadena. El método le dice qué hace en lugar de cómo lo hace.