Cómo utilizar el patrón de diseño Factory en un caso de ladrones de un país. Fácil y sencillo como la vida misma

Imaginemos aleatoriamente y usando la imaginación que existe un país llamado “OtrasDesvirtudes”.

En este país roban los banqueros, los políticos, los jueces y miembros de la real-desvirutd. El gobierno-desvirtud ha hecho una aplicación  (encargada al hijo del dirigente) para que puedan robar(); Los usuarios se autentifican y aparece un botón enorme “ROBAR A LOS PRINGADOS DE SIEMPRE QUE PAGAN DIGNAMENTE SUS IMPUESTOS”.

Lo que pasa! que cada uno en función de su puesto, roba de diferente forma:

– Los banqueros (altos dirigentes): piden rescate monetario para hacerse unas pensiones vitalicias de cifras orbitales para finalmente, declarar suspensión de pagos.

– Los políticos: Se quedan comisiones por asignaciones de obra, rectificar terrenos y viajes inexistentes.

– Los jueces: sobornos y viajes inexistentes.

– La real-desvirtud: crea empresas que no existen para recibir subvenciones.

Caos!!! tenemos distintos robos para distintas personas!! cómo lo haremos de forma transparente!! de forma que sea sólo “robar” y que cada uno se las apañe como mejor pueda robar.

La persona que hace la aplicación letal, se le ocurre la brillante idea, de aparte cobrarles más por facinerosos, contratar a su “amigo informático” para que le haga la aplicación de gratis.

El “amigo informático” dados sus conocimientos letales utilizar el patrón de diseño Factory. La idea aplicada a Java, sería de la siguiente forma:

Una clase abstracta RobarFactory().

public abstract class RobarFactory {

    private static int defaultFactoryType = 1;

    public static final int BANQUERO = 1;

    public static final int POLITICO = 2;

    public static final int JUEZ = 3;

    public static final int REAL-DESVIRTUD = 4;



    /**

     * Establece el tipo de factoria por defecto

     * @param type Tipo de factoria de los aceptados

     */

    public static void setDefaultFactoryType(int type){

        defaultFactoryType = type;

    }


    /**

     * Devuelve el Factory adecuado para el tipo establecido por defecto

     * @return Factory del tipo establecido

     * @throws Exception

     */

    public static RobarFactory getRobarFactoryDefault() throws Exception{

        return getRobarFactory(RobarFactoryType);

    }


    /**

     * Devuelve el Factory para el tipo indicado en el parametro type

     * @param type Tipo de Factory a utilizar

     * @return Factory del tipo indicado

     * @throws Exception

     */

    public static RobarFactory getRobarFactory(int type) throws Exception{

        DAOFactory factory = null;

        switch(type){

            case RobarFactory.BANQUERO

                factory = new BANQUEROFactory();

                break;

            case RobarFactory.POLITICO

                factory = new POLITICOFactory();

                break;

                

            default:

                throw new TAsistoException(“ERR-0003”, “No existe una factoria para el indicado: ” + type);

        }

        return factory;

    }

    


    //metodos abstractos que todas las factorias deberán implementarlos

    /**

     * Devuelve el Dinero robado

     * @return Dinero robado

     */

    public abstract Dinero robar();

Ya tenemos la factoría hecha. ¿Dudas? Con lo fácil que es robar!

Cuando se autentifican se pone setFactoryDeflautType al tipo de la persona y devolveremos su factoria con getRobarFactory(). Porque ojo! todos roban de diferente forma. Por ejemplo: se autentifica el político, se pone setFactoryDeflautType a 1 y se cargará su factoría POLITICOFactory()

Pero su función no es robar(); es robarPolítico(); lo que pasa que queremos que en la aplicación aparezca un sólo robar(), ya que el objetivo es que se unan más miembros (factorías) en el futuro y que se añadan nuevas funciones propias como estafar(), defraudarHacienda(), etc.

Así que implementamos las funciones abstractas, en este caso, robar()

/**

 *

 * @author llacarra

 */

public class POLITICOSFactory extends RobarFactory {


    /**

     * Devuelve el Robar para trabajar con usuario en una base de datos Mysql

     * @return Dinero robado

     */

   @Override

    public Dinero robar(){

        return new robarPolitico();

    }

   

   @Override

    public Dinero estafar(){

        return new estafarPolitico();

    }

Así una factoría con sus funciones por cada miembro ladrón del país. 

De esta forma. El amigo informático ha conseguido que la aplicación llame a un sólo “robar()” y que por medio de la factoría abstraiga la lógica de la función. En algún sitio, deberá estar implementada la función de estafarPolitico(), o en esta misma clase puede estar la función desarrollada.

Se puede hacer que desde la misma base de datos cargue esa configuración, de forma que dependa menos de la aplicación.

Así da igual que miembro del país acceda… que robará igualmente, fácilmente, e independientemente de su puesto.  Bravo, bravísimo!!!

Anuncios

Un comentario en “Cómo utilizar el patrón de diseño Factory en un caso de ladrones de un país. Fácil y sencillo como la vida misma

  1. Hola Laura:
    Excelente ejemplo de dicho patrón, bastante didáctico y entendible … desafortunadamente este “patrón de diseño” lo aplican bastante seguido nuestros gobernantes S.A de C.V… “La realidad supera la fantasía”… Simplemente brillante forma de abordar la programación con crítica social… Saludos.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s