Primer proyecto

En este artículo vamos a implementar los conocimientos básicos en Java, y como siempre, la mejor manera de aprender, es practicando, manos a la obra!

Descripción

Vamos a simular un "sistema" de seguros de vida. No utilizaremos por el momento bases de datos. Será una aplicación sencilla en la que se pueda apreciar la herencia, polimorfismo, abstracción, etc. Vamos a implementar la teoría.

Características

El sistema, en una PRIMERA ETAPA debe cumplir con los siguientes requisitos:

• Debe ejecutarse por consola (sin interfaz gráfica de usuario).
• Mantenimiento de clientes (agregar, editar, dar de baja).
• Mantenimiento de seguros (agregar, editar, cancelar).
• Los seguros están clasificados por tipo: de vida, de accidentes, etc.
• Los clientes pagan cuotas para el seguro.
• Búsqueda de clientes.
• Búsqueda de seguros, por tipo.
• Un cliente puede tener más de un seguro, pero no del mismo tipo.
• Listar seguros de un cliente.
• Listar las cuotas pagadas del cliente por seguro y el total.
• Listar todos los pagos del cliente y el total, con una descripción del pago.

¿Todo esto? en realidad, para los sistemas actuales, esto es poco. Los clientes piden muchas hojas de requerimientos. Pero esto sirve muy bien para comenzar, cuando lo terminemos implementaremos GUI (Interfaz Gráfica de Usuario) es decir, bonotes, cajas de texto, lo típico usando la interfaz Swing, y si me animo usaremos JavaFX :).

Comenzando

En primer lugar vamos a definir una estructura de 2 paquetes:

• clases: En este paquete vamos a tener las clases que necesitaremos en este proyecto como Cliente, Seguro, Cuota, etc. Digamos que son las clases que son fundamentalmente parte de la lógica.
• usuario: Acá vamos a tener todas las clases que interactúan con el usuario. Esto es, todas las clases que permiten el ingreso y la salida de datos. (Incluyendo la clase Main).

Como pueden apreciar en la imagen, mi proyecto tiene por nombre "SegurosMusux".

Cliente

Para comenzar, en el paquete clases, agregaremos un archivo llamado Cliente.java:

package clases;

public class Cliente {
    
    private String nombre;
    private String dni;
    private int nac_año;
    private String estadoCivil;
    private float sueldoMensual;
}

Esos son los campos que vamos a necesitar del cliente por ahora. La palabra reservada private la utilizamos para indicar que no se podrá acceder a estas variables desde otra clase, sólo dentro de la clase Cliente, si necesitamos almacenar los datos desde otra clase (así será) necesitamos métodos que tengan el modificador public, como buena práctica, en las clases siempre debemos tratar a los atributos como private y a los métodos como public. Y los métodos correspondientes a las variables son siempre (como buena práctica) set  y get, para guardar y obtener, respectivamente, así:

public String getNombre() {
    return this.nombre;
}

public void setNombre(String nombre){
    this.nombre = nombre;
}

Estos serían los métodos correspondientes al atributo nombre. Acá encontramos otra palabra reservada, this, esta palabra hace referencia a la propia clase, en entradas anteriores habíamos comentado que para acceder a un atributo de una clase lo hacíamos a través del punto, por ejemplo: perro.raza, o persona.nombre. En este caso, this.nombre hace referencia al atributo nombre que pertenece a la clase en la que estamos, es decir, a los atributos que declaramos líneas arriba (nombre, dni, etc.).

Debemos crear los métodos set y get para cada atributo que hemos declarado:

public String getDni() {
    return dni;
}

public void setDni(String dni) {
    this.dni = dni;
}

public int getNac_año() {
    return nac_año;
}

public void setNac_año(int nac_año) {
    this.nac_año = nac_año;
}

public String getEstadoCivil() {
    return estadoCivil;
}

public void setEstadoCivil(String estadoCivil) {
    this.estadoCivil = estadoCivil;
}

public float getSueldoMensual() {
    return sueldoMensual;
}

public void setSueldoMensual(float sueldoMensual) {
    this.sueldoMensual = sueldoMensual;
}

Ahora viene un nuevo concepto, el método constructor, es un método que se ejecutará automáticamente cuando creamos (instanciamos) un objeto de la clase. En Java, el método constructor se crea utilizando el mismo nombre que la clase, y usaremos el modificador public:

