3. Caso de Estudio Nº 1: Un Club Social

Se quiere construir una aplicación para manejar la información de socios de un club. El club maneja dos tipos de suscripciones de socios: Regular o VIP. El número máximo de socios VIP que maneja el club es 3. Además de los socios, al club pueden ingresar personas autorizadas por éstos, que hayan sido registradas con anterioridad. Tanto los socios como las personas autorizadas pueden realizar consumos en los restaurantes del club. Cada socio está identificado con su nombre y su cédula. No puede haber dos socios con la misma cédula. Cuando un socio se afilia al club debe hacerlo con un fondo inicial (para pagar sus propios consumos y los de sus personas autorizadas) según el tipo de suscripción que tenga. Los socios regulares deben afiliarse con un fondo inicial de $50.000 y los socios VIP con $100.000. Los socios pueden aumentar sus fondos en cualquier momento, pero tienen una restricción máxima, que también depende de su tipo de suscripción, de la siguiente manera: regulares $1´000.000 y VIP $5´000.000. Para que un socio pueda añadir personas autorizadas a su lista, debe contar con fondos.

Una persona autorizada por un socio se identifica únicamente por su nombre. Cuando un socio (o una persona autorizada por él) realiza un consumo en el club, se crea una factura que es cargada a la cuenta del socio. Cada factura tiene un concepto que describe el consumo, el valor de lo consumido y el nombre de quien lo hizo. Para hacer un consumo, el socio debe contar con fondos suficientes para pagarlo. El club guarda las facturas y permite que en cualquier momento el socio vaya y cancele cualquiera de ellas. Una factura sólo puede ser pagada si el socio cuenta con fondos suficientes para hacerlo. Al pagar la factura, esta es eliminada de la lista de facturas por pagar del socio y se descuenta el valor de los fondos del socio.

La interfaz de usuario que se diseñó para este ejemplo se muestra en la figura 4.2. Esta interfaz tiene varios botones para que el usuario pueda seleccionar los distintos servicios de la aplicación.

Fig. 4.2 Diseño de la interfaz de usuario para el caso de estudio del club

• El botón "Afiliar socio" permite afiliar a un nuevo socio al club.
• El botón "Agregar autorizado" permite registrar las personas autorizadas por un socio.
• El botón "Registrar consumo" permite crear una nueva factura para un socio.
• A la derecha de la ventana aparece la lista de todas las facturas pendientes por pagar que tiene el socio. Para cada factura se indica el concepto del consumo, el valor y la persona que lo realizó.
• Seleccionando una de las facturas de la lista y oprimiendo el botón "Pagar factura", ésta se da por cancelada.

3.1. Comprensión de los Requerimientos

La primera tarea de este nivel consiste en la identificación y especificación de los requerimientos funcionales del problema.

Tarea 1

Objetivo: Describir los requerimientos funcionales del caso de estudio.

Para el caso de estudio del club, complete la siguiente tabla con la especificación de los requerimientos funcionales.

Requerimiento funcional 1

Requerimiento funcional 2

Requerimiento funcional 3

Nombre	R3 - Afiliar un socio al club.
Resumen
Entradas
Resultado

Requerimiento funcional 4

Nombre	R4 - Registrar un consumo.
Resumen
Entradas
Resultado

Requerimiento funcional 5

Nombre	R5 - Aumentar los fondos de la cuenta de un socio.
Resumen
Entradas
Resultado

3.2. Comprensión del Mundo del Problema

En la figura 4.3 aparece el modelo conceptual del caso de estudio. Allí podemos identificar las entidades del problema:

• El club social.
• Los socios afiliados al club.
• Las personas autorizadas por el socio.
• Las facturas de los consumos de un socio y de sus autorizados.

Fig. 4.3 Modelo conceptual del caso de estudio del club

3.3. Definición de la Arquitectura

La solución de este caso de estudio la dividimos en tres subproblemas, de acuerdo con la arquitectura presentada en el nivel 1. La solución de cada uno de los componentes del programa (modelo del mundo, interfaz de usuario y pruebas) va expresada como un conjunto de clases, en un paquete distinto, tal como se muestra en la figura 4.4.

