Programación Orientada a Objetos y Taller

Los antipatrones de diseño son resultado de malas prácticas de programación e invariablemente conducen a una errónea solución a un problema.

Hay una gran cantidad de antipatrones. Yo me ocuparé solamente de algunos de ellos:

Gran Bola de Lodo.

· Reinventar la rueda.

· Objeto Todopoderoso.

· Código espagueti

Gran Bola de Lodo

Antipatrón de diseño de software que consiste en la realización de un programa sin una estructura clara y que por lo mismo resulta difícil de comprender. Los programadores suelen caer en esto debido a la falta de preparación en análisis y diseño de sistemas.

El principal problema al hacer una aplicación de esta forma no es que no funcione sino el mantenimiento futuro que pueda necesitar el programa.

Reinventar la rueda

Antipatrón metodológico que se refiere al hecho de resolver un problema desde cero cuando ya hay soluciones a dicho problema. El punto aquí es no esforzarte de más por algo que ya se inventó.

Objeto Todopoderoso

Antipatrón en el que un objeto se encarga de hacer todo. La idea cuando un programador trata de resolver un gran problema es dividirlo en pequeños para ir resolviéndolos uno a uno y al final manejar esto como un todo.

Código espagueti

Antipatrón muy similar al de “Gran Bola de Lodo” en el que se realiza un programa de gran extensión sin una estructura definida y que por esto resulta difícil comprender el código.

Fuentes

El patrón que estoy tratando de implementar en mi proyecto es el de Modelo-Vista-Controlador.

A modo de ejemplo tomaré la función abrir. A continuación se puede apreciar como es que divide el código para manejar el patrón MVC.

Clase Interfaz

/** Clase que maneja la vista del editor
 * 
 * 
 * 
 * 
 * */ 

import java.awt.event.*;
import javax.swing.*;
import java.awt.*;

import javax.swing.text.*;

 public class Interfaz extends JFrame{

  JMenuBar barraMenu;
  JMenu archivo;
  JMenuItem abrirFichero;
  JMenuItem guardarFichero;
  JMenuItem salir;
  JMenu edicion;
  JMenuItem cortar;
  JMenuItem copiar;
  JMenuItem pegar;
     JTextArea areaDeTexto;
  JScrollPane desplazamiento;  
  
  // Constructor de la clase Interfaz. 
  public Interfaz(){

  super("Editor ++");
  this.setSize(400,400);
  this.definir_componentes();
  this.agregar_componentes();
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  this.setVisible(true);

  }

  /** Se definen los componentes de la ventana, así como también 
   * algunas de sus características
   * 
   * 
   * */
  public void definir_componentes(){
  
  // Área de Texto
  areaDeTexto = new JTextArea();
  areaDeTexto.setLineWrap(true);
  areaDeTexto.setWrapStyleWord(true);
  desplazamiento = new JScrollPane(areaDeTexto);

  // Barra de menú y menús
  barraMenu = new JMenuBar();
  archivo = new JMenu("Archivo");
  archivo.setMnemonic(KeyEvent.VK_A);
  edicion = new JMenu("Edición");
  edicion.setMnemonic(KeyEvent.VK_E);
 
  // MenuItems
  abrirFichero = new JMenuItem(new ModeloAbrir(areaDeTexto));
  guardarFichero = new JMenuItem(new ModeloGuardar(areaDeTexto));
  salir = new JMenuItem("Salir");
  
  
  Action accionCopiar = areaDeTexto.getActionMap().get(DefaultEditorKit.copyAction);
  accionCopiar.putValue(Action.NAME,"Copiar  ");
  accionCopiar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('C',Event.CTRL_MASK));
  copiar = new JMenuItem(accionCopiar);
  
  Action accionPegar = areaDeTexto.getActionMap().get(DefaultEditorKit.pasteAction);
  accionPegar.putValue(Action.NAME,"Pegar  ");
  accionPegar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('P',Event.CTRL_MASK));
  pegar = new JMenuItem(accionPegar);
  
  
  Action accionCortar = areaDeTexto.getActionMap().get(DefaultEditorKit.cutAction);
  accionCortar.putValue(Action.NAME,"Cortar  ");
  accionCortar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('O',Event.CTRL_MASK));
  cortar = new JMenuItem(accionCortar);
  
  
  }
  
  
  /** Agrega los componentes definidos por 
   * la función definir_componentes()
   * 
   * */
  
  public void agregar_componentes(){

   barraMenu.add(archivo);
   barraMenu.add(edicion);
   archivo.add(abrirFichero);
   archivo.add(guardarFichero);
   archivo.add(salir);
   edicion.add(copiar);
   edicion.add(pegar);
   edicion.add(cortar);
   this.add(barraMenu, BorderLayout.NORTH);
   this.add(desplazamiento, BorderLayout.CENTER);

   } 
 
}

