Diferencia entre la ocultación de datos y la abstracción en Java

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

  1. abstracción procedimental
  2. Abstracción de datos
  3. 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
    }
}
Producción

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *