jueves, 31 de marzo de 2011

Patrones de diseño (clase)

Los patrones de diseño en programación ayudan a resolver problemas que se presentan muy a menudo en el desarrollo de un programa. Podemos referirnos a los patrones de diseño en base a :
1.- Nombre: usado para describir el patrón.
2.- Synopsis: nos da una breve descripción sobre los  problemas a los que se puede aplicar el  patrón.
3.- Solución: breve descripción de la solución.
Existen varios tipos de patrones de diseño, pero yo les voy  a mostrar unos cuantos que me parecieron muy importantes.

Adapter
Este patron se usa cuando se tienen dos objetos los cuales queremos que interactuen, pero ambos tienen interfaces distintas el uno al otro. Uno de nuestros objetos puede ser el cliente (quien recibe servicios) y el otro el servidor (quien presta servicios). Como tenemos metodos que pertenecen a la interfaz del cliente los cuales no son los mismos que los metodos que pertenecen a la interfaz del servidor y en nuestro programa queremos conservar ambas interfaces, necesitamos una manera de comunicar el servidor con el cliente. Esto se realiza por medio de un adaptador el cual permite que los metodos del objeto cliente puedan ser entendidos por el objeto servidor y la tarea que se le encargo a este ultimo se lleve a cabo.
La siguiente imagen sirve para ilustrar la manera en que se aplica este patron de diseño.


Iterator
Se usa cuando tenemos un objeto que contiene una colección de datos de un cliente, los cuales son guardados en estructuras de datos (arboles, listas enlazadas, vectores, etc) y el cliente quiere acceder a ellos sin preocuparse sobre como son guardados los datos. Por lo cual tenemos que proveer una interfaz que permita acceder a los datos de una manera amigable.
Imaginemos que el cliente quiere realizar un ciclo sobre los datos, como le hemos proveido una interfaz el cliente realiza un ciclo usando los componentes de la interfaz la cual a su vez realiza el trabajo de pasar los datos. De esa manera facilitamos la manipulación de los datos.

Composite
Trata con el problema de la creación de objetos complejos a partir de objetos mas simples, lo cual se soluciona usando una colección de elementos simples pero que puedan ser unidos entre ellos de varias maneras.
Un ejemplo muy conocido son las ventanas graficas de los programas, las cuales basicamente estan formadas por contenedores y componentes y agrupados de tal manera que se forma la ventana que se desea.


Flyweight
Cuando se tienen muchos objetos que tienen la misma información, se puede ahorrar espacio en memoria creando una clase que se encargue de manejar la información que es común a varios objetos y haciendo que esos objetos obtengan su información la un objeto de la clase anterior.


Model View Controller (MVC)
Es una manera de descomponer una aplicación en tres partes: el modelo, la visualización y el controlador. originalmente diseñado para la aplicación de una GUI. Se comporta de la siguiente forma.
Entrada --> Procesamiento --> Salida
Controlador --> Modelo --> Visualización

Este patrón es el que pienso usar, en donde la visualización es la ventana donde se ve el laberinto, las entradas son los datos que el robot pasa a el contenedor el cual modela a los muros y guarda sus posiciones y la del robot(s).

Bibliografía:
An Introduction to Object-Oriented Programming,(3rd Edition)
Timothy Budd
http://ootips.org/mvc-pattern.html
http://www.go4expert.com/forums/showthread.php?t=5127#prototype

martes, 29 de marzo de 2011

Demostraciones de avance parcial

Taller de programación orientada a objetos
Semana 8

Esta vez voy a mostrar un poco del avance que he tenido con el código en mi programa.

Por el momento el programa solo inicia el sistema principal, que a su vez trata de comunicarse con dispositivos bluetooth ( lo cual aun no he codificado) y se apaga automaticamente dado un tiempo preestablecido por el usuario ( en este caso son 4 iteraciones del programa).

Para poder tener tiempo de ver lo que el programa hace, agregue un retardo con en while y un for anidados, iterando numeros mayores a 1000, por el momento los retardos representan los tiempos en que se realizan las comunicaciones y demas funciones del sistema.

package oop;

/*
 *clase base de la mayoria de las clases que se usan en el 
 *proyecto de oop
*/

public class Comun {

    //atributos
    int id;
    int estado;

    //constructor
    public Comun(int valorId, int valorActivado){
 id = valorId;
 estado = valorActivado;
 System.out.println("Creando objeto con valores definidos por el usuario");
    }

    //constructor vacio
    public Comun(){
 id = 0;
 estado = 1;
 System.out.println("Iniciando objeto con valores predefinidos");
    }

    //atributos
    public int verId(){
 System.out.println("Viendo id del objeto");
 return id;
    }

    public int verEstado(){
 System.out.println("Viendo estado del objeto");
 return estado;
    }

    public void Activar(){
 System.out.println("Estado");
 estado = 1;
    }



/*
 *clase principal del programa, se encarga de coordinar todas las 
 *demas clases del proyecto, hereda de la clase comun
 */

package oop;

public class Sistema extends Comun {
    
    //atributos
    int idContador, modo,tiempoMuestreo,contadorMuestreo;
    int tiempoPrendido, contadorPrendido, apagar;
    String[] nombres={"Sistema","Informacion","Graficos",
       "Comunicador","Usuario"};


