La encapsulación se define como el empaquetado de datos en una sola unidad. Es el mecanismo que une el código y los datos que manipula. Otra forma de pensar en la encapsulación es que es un escudo protector que evita que el código acceda a los datos fuera de este escudo. Técnicamente, en la encapsulación, las variables o datos de una clase se ocultan de cualquier otra clase y solo se puede acceder a ellos a través de cualquier función miembro de su propia clase en la que se declaran. Al igual que en la encapsulación, los datos de una clase se ocultan de otras clases, por lo que también se conoce como ocultación de datos. La encapsulación se puede lograr declarando todas las variables de la clase como privadas y escribiendo métodos públicos en la clase para establecer y obtener los valores de las variables.
Java
// Java program to demonstrate encapsulation public class Encapsulate { // private variables declared // these can only be accessed by // public methods of class private String geekName; private int geekRoll; private int geekAge; // get method for age to access // private variable geekAge public int getAge() { return geekAge; } // get method for name to access // private variable geekName public String getName() { return geekName; } // get method for roll to access // private variable geekRoll public int getRoll() { return geekRoll; } // set method for age to access // private variable geekage public void setAge(int newAge) { geekAge = newAge; } // set method for name to access // private variable geekName public void setName(String newName) { geekName = newName; } // set method for roll to access // private variable geekRoll public void setRoll(int newRoll) { geekRoll = newRoll; } } // Class to access variables // of the class Encapsulate class TestEncapsulation { public static void main(String[] args) { Encapsulate obj = new Encapsulate(); // setting values of the variables obj.setName(" Harsh & quot;); obj.setAge(19); obj.setRoll(51); // Displaying values of the variables System.out.println("Geek's name: " + obj.getName()); System.out.println("Geek's age: " + obj.getAge()); System.out.println("Geek's roll: " + obj.getRoll()); // Direct access of geekRoll is not possible // due to encapsulation // System.out.println("Geek's roll: " + // obj.geekName); } }
Geek's name: Harsh Geek's age: 19 Geek's roll: 51
La abstracción de datos es la propiedad en virtud de la cual sólo se muestran al usuario los datos esenciales. Las unidades triviales o no esenciales no se muestran al usuario. Ej: Un automóvil se ve como un automóvil en lugar de sus componentes individuales. La abstracción de datos también se puede definir como el proceso de identificar solo las características requeridas de un objeto ignorando los detalles irrelevantes. Las propiedades y comportamientos de un objeto lo diferencian de otros objetos de tipo similar y también ayudan a clasificar/agrupar los objetos.
Java
// Java program to illustrate the concept of Abstraction abstract class Shape { String color; // these are abstract methods abstract double area(); public abstract String toString(); // abstract class can have a constructor public Shape(String color) { System.out.println("Shape constructor called"); this.color = color; } // this is a concrete method public String getColor() { return color; } } class Circle extends Shape { double radius; public Circle(String color, double radius) { // calling Shape constructor super(color); System.out.println("Circle constructor called"); this.radius = radius; } @Override double area() { return Math.PI * Math.pow(radius, 2); } @Override public String toString() { return "Circle color is " + super.color + "and area is : " + area(); } } class Rectangle extends Shape { double length; double width; public Rectangle(String color, double length, double width) { // calling Shape constructor super(color); System.out.println("Rectangle constructor called"); this.length = length; this.width = width; } @Override double area() { return length * width; } @Override public String toString() { return "Rectangle color is " + super.color + "and area is : " + area(); } } public class Test { public static void main(String[] args) { Shape s1 = new Circle("Red", 2.2); Shape s2 = new Rectangle("Yellow", 2, 4); System.out.println(s1.toString()); System.out.println(s2.toString()); } }
Shape constructor called Circle constructor called Shape constructor called Rectangle constructor called Circle color is Redand area is : 15.205308443374602 Rectangle color is Yellowand area is : 8.0
Diferencia entre abstracción y encapsulación:
Abstracción | Encapsulación |
---|---|
La abstracción es el proceso o método de obtener la información. | Mientras que la encapsulación es el proceso o método para contener la información. |
En abstracción, los problemas se resuelven a nivel de diseño o interfaz. | Durante la encapsulación, los problemas se resuelven en el nivel de implementación. |
La abstracción es el método de ocultar la información no deseada. | Mientras que la encapsulación es un método para ocultar los datos en una sola entidad o unidad junto con un método para proteger la información del exterior. |
Podemos implementar la abstracción usando interfaces y clases abstractas. | Mientras que la encapsulación se puede implementar mediante el modificador de acceso, es decir, privado, protegido y público. |
En abstracción, las complejidades de implementación se ocultan mediante clases e interfaces abstractas. | Mientras está encapsulado, los datos se ocultan mediante métodos de obtención y configuración. |
Los objetos que ayudan a realizar la abstracción están encapsulados. | Mientras que los objetos que dan como resultado la encapsulación no necesitan abstraerse. |
La abstracción proporciona acceso a una parte específica de los datos. | La encapsulación oculta los datos y el usuario no puede acceder a ellos directamente (ocultación de datos. |
El enfoque de abstracción está en «qué» se debe hacer. | El enfoque de encapsulación está en «Cómo» debe hacerse. |