public Cliente(String nombre, String dni, int nac_año, String estadoCivil, float sueldoMensual) {
    this.nombre = nombre;
    this.dni = dni;
    this.nac_año = nac_año;
    this.estadoCivil = estadoCivil;
    this.sueldoMensual = sueldoMensual;
}

Hemos creado el constructor de la clase Cliente con todos los parámetros necesarios para crear un nuevo cliente. Esto significa que cuando creemos un objeto Cliente, tendremos que pasar como parámetros todos sus atributos asi:

Ejemplo:
Cliente objCliente = new Cliente("Edder", "12345678", 1992, "Soltero", 100.0f );

Ya tenemos nuestra clase Cliente creada. Ahora vamos a seguir con el código necesario para registrar y listar clientes. Para ello necesitamos:

• Leer datos.
• Tener una lista de clientes.

Entrada

Vamos a comenzar con la Entrada de datos. Java nos ofrece unas clases que podemos utilizar para leer datos por teclado, al principio no necesitamos mucha explicación de lo que es y cómo funciona, por el momento nos interesa utilizarlo, nada más. Para comenzar, vamos a crear un archivo en el paquete usuario con el nombre Entrada.java:

package usuario;


public class Entrada {
    private static BufferedReader objEnt = new BufferedReader(new InputStreamReader(System.in));

    public static String leerString() {}
    
    public static int leerInt() {}
    
    public static byte leerByte() {}

    public static float leerFloat() {}
}

En la línea 5 (private static BufferedReader objEnt...) estamos creando un objeto de la clase BufferedReader, el cual, dentro de los métodos que nos ofrece, está el readLine(), éste nos devuelve un String, que es lo que ha ingresado el usuario por teclado. Tenemos también la palabra reservada static lo que indica que para acceder a los métodos o atributos, no necesitaremos crear un objeto. Normalmente nosotros crearíamos un objeto de la clase entrada (por ejemplo objEntrada) y para acceder al método leerString, usamos objEntrada.leerString(), pero si declaramos los métodos como static no necesitaremos crear el objeto, y para acceder al método bastaría con poner el nombre de la clase así: Entrada.leerString(). Esto es muy útil cuando creamos clases generales como lo que estamos haciendo (una clase para leer datos del teclado).

Los métodos que hemos declarado son leerString(), leerInt(), leerByte() y leerFloat(). Antes de escribir el código de estos métodos, debo hablar de modo breve sobre las excepciones. En Java, una excepción es algo que sucede y que no debería haber sucedido. Por ejemplo, si nosotros le decimos a un usuario "Ingresa tu edad", y el usuario ingresa "juan", esto es un error, porque es muy seguro de que yo tenga una variable de tipo int para almacenar su edad, y de pronto el usuario escribe una cadena, ¡nuestro programa terminaría muy mal!, pero para esto Java tiene excepciones, esto significa que... podemos controlar los posibles errores, podemos decirle a Java: ey!, si encuentras un error de este tipo, puedes hacer esto otro. Excelente no?

Para terminar de hablar sobre las excepciones, debo decir que cuando hay una excepción tenemos dos opciones, pasar la excepción a quien llamó al método o tratarlas en el momento en que sucede la excepción, bueno aquí dejo las palabras reservadas y la estructura para capturar excepciones:

/** si pasamos la excepción a quien llamó al método
*/
public void nombreMetodo() throws [TipoExcepción] {
    //código que puede ocasionar excepciones | errores
}

/** si queremos tratar la excepción dentro del método:
*/

public void nombreMetodo() {
    try{
        //código que puede ocasionar excepciones | errores
    } catch( [Tipo de Excepción] ex) {
        //código si hubo una excepción en el bloque try
    }
}

Bueno, esta entrada terminó siendo más larga de lo que pensé, así que por aquí dejaré el código del método leerString(), e intenten implementar los otros:

public static String leerString(){
    String x = "";
    boolean flag = false;
    while(!flag){
        try{
            x = objEnt.readLine();
            flag = true;
        } catch(IOException ex){
            System.out.println("Error al ingresar la cadena, intenta de nuevo:");
        }
    }
    return x;
}

En la siguiente entrada explicaré lo que hice aquí y luego implementaremos los otros métodos de la clase Entrada, hasta la próxima, y no olviden practicar, así se aprende más rápido, y cambien cosas, no sólo copien y peguen, con curiosidad se descubren muchas más cosas que lo que alguien pueda escribir en un post :)

Comenten si tienen dudas o si encontraron algún error. Gracias.


PD:
Link del archivo: Cliente.java
No subo el proyecto aún ya que sólo hemos implementado una clase.