Clase ModeloAbrir

/** Clase en la que se maneja la mayor parte de la lógica de la
 *  acción abrir del menú Archivo
 * 
 * 
 * */

import java.awt.Event;
import java.io.*;
import javax.swing.*;
import javax.swing.text.*;


// Clase ModeloAbrir que hereda de la clase abstracta ControladorAbrir
public class ModeloAbrir extends ControladorAbrir {

     /** Constructor de la clase ModeloAbrir
      * 
      *
      * @param areaDeTrabajo Componente en el que se pretende mostrar el
      * contenido del archivo leído.
      */
     public ModeloAbrir(JTextComponent areaDeTrabajo)
     {
      // Se le pasa al constructor de la superclase el JTextComponent
         super(areaDeTrabajo);
         
         // Etiqueta y tecla aceleradora
         this.putValue(Action.NAME, "Abrir ...");
         this.putValue(Action.ACCELERATOR_KEY,
             KeyStroke.getAWTKeyStroke('A', Event.CTRL_MASK));
     }
     

     /**
      * Lee el archivo y coloca su contenido en el área de texto
      *
      * @param archivo Archivo a leer
      *
      * @throws FileNotFoundException Error al leer el archivo
      */
     
     @Override
     protected void logicaAbrir(File archivo)
         throws FileNotFoundException
     {
      // Se crea el objeto archivoEntrada para leer el archivo.
      // bufferLinea irá modificando su longitud al ir leyendo las lineas del
      // archivo. Al final todos esos caracteres se colocarán en el area de Texto
         BufferedReader archivoEntrada = new BufferedReader(new FileReader(archivo));
         StringBuffer bufferLinea = new StringBuffer();

         try
         {
             String linea = archivoEntrada.readLine();

             while (linea != null)
             {
              //  Se va añadiendo las líneas que se leen a la variable bufferLinea
              //  modificando cada vez la longitud de caracteres de esta variable.
              // Además se agrega un salto de línea con la instrucción 
              // System.getProperty("line.separator") la cual da mayor portabilidad
                 bufferLinea.append(linea);
                 bufferLinea.append(System.getProperty("line.separator"));
                 
                 // Siguiente linea.
                 linea = archivoEntrada.readLine();
             }
         }
         catch (IOException e)
         {
             JOptionPane.showMessageDialog(
                 areaDeTrabajo, e, "Error al leer el archivo",
                 JOptionPane.ERROR_MESSAGE);
   
         }

         // Se pone el texto leido en el JTextArea.
         areaDeTrabajo.setText(bufferLinea.toString());
     }
 }

Clase ControladorAbrir

/** Clase que maneja el controlador de la acción abrir del menú

 *  Archivo

 * 

 * 

 * */



import java.awt.event.ActionEvent;

import java.io.*;

import javax.swing.*;

import javax.swing.text.JTextComponent;



public abstract class ControladorAbrir extends AbstractAction{



    protected JTextComponent areaDeTrabajo;
  

    private JFileChooser fc;



    /** Constructor de la clase ControladorAbrir.

     * 

     *

     *  @param areaDeTrabajo Componente de texto en el cual se mostrará

     *  el contenido del archivo

     * 

     */

    public ControladorAbrir(JTextComponent areaDeTrabajo)

    {

        this.areaDeTrabajo = areaDeTrabajo;  
    }



    

    /** Método que se dispara cuando se da clic en la opción Abrir

     *

     *  @param event 

     */

    public void actionPerformed(ActionEvent event)

    {

     // Se crea el FileChooser.

        fc = new JFileChooser();

    
        int respuesta;


        respuesta = fc.showOpenDialog(areaDeTrabajo);


        //  Confirma que se haya presionado el botón Abrir y así poder aplicar

        // la lógica de la opción Abrir

        if (JFileChooser.APPROVE_OPTION == respuesta)

        {
         // Se obtiene el fichero

         File archivo = fc.getSelectedFile();
            try

            {

             //  Se abre el archivo. Este método tiene que ser definido por las

             // clases hijas

                logicaAbrir(archivo);

            }
            catch (Exception e)
            {

             // Mensaje de error si se produce.

                JOptionPane.showMessageDialog(

                    areaDeTrabajo, e, "Error en el archivo " + archivo,

                    JOptionPane.ERROR_MESSAGE);

            }

        }

    }



