sábado, 10 de noviembre de 2012

El Patrón Estrategia en Java

Este proyecto fue guiado por el patrón de diseño Strategy Pattern para su estructura, junto a librerías que dan apoyo para su realización tales como el sonido y el LookAndFeel. No vamos a explicar el proyecto pero si explicaremos la parte esencial del proyecto, que es este patrón de diseño. El patrón de diseño Strategy se guían con los siguientes pasos:
  • Separar los datos que cambiaran de valor en un futuro. Ya que en una empresa todo cambia o muere al no hacerlo. Ya sea por mejoramiento, innovación, etc. Siempre esta destinada a cambiar y nada mejor que un patrón de diseño que aguante el cambio.
  • Programar para una interfaz no una implementación. En pocas palabras (Herencia no siempre es la respuesta) ya que si se seguían en Herencia siempre estarás cambiando el dato.
Para mayor entendimiento es mejor si aplicamos un pequeño ejemplo. Supongamos que trabajamos para una empresa de aplicaciones educativas y recibimos una llamada para la realización de una aplicacion de lecciones de Guitarra. En este caso no queremos abundar con clases de guitarras ya que solo se quiere tomar una leccion con una sola clase de guitarra. Lo primero que se nos podría ocurrir es crear una clase Padre llamada Tonos y que todos los tonos hereden de este y aquí es donde empiezan notar los 2 pasos antes mencionados. Cualquier subclase de la clase Tonos estarían reusando los métodos, pero cuando aparecen casos por ejemplo: los tonos Do,Re,Mi,Fa,Sol,La,Si; cada subclase de tonos no siempre debe de reusar los metodos ya que hay casos en donde no son necesarios reusarlos ya sea por diferentes comportamientos que este realiza.
abstract class Tonos {

    public abstract void doMayor();

    public abstract void doMenor();
}

class DOMayor extends Tonos {

    public void doMayor() {
        System.out.println(" Esta posicion es doMayor ");
    }
}
Pero si haces esto es probable que vuelvas a recibir una llamada de quejas, ya que esto no es muy flexible a cambios ya que habran mas cambios en el futuro, mas tonos con posiciones diferentes, etc. Siguiendo el paso 1 descrito al incio, debemos pensar sobre los comportamientos que podrían variar en un futuro. Para este ejemplo podríamos mencionar Domayor,Domenor,DoBemol, Do sostenido, Do septimo, etc. Y luego. Siguiendo el paso 2. Haríamos un conjunto de comportamientos programando para una interfaz. Esto nos quedaría del siguiente modo:

public interface Chords {

    public abstract void position(List<List<JLabel>> cuerda);

    public abstract String chordName();
}
//-----------------COMPORTAMIENTOS--------------//
package Chords.C;

import ChordsBehavior.Chords;
import java.util.List;




import javax.swing.JLabel;
       //Este comportamiento es del tono C mayor
public class C_Mayor implements Chords {

    List<List<JLabel>> cuerdas;

    public void position(List<List<JLabel>> cuerda) {    //Posicion del Tono en los acordes
        this.cuerdas = cuerda;
        cuerda.get(0).get(1).setVisible(true);     //traste 0(1) cuerda 1(2);
        cuerda.get(1).get(3).setVisible(true);   // traste 1(2)cuerda 3(4);
        cuerda.get(2).get(4).setVisible(true);   // traste 2(3) cuerda 4(5);
    }

    public String chordName() {
        return "C Mayor";
    }
}

// Nota:   No creamos una clase Abstracta ya que la parte de la vista extiende de Jframe 
//-----------------Vista-----------------------------//
public class GuitarApp extends javax.swing.JFrame implements BasicPlayerListener {

    Chords c = null;
    List<List<JLabel>> cuerda = null;     //una lista de listas 

    private void cMayorActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cMayorActionPerformed
        try {
            cMinor.setSelected(false);
            cSharp.setSelected(false);
            c7.setSelected(false);
            this.emptyTrast();

            c = new C_Mayor();
            c.position(cuerda);  //pasamos la lista de listas para las posiciones de la cuerda y el traste para la colocacion de la posicion de este acorde cuyo comportamiento es DO_MAYOR

            if (!muteBox.isSelected()) {
                file = getClass().getResource("/note_sound/DoMayor.mp3");

                File a = new File(file.toURI());
                jf.setSelectedFile(a);
                a = jf.getSelectedFile();
                System.out.println(a.getName());
                loadFile(a);
                play();
            }



            for (int i = 0; i <= 3; i++) {

                this.d_Chords().get(i).setSelected(false);
                this.e_Chords().get(i).setSelected(false);
                this.f_Chords().get(i).setSelected(false);
                this.g_Chords().get(i).setSelected(false);
                this.a_Chords().get(i).setSelected(false);
                this.b_Chords().get(i).setSelected(false);
            }
        } catch (BasicPlayerException ex) {
            Logger.getLogger(GuitarApp.class.getName()).log(Level.SEVERE, null, ex);
        } catch (URISyntaxException ex) {
            Logger.getLogger(GuitarApp.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
}
Para este proyecto se siguió esta estructura, en donde el dato que variaría serían los tonos ya que hay un sin numero de tonos y cada clase de tono tiene una posición distinta y sonido distinto. El proyecto se encuentra disponible para su descarga en el siguiente enlace:

Descargar

Y también les dejo un screenshot del proyecto :

Figura 1. Aplicación de lecciones de Guitarra desarrollado en Java utilizando el Patrón Estrategia
Espero este post les sea de utilidad y quiero hacer un agradecimiento al autor del mismo, mi amigo Roliver Javier Rodriguez quien nos envió su aporte desde Santo Domingo. Saludos y hasta una próxima oportunidad.

0 comentarios:

Publicar un comentario