El encapsulamiento implica mantener las propiedades de una clase como privadas y proveer métodos públicos como getters y setters para acceder y modificar las propiedades. Esto permite controlar el acceso y cambios a las propiedades, agregando validaciones. Una clase abstracta no puede ser instanciada directamente, sino que define métodos abstractos que deben implementarse en clases hijas concretas.

1. Encapsulamiento
De manera general, se hace teniendo las propiedades como privadas y métodos
que la controlan públicos. Comúnmente, se crean un grupo de métodos llamados
getters (se encargan de obtener el valor de la propiedad) y setters (se encargan de
setearla).
Mantener las clases con el principio de encapsulamiento nos permite controlar el
cambio de valor que pueda producirse en ellas añadiendo validaciones. De
cualquier manera, es una convención dentro de la programación orientada a
objetos, aunque no se esté realizando una operación adicional al cambio de valor.
Veamos un ejemplo:
Public class Gato {
public String nombre;
public int patas;
}
//Mi método main...
Gato g = new Gato();
g.nombre = "Nemo";
g.patas = 4;
System.out.println("Mi gato se llama: " + g.nombre);
System.out.println("El número de patas de mi gato es: " + g.patas);
En este caso, no se ha aplicado el principio de encapsulamiento, puede cambiar las
propiedades del mismo tan sólo con acceder a ellas, de manera muy simple.
Veamos la misma clase, con el principio de encapsulamiento
public class Gato {
private String nombre;
private int patas;
public getNombre(){ return nombre;}
public getPatas(){ return patas;}
public setNombre(String nuevoNombre){ nombre = nuevoNombre;}
public setPatas(int numeroPatas){ patas = numeroPatas;}
}
//Mi método main...
Gato g = new Gato();
g.setNombre("Nemo");
g.setPatas(3);
System.out.println("Mi gato se llama: " + g.getNombre());
System.out.println("El número de patas de mi gato es: " +
g.getPatas());
Tras aplicar el principio de encapsulamiento, ya no tenemos acceso a las
propiedades directamente, por lo que tenemos que usar los métodos (que son
públicos y sí tenemos acceso a ellos) para poder acceder a las variables, tanto para
modificarlas como para obtenerlas. El comportamiento es el mismo, aunque lleve
un código adicional

2. Abstracción
Una clase abstracta es una superclase (clase principal) que no puede ser instanciada. Debe
crear una instancia de una de sus clases secundarias si desea crear un nuevo objeto. Las
clases abstractas pueden tener métodos tanto abstractos como concretos. Los métodos
abstractos contienen solo la firma del método, mientras que los métodos concretos
también declaran un cuerpo del método. Las clases abstractas se definen con la abstract
palabra clave.
En el siguiente ejemplo, puede ver una clase abstracta llamada Animal con dos métodos
abstractos y uno concreto.
abstract class Animal {
// abstract methods
abstract void move();
abstract void eat();
// concrete method
void label() {
System.out.println("Animal's data:");
}
}
Amplíe la clase Animalclase abstracta con dos clases secundarias: Birdy Fish. Ambos
establecieron su propia funcionalidad para las move()y eat()abstractos métodos.
class Bird extends Animal {
void move() {
System.out.println("Moves by flying.");
}
void eat() {
System.out.println("Eats birdfood.");
}
}
class Fish extends Animal {
void move() {
System.out.println("Moves by swimming.");
}
void eat() {
System.out.println("Eats seafood.");
}
}
Ahora, vemos con las clases TestBirdy TestFish. Ambos llaman al método concreto ( label())
y los dos métodos abstractos ( move()y eat()).
class TestBird {
public static void main(String[] args) {
Animal myBird = new Bird();
myBird.label();
myBird.move();
myBird.eat();
}
}
class TestFish {
public static void main(String[] args) {
Animal myFish = new Fish();

3. myFish.label();
myFish.move();
myFish.eat();
}
}
En la consola, el método concreto ha sido llamado desde la clase Animalclase abstracta,
mientras que los dos métodos abstractos han sido llamados desde Bird()y Fish(),
respectivamente.
[Console output of TestBird]
Animal's data:
Moves by flying.
Eats birdfood.
[Console output of TestFish]
Animal's data:
Moves by swimming.
Eats seafood.