    //constructor vacio
    public Sistema(){
 super();
 tiempoPrendido = -1; //tiempo indefinido
 tiempoMuestreo = 5000; //cada 5000 iteraciones toma un valor
 modo = 1; //modo automatico 
 aumentarIdContador();
 apagar = 0; //inicialmente el programa esta prendido
    }

    //constructor con elementos
    public Sistema(int prendido, int muestreo, int modo){
 super();
 tiempoPrendido = prendido;
 tiempoMuestreo = muestreo;
 this.modo = modo;
 aumentarIdContador();
 apagar = 0;
    }

    
    //aumenta el valor del contador de muestreo
    public void aumentarContadorMuestreo(){
 if((++contadorMuestreo%tiempoMuestreo)== 0){
     System.out.println("******Conectando con el dispositivo*****");
 }
 return ;
    }

    //aumenta el valor del contador de prendido
    public void aumentarContadorPrendido(){
 //System.out.println("Entrando a aumentarContadorPrendido");
 if(tiempoPrendido == -1){
     System.out.println("El tiempo de prendido esta indefinido");
 }else{
     //el programa va a ser apagado
     if(++contadorPrendido>= tiempoPrendido){
  apagar = 1;
  System.out.println("Apagando el sistema");
  return;
     }else{ // el programa sigue prendido
  //contadorPrendido++;
  //System.out.println("Aumentamos el contador de prendido");
  System.out.print("Valor de tiempo prendido -- ");
  System.out.println(contadorPrendido);
     }
 }
 //System.out.println("Saliendo de aumentarContadorPrendido");
 return ;
    }

 


    //metodo que pausa el sistema para que no termine muy pronto
    public void delay(int repeticion){
 int i = 0;
 //System.out.println("Iniciando delay");
 System.out.println("........");
 while (i < repeticion){
     for(int j=0;j<10000;j++){
     }
     i++;
 }
 //System.out.println("Delay finalizado");
 return ;
    }


    //metodo principal
    public static void main(String[] args){

 System.out.print("--> ");
 System.out.println("Sistema prendido");
 Sistema principal = new Sistema(4,2,1);
 
 //mantiene el programa activo mientras no se de la orden de apagar el programa
 System.out.println("Valores del sistema");
 System.out.print("id--");
 System.out.print(principal.id);
 System.out.print(", tiempoPrendido--");
 System.out.print(principal.tiempoPrendido);
 System.out.print(", tiempoMuestreo--");
 System.out.print(principal.tiempoMuestreo);
 System.out.println("");
 while (principal.apagar != 1){
     principal.delay(100000);
     principal.aumentarContadorMuestreo();
     principal.aumentarContadorPrendido();
 }
 System.out.print("--> ");
 System.out.println("Systema apagado");
    }
    //fin del programa
} 
La implementación del código da como resultado:













Como se puede ver el sistema se inicia, luego muestra las variables del sistema.
Después nos muestra el valor de cada iteración con valor de tiempo prendido y cada cierto tiempo
trata de conectar con el dispositivo bluetooth.
Cuando llega al número de iteraciones que tiene que realizar termina el programa.
Por el momento esto es todo lo que tengo, pero conforme pasen los dias pienso agregar la comunicación
bluetooth y la funcionalidad de usuario, usando los eventos y luego guardar datos en un
archivo de texto por el momento.


Todos los comentarios y sujerencias son bien recibidos.

miércoles, 16 de marzo de 2011

Diagramas de clase y secuencia de UML

Diagramas de mi proyecto de software.

Herramientas para diagramas de clase y secuencia de UML; autogeneración de código

Existen muchas herramientas que permiten la creación de diagramas UML, de las cuales yo utilize umbrello.
La instalación en Ubuntu es muy sencilla, basta con teclear desde terminal:
sudo apt-get install umbrello

Para correr el programa, se puede hacer desde terminal tecleando:
umbrello &

Una imagen de como se ve un diagrama en el programa.  


 
Código generado en base al diagrama de clases de la foto anterior.
 
 

// 
/**
 * Class elemento
 */
public class elemento {

  //
  // Fields
  //

  public boolean activo;  /**

   * Clase principal del sistema
   *    */

  public String nombre;
  
  //
  // Constructors
  //
  public elemento () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  /**
   * Set the value of activo
   * @param newVar the new value of activo
   */
  public void setActivo ( boolean newVar ) {
    activo = newVar;
  }

  /**
   * Get the value of activo
   * @return the value of activo
   */
  public boolean getActivo ( ) {
    return activo;
  }

  /**
   * Set the value of nombre
   * Clase principal del sistema
   * 
   * @param newVar the new value of nombre
   */
  public void setNombre ( String newVar ) {
    nombre = newVar;
  }

  /**
   * Get the value of nombre
   * Clase principal del sistema
   * 
   * @return the value of nombre
   */
  public String getNombre ( ) {
    return nombre;
  }

  //
  // Other methods
  //

  /**
   */
  public void apagarElemento(  )
  {
  }


  /**
   */
  public void prenderElemento(  )
  {
  }

}


Documentación sobre el uso de umbrello.

Documentación para leer sobre diagramas UML.