Fig. 4.4 Arquitectura de paquetes para el caso del club

En este nivel vamos a trabajar únicamente en las clases que corresponden al paquete que implementa el modelo del mundo. En el nivel 5, veremos la manera de construir las clases del paquete que implementa la interfaz de usuario.

3.4. Declaración de las Clases

En esta sección presentamos las principales decisiones de modelado de los atributos y las asociaciones, mostrando las declaraciones en Java de las tres clases del modelo del mundo (Club, Socio, Factura). La definición de los métodos se hará a lo largo del nivel, ya que éste es el tema central de esta parte del libro.

public class Club
{

    // -----------------------------------------------------------------
    // Constantes
    // -----------------------------------------------------------------

    /**
     * Cantidad máxima de socios VIP que acepta el club.
     */
    public final static int MAXIMO_VIP = 3;

    // -----------------------------------------------------------------
    // Atributos
    // -----------------------------------------------------------------
    /**
     * Lista de socios del club.
     */
    private ArrayList<Socio> socios;
}

• A partir del diagrama de clases, vemos que hay una asociación de cardinalidad variable entre la clase Club y la clase Socio.
• Esta asociación representa el grupo de socios afiliados al club, que modelaremos como un vector (una contenedora de tamaño variable).

public class Socio
{
    // -----------------------------------------------------------------
    // Enumeraciones
    // -----------------------------------------------------------------

    /**
     * Enumeraciones para los tipos de suscripción.
     */
    public enum Tipo
    {
        /**
         * Representa el socio VIP.
         */
        VIP,
        /**
         * Representa el socio regular.
         */
        REGULAR
    }
    // -----------------------------------------------------------------
    // Constantes
    // -----------------------------------------------------------------

    /**
     * Dinero base con el que empiezan todos los socios regulares.
     */
    public final static double FONDOS_INICIALES_REGULARES = 50000;

    /**
     * Dinero base con el que empiezan todos los socios VIP.
     */
    public final static double FONDOS_INICIALES_VIP = 100000;

    /**
     * Dinero máximo que puede tener un socio regular en sus fondos.
     */
    public final static double MONTO_MAXIMO_REGULARES = 1000000;

    /**
     * Dinero máximo que puede tener un socio VIP en sus fondos.
     */
    public final static double MONTO_MAXIMO_VIP = 5000000;

    // -----------------------------------------------------------------
    // Atributos
    // -----------------------------------------------------------------

    /**
     * Cédula del socio.
     */
    private String cedula;

    /**
     * Nombre del socio.
     */
    private String nombre;

    /**
     * Dinero que el socio tiene disponible.
     */
    private double fondos;

    /**
     * Tipo de subscripción del socio.
     */
    private Tipo tipoSubscripcion;

    /**
     * Facturas que tiene por pagar el socio.
     */
    private ArrayList<Factura> facturas;

    /**
     * Nombres de las personas autorizadas para este socio.
     */
    private ArrayList<String> autorizados;
}

• Un socio tiene una cédula y un nombre, los cuales se declaran como atributos de la clase String.
• El dinero disponible que tiene un socio para pagar sus consumos se declara mediante el atributo fondos de tipo double.
• Los posibles valores que puede tomar el tipo de suscripción se modela a través de una enumeración llamada Tipo, cuyos posibles valores son VIP o REGULAR.
• Para representar las personas autorizadas por el socio, utilizaremos un vector de cadenas de caracteres (autorizados), en donde almacenaremos únicamente sus nombres.
• Para guardar las facturas pendientes del socio, tendremos un segundo vector (facturas), cuyos elementos serán objetos de la clase Factura.

public class Factura
{
    // -----------------------------------------------------------------
    // Atributos
    // -----------------------------------------------------------------
    /**
     * Es la descripción del consumo que generó esta factura.
     */
    private String concepto;

    /**
     * Es el valor del consumo que generó la factura.
     */
    private double valor;

    /**
     * Nombre de la persona que hizo el consumo que generó la factura.
     */
    private String nombre;
}