    /** Las clases hijas deben redefinir este método abstracto para leer el contenido 

     *  del archivo

     *

     * @param archivo Archivo del cual se va a leer

     *

     * @throws FileNotFoundException Excepción si el archivo no existe.

     */

    protected abstract void logicaAbrir(File archivo)

        throws FileNotFoundException;

}

Enseguida también pongo el código como separé la funcionalidad "Guardar como...".

La parte de Interfaz es la misma que la mostrada en el ejemplo anterior.

Clase ModeloGuardar

/** Clase en la que se maneja la mayor parte de la lógica de la
 *  acción guardar del menú Archivo
 * 
 * 
 * 
 * 
 * */


import java.awt.Event;
import java.io.*;

import javax.swing.*;
import javax.swing.text.*;


//Clase ModeloGuardar que hereda de la clase abstracta ControladorGuardar
public class ModeloGuardar extends ControladorGuardar
{
   

 /** Constructor de la clase ModeloGuardar
     * 
     *
     * @param areaDeTrabajo Componente en el que se pretende tomar el contenido 
     *  para guardarlo en alguna ruta en específico
     */
    public ModeloGuardar(JTextComponent areaDeTrabajo)
    {
     // Se le pasa al constructor de la superclase el JTextComponent
        super(areaDeTrabajo);
        
        // Etiqueta y tecla aceleradora
        this.putValue(Action.NAME, "Guardar como...  ");
        this.putValue( Action.ACCELERATOR_KEY,
            KeyStroke.getAWTKeyStroke('G', Event.CTRL_MASK));
    }

    /** Toma el archivo creado de la ruta específicada en el selector de archivos
     * y escribe sobre él el contenido del areaDeTrabajo (área de Texto) para
     * guardarlo en dicho archivo
     *
     * @param archivo Archivo a escribir
     *
     * @throws FileNotFoundException Error al leer el archivo
     */
    protected void logicaGuardar(File archivo) throws FileNotFoundException
    {
        PrintWriter archivoSalida = new PrintWriter(archivo);
        archivoSalida.print(areaDeTrabajo.getText());
        archivoSalida.close();
    }
}

Clase ControladorGuardar

/** Clase que maneja el controlador de la acción guardar del menú
 *  Archivo
 * 
 * 
 * */

import java.awt.event.ActionEvent;
import java.io.*;

import javax.swing.*;
import javax.swing.text.JTextComponent;


public abstract class ControladorGuardar extends AbstractAction
{
   
    protected JTextComponent areaDeTrabajo;

    
    private JFileChooser selectorArchivos;

  
    

    

    /** Constructor de la clase ControladorGuardar
     * 
     *
     *  @param componenteTexto Componente de texto del cual se dispondrá de
     *  su contenido para guardarlo
     * 
     */
    public ControladorGuardar( JTextComponent areaDeTrabajo)
    {
        this.areaDeTrabajo = areaDeTrabajo;
        
    }


    /** Método que se dispara cuando se da clic en la opción Guardar
    *
    *  @param event 
    */
    public void actionPerformed(ActionEvent event)
    {   
        
        selectorArchivos = new JFileChooser();
        int respuesta;

        respuesta = selectorArchivos.showSaveDialog(areaDeTrabajo);
        

        //  Confirma que se haya presionado el botón Guardar y así poder aplicar
        // la lógica de la opción Guardar
        if (JFileChooser.APPROVE_OPTION == respuesta)
        {
         // Se obtiene el fichero
            File archivo = selectorArchivos.getSelectedFile();

            try
            {
             // Se guarda. Las clases hijas deben redefinir este método.
                logicaGuardar(archivo);
            }
            catch (Exception e)
            {
             // Mensaje de error si se produce.
             JOptionPane.showMessageDialog(null,"Error de archivo"+e.toString());
            }
        }
    }

    
    /** Las clases hijas deben redefinir este método abstracto para guardar el contenido 
     *  
     *
     * @param archivo Archivo en el cual se va a guardar
     *
     * @throws FileNotFoundException Excepción si el archivo no existe.
     */
    protected abstract void logicaGuardar(File archivo)throws FileNotFoundException;
}

Fuentes
Chuidiang

Programación Orientada a Objetos y Taller

miércoles, 23 de noviembre de 2011

Puntos Extras Taller Programación Orientada a Objetos

Puntos Extras Clase POO

Ejercicio Interfaz Grafica y Heuristicas

Ejercicio Pruebas Unitarias

Antipatrones de diseño

lunes, 31 de octubre de 2011

Patrones de diseño (Taller)

Patrones de diseño (Clase)