Abstracción Es ocultar la implementación interna y solo resaltar el conjunto de servicios. Se logra mediante el uso de la clase abstracta y las interfaces y su posterior implementación. Sólo necesariamente las características de un objeto que lo diferencia de todos los demás objetos. Solo se enfatizan los detalles importantes y el resto se suprime del usuario o lector.
Un ejemplo real de abstracción
Mediante el uso de la pantalla ATM GUI, las personas del banco destacan el conjunto de servicios que ofrece el banco sin destacar la implementación interna.
Tipos de Abstracción: Existen básicamente tres tipos de abstracción
- abstracción procedimental
- Abstracción de datos
- Abstracción de control
1. Abstracción Procedural: De la palabra misma, hay una serie de procedimientos en forma de funciones seguidas una tras otra en secuencia para lograr la abstracción a través de clases.
2. Abstracción de datos: A partir de la palabra misma, se logra la abstracción de un conjunto de datos que va describiendo un objeto.
3. Abstracción de control: la abstracción se logra al escribir el programa de tal manera que los detalles del objeto estén incluidos.
Ventajas de la abstracción:
- Los usuarios o las comunidades pueden lograr la seguridad ya que no hay puntos destacados para la implementación interna.
- La mejora será muy fácil porque sin afectar a los usuarios finales, uno puede realizar cualquier tipo de cambios en el sistema interno.
- Proporciona más flexibilidad al usuario final para usar el sistema muy fácilmente.
- Mejora la riqueza de aplicación.
Implementación de abstracción : se implementa como una clase que solo representa los rasgos importantes sin incluir detalles de fondo. Proporcionando solo los detalles necesarios y ocultando toda su implementación interna. A continuación se muestra la implementación de java de la abstracción:
Java
// Java program showing the working of abstraction
// Importing generic libraries
import java.io.*;
// Creating an abstract class
// demonstrate abstraction
abstract class Creature {
// Just providing that creatures has legs
// Hiding the number of legs
abstract void No_Of_legs();
}
// A new child class is extending
// the parent abstract class above
class Elephant extends Creature {
// Implementation of the abstract method
void No_Of_legs()
{
// Printing message of function in non abstract
// child class
System.out.println("It has four legs");
}
}
// Again a new child class is extended from parent
// Human class to override function created above
class Human extends Creature {
// Same function over-riden
public void No_Of_legs()
{
// Message printed if this function is called or
// Implementation of the abstract method
System.out.println("It has two legs");
}
}
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating human object showing the implementation
Human ob = new Human();
ob.No_Of_legs();
// Creating object of above class in main
Elephant ob1 = new Elephant();
// Calling the function in main by
// creating object of above non abstract class
ob1.No_Of_legs();
// Implementation of abstraction
}
}
It has two legs It has four legs
Ahora, saltando al segundo concepto, aunque ambos conceptos se usan para lograr la encapsulación de alguna manera, hay una diferencia elegante como se muestra a continuación:
La ocultación de datos oculta datos internos de usuarios externos. Los datos internos no deben ir directamente, ya que las personas o clases externas no pueden acceder a los datos internos directamente. Se logra mediante el uso de un especificador de acceso, un modificador privado.
Nota: El modificador recomendado para miembros de datos es privado. La principal ventaja de la ocultación de datos es la seguridad.
Muestra para ocultar datos:
cuenta de clase {
privado doble cuenta_saldo;
……..
…….
}
Aquí, el saldo de la cuenta de cada empleado, por ejemplo, es privado para los demás que trabajan en la misma organización. Ningún organismo conoce el saldo de la cuenta de nadie. En java, se logra mediante el uso de una palabra clave ‘privada’ y el proceso se denomina ocultación de datos.
Se utiliza como seguridad de modo que no se acceda a ningún dato interno sin autenticación. Un usuario final no autorizado no tendrá acceso a los datos internos. Mediante programación, podemos implementar la ocultación de datos declarando elementos de datos como privados. Ahora, para acceder a estos datos o para modificarlos, tenemos un método especial conocido como getter setter respectivamente.
Getter se usa para acceder a los datos privados y setter se usa para modificar los datos privados solo después de la autenticación. En términos simples, está ocultando datos internos de usuarios externos.
Se utiliza como seguridad de modo que no se acceda a ningún dato interno sin autenticación. Un usuario final no autorizado no tendrá acceso a los datos internos. Mediante programación, podemos implementar la ocultación de datos declarando elementos de datos como privados.
Ahora, para acceder a estos datos o para modificarlos, tenemos un método especial conocido como getter setter respectivamente .
Concepto involucrado en la ocultación de datos: getter y setter
Getter se usa para acceder a los datos privados y setter se usa para modificar los datos privados solo después de la autenticación. En términos simples, está ocultando datos internos de usuarios externos. Se utiliza como seguridad de modo que no se acceda a ningún dato interno sin autenticación. Un usuario final no autorizado no tendrá acceso a los datos internos. Mediante programación, podemos implementar la ocultación de datos declarando elementos de datos como privados. Ahora, para acceder a estos datos o para modificarlos, tenemos un método especial conocido como getter setter respectivamente.
Getter se usa para acceder a los datos privados y setter se usa para modificar los datos privados solo después de la autenticación. En términos simples, está ocultando datos internos de usuarios externos. Se utiliza como seguridad de modo que no se acceda a ningún dato interno sin autenticación. Un usuario final no autorizado no tendrá acceso a los datos internos. Mediante programación, podemos implementar la ocultación de datos declarando elementos de datos como privados.
Ahora, para acceder a estos datos o para modificarlos, tenemos un método especial conocido como getter setter respectivamente. Getter se usa para acceder a los datos privados y setter se usa para modificar los datos privados solo después de la autenticación.
Implementación de la ocultación de datos:
Java
// Java Program showing working of data hiding
// Importing generic libraries
import java.io.*;
// Class created named Bank
class Bank {
// Private data (data hiding)
private long CurBalance = 0;
// Bank_id is checked for authentication
long bank_id;
String name;
// Getter function to modify private data
public long get_balance(long Id)
{
// Checking whether the user is
// authorised or unauthorised
// Comparing bank_id of user and the give Id
// then only it will get access
if (this.bank_id == Id) {
// Return current balance
return CurBalance;
}
// Unauthorised user
return -1;
}
// Setter function
public void set_balance(long balance, long Id)
{
// Comparing bank_id of user and the give Id
// then only it will get access
if (this.bank_id == Id) {
// Update balance in current ID
CurBalance = CurBalance + balance;
}
}
}
// Another class created- Employee
public class Emp {
public static void main(String[] args)
{
// Creating employee object of bank type
Bank _emp = new Bank();
// Assigning employee object values
_emp.bank_id = 12345;
_emp.name = "Roshan";
// _emp.get_balance(123456)
_emp.set_balance(10000, 12345);
// This will no get access as bank_id is given wrong
// so
// unauthorised user is not getting access that is
// data hiding
long emp_balance = _emp.get_balance(12345);
// As this time it is valid user it will get access
// Display commands
System.out.println("User Name"
+ " " + _emp.name);
System.out.println("Bank_ID"
+ " " + _emp.bank_id);
System.out.println("Current Balance"
+ " " + emp_balance);
}
}
Producción:
User Name Roshan Bank_ID 12345 Current Balance 10000
Publicación traducida automáticamente
Artículo escrito por techwithintechtofar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA