Diferencia entre abstracción y encapsulación en Java con ejemplos

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

Abstracción en Java

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