La Encapsulacion es una clase en la cual contiene unos atributos privados y unos metodos en el cual nos los agrupa en un solo objeto. Es como si tuvieses un remolque y dentro todo el contenido en uno. Por tanto, cuando necesite el remolque, simplemente lo tengo que trasladar a donde me convenga.
Imaginemos que quiero crear una clase encapsulada de un cliente, su sintaxis seria la siguiente:
public class Clientes{
private String nombre;
private int edad;
public Clientes(String nombre, int edad){
this.nombre = nombre;
this.edad = edad;
}
public String getNombre(){
return nombre;
}
public void setNombre(String nombre){
this.nombre = nombre;
}
public int getEdad(){
return edad;
}
public void setEdad(int edad){
this.edad = edad;
}
}
El codigo es siempre el mismo para crear clases encapsuladas, en el cual creamos atributos privados, creamos su constructor y por ultimo creamos sus metodos get/set, encargados de la lectura y escritura sobre los atributos.
Imaginemos que, al igual que en el capitulo 26 tratamos las Colecciones, en particular los ArrayList, podiamos agregar a las listas tipos de datos como Strings, Integer, Doubles, etc... Ahora en este caso, vamos a agregar a la lista "Objetos", ¿y cual sera el objeto?, pues nuestra clase encapsulada.
Cuando en el ArrayList de tipo generico String, solo podiamos ingresar nombres, ahora con los Objetos podremos ingresar nombres y su respectiva edad.
Vamos a coger como ejemplo la clase encapsulada anterior, la de Clientes y vamos a hacer un ejercicio.
Creamos una clase encapsulada que se llamara "Clientes" y es la siguiente:
public class Clientes{
private String nombre;
private int edad;
public Clientes(String nombre, int edad){
this.nombre = nombre;
this.edad = edad;
}
public String getNombre(){
return nombre;
}
public void setNombre(String nombre){
this.nombre = nombre;
}
public int getEdad(){
return edad;
}
public void setEdad(int edad){
this.edad = edad;
}
}
Ahora vamos a crear otra clase llamada "Principal" y con su respectivo "main", quedara asi:
import java.util.*;
public class Principal {
public static void main(String[]args) {
// Fijate como ahora en vez de String o Integer es un Objeto Clientes
ArrayList<Clientes>lista = new ArrayList<Clientes>();
Scanner scan = new Scanner(System.in);
int opcion;
do {
System.out.println("1. Nuevo cliente");
System.out.println("2. Ver clientes");
System.out.println("3. Salir");
System.out.print("Elige una opcion>> ");
opcion = scan.nextInt();
String nombre;
Integer edad;
switch(opcion) {
case 1:
System.out.print("Introduce el nombre>> ");
nombre = scan.next();
System.out.print("Introduce la edad>> ");
edad = scan.nextInt();
Clientes cl = new Clientes(nombre, edad);
agregarClientes(cl, lista);
break;
case 2:
mostrarClientes(lista);
break;
case 3:
System.out.println("Has salido de la aplicacion");
break;
}
}while(opcion!=3);
}
public static void agregarClientes(Clientes cl, ArrayList<Clientes>lista) {
lista.add(cl);
}
public static void mostrarClientes(ArrayList<Clientes>lista) {
Iterator it = lista.listIterator();
while(it.hasNext()) {
Clientes cls = (Clientes)it.next();
System.out.println(cls.getNombre()+" edad: "+cls.getEdad());
}
}
}
En este caso, al contrario que en el capitulo anterior, nos permite ingresar un nombre de cliente y su respectiva edad, esto se guarda en el ArrayList que esta vinculada al Objeto "Clientes" que es la clase encapsulada, ahi es donde tenemos los atributos "nombre y edad".
En el "case 1", creamos dos variables "nombre y edad" y luego instanciamos la clase "Clientes" que vinculara en su constructor las variables "nombre y edad", a esta instancia la hemos llamado "cl".
Ahora en el metodo, ponemos en su parametro el Obteto "cl" y nuestra ArrayList, que quedara vinculada al metodo que crearemos fuera del "main" llamado "agregarClientes", aqui añadimos a la lista el Objeto "cl" que contiene los dos atributos.
En el "case 2", simplemente creamos el metodo que vincula el ArrayList. Luego fuera del "main" con el metodo "mostrarClientes", hacemos un Iterator. ¿Que es esto?, el Iterator nos permite hacer un recorrido por todo el ArrayList.
Entonces instanciamos un Iterator llamado "it", este crea un objeto de la "lista" ayudandonos del metodo "listIterator".
Ahora ponemos un ciclo "While" y en su parametro decimos "Si en el objeto "it" hay elementos..." y dentro del ciclo creamos una instancia de la clase Clientes llamandola "cls" que nos indicara que pase al siguiente elemento, (siempre que hayan elementos).
Luego con nuestro objeto creado "cls" podemos llamar a los elementos con los gets, por ejemplo, "cls.getNombre".
Ya se que al principio es un poco confuso, pero lo que tienes que hacer, es crear tus propios ejemplos una y otra vez utilizando estos metodos, al final, de hacerlo tantas veces, comprenderas su funcionamiento.
Por ejemplo, haz tu programita, pero en vez de Clientes que sean Trabajadores y ponle mas atributos como "nombre, apellido, edad, estado, etc..."
