Sistemas Distribuidos (4ta Entrega)

Que es un sistema Distribuido?
bueno este, como su nombre lo dice, es un software que se encuentra distribuido en diferentes computadores conectadas por medio de la red, con el protocolo cliente-servidor.
Estos sistemas funcionan mandando mensaje y recibiendo asi respondiendo a con una accion, los sistemas distribuidos son muy bueno para cuando un sistemas es demasiado complejo que se necesita mas de un computador con hardware limitado, podria ser casi ilimitado si utilizamos varios computadores conectados.

y que es un protocolo cliente-servidor?
pues este es un sistema donde el cliente es una maquina que solicita un determinado servicio y se denomina servidor a la maquina que lo proporciona.

Los servicios pueden ser:

• Ejecución de un determinado programa.
• Acceso a un determinado banco de información.
• Acceso a un dispositivo de hardware.

http://www.monografias.com/trabajos16/sistemas-distribuidos/sistemas-distribuidos.shtml aqui podemos ver mas informacion.

ahora como implementaria mi software en un sistema distribuido:

primero tendria que crear otra clase que contenga sockets, en java ya existen estas clases predeterminadas en la API encontramos mucha informacion relacionada, esto es para crear conexiones por medio de la red, con esto implementaria al servidor, haria otra clase para el cliente que seria solo una interfaz que mandaria el mensaje por medio de esos sockets. mi software seria lo mismo pero en otro computador, que respondiera a mis mensajes desde otra computadora.

otra manera seria crear scrips con cgi's configurando un servidor abierto como apache y poner mi programa en la direccion de mi computador y de igual manera es un cliente-servidor.

aqui un link con informacion mas detallada http://www.augcyl.org/?q=glol-intro-sistemas-distribuidos

Patrones de Diseno (3ra entrega)

Bueno para esta parte de mi programa, lo hice con el Modelo Vista Controlador ya que tengo todo separando para no publicar tanto codigo lo hare un diagramas uml para simplificar la vision.

primero tengo mi parte separa de la interfaz grafica que asu vez se comunica con el controlador que es el que hace la logica de como calcular los colores de las caras asi como su posicion y asi quedaria modelado:

cuando el modelo es el cubo, que genera las ventanas botones etc, graficoscubito tiene toda la logica y el controlador es obtener coordenadas que asu vez llama a los movimientos

Eventos Y Excepciones (3ra entrega)

Fue dificil para mi, encontrar donde colocar una excepcion hasta que me di cuenta de que no se puede dan ciertos movimientos asi que puse como condicion, que si se llega a seleccionar una cara a mover, y intenta moverlo para un lado que on se pueda, generara un error y lanzara la excepcion con un mensaje de error

y aqui lo muestro:

try{
    if(caraSeleccionada==0){// si ninguna cara ha sido seleccionada

       throw new Exception();//lanzara una nueva excepcion que mas adelante la atrapara
   }
    else{
   System.out.println("esta accion si es posible");
    switch(caraSeleccionada){

   //y realiza el movimiento

}

}catch(Exception excepcion){
System.out.println("esta accion no puede hacerse, NINGUNA CARA HA SIDO SELECCIONADA");
     }

igual para cada cara, si en dado caso no ha escogido ninguna lanzara esa exepcion

y aqui una pantalla de la excepcion

y despues escogiendo una cara y realizando un movimiento

EVENTOS

mientras tanto los eventos son diferentes

disenie una accion para cada boton, los de los colores solo regresan el valor entero equivalente al color que movera asi:

JButton botonRojo=new JButton("Rojo");
 botonRojo.addActionListener(new ActionListener(){
  public void actionPerformed(ActionEvent e){
      System.out.println("Cara seleccionada roja");
      caraSeleccionada=1;
  }
     }
     );

y de esta forma lo hice para cada boton, pero para los botones de movimientos fue en donde implemenente las excepciones donde tengo que llamar los colores de las caras para poder mandarlos al de los movimientos y aqui el codigo.

JButton botonoeste=new JButton("IZQUIERDA");
        botonoeste.addActionListener(new ActionListener() {
 public void actionPerformed(ActionEvent e){
  System.out.println("movio hacia izquierda");
   try{        
   if(caraSeleccionada==0){
    throw new Exception();
      }
      else{

   System.out.println("esta accion si es posible");

y es cuando llama al movimiento a realizar mandando las caras para que las cambie que es como lo muestro en las imagenes de arriba

por lo pronto es todo que tengan un buen dia.

Interfaz Grafica (3ra Entrega)

Para esta entrega mostrare mi interfaz grafica que para medio curso ya la tenia lista para medio curso

ya que lo necesitaba para mostrar los colores del cubo.

Para mi beta del programa estoy implementando eventos del raton y definiendo las acciones para cada boton que son los movimientos pero el disenio de la interfaz grafica es la misma.

agregue varios botones que son las que moveran las caras de los cubos cada que se haga un movimiento la pantalla se repintara con repaint().

utilice g.fillRect(x,y,anchura,altura)

para que los cuadros se pinten, utilice metodos que cree para buscarlos dentro de todas las caras asi buscar los colores para cada cara. y quedaria algo asi.

aqui ya movi un lado de la cara hacia arriba como se muestra en la imagen con los botones de eventos que en la proxima publicacion mencionare, para generar estos colores los busco en todo el cubo y calculo en x , y en numero de pixeles para que salgan acomodados.

Para este proyecot implemente JPanel, JButton, JFrame y un container para la ventana asi hice un objeto de cada uno de ellos para juntarlos todos en el container.

Aqui el codigo

 JPanel panelbotones= new JPanel();

 JButton botoneste= new JButton("DERECHA");

 JButton botonoeste=new JButton("IZQUIERDA");

 JButton botonnorte=new JButton("ARRIBA");

 JButton botonsur= new JButton("ABAJO");

panelbotones.setLayout(new GridLayout(1, 2));

panelbotones.add(botonsur);

panelbotones.add(botoneste);

panelbotones.add(botonoeste);

panelbotones.add(botonnorte);

Container ventana = getContentPane();

 ventana.add(gr,BorderLayout.CENTER);

ventana.add(panelbotones, BorderLayout.SOUTH);

setSize(450,400);

 setVisible(true);

Eso seria nadamas la interfas para la ventana, lo de los colores lo tengo en otra clase que pinta color por color dependiendo de donde este ubicada, con la funcion anteriormente mencionada.

Herencia, Documentacion, Codigo auto-generado (2da Entrega)

HERENCIA

En mi proyecto la herencia que utilizo es la de JFrame ya que la utilizo para generar las ventanas y botones trate de utilizar como herencia los movimientos pero vi que no era eficientes asi que mejor herede de JFrame y ActionListener para los eventos que se encuentran ya en la API de Java.

La herencia en Java es muy facil de usar, solo se pone despues del nombre de la clase la palabra reservada extends y despues el nombre de la clase a heredar si queremos heredar mas de una clase utilizamos otra palabra reservada implements y ponemos las que necesitemos separadas por comas por ejemplo

public class Prueba extends JFrame implements ActionListener, MouseEvent{
}
esto sirve demasiado para cuando queremos reutilizar codigo, que es una muy buena practica en la ingenieria de software, pero no hay que olvidar tambien importar el paquete que contiene esa clase con import javax.swing.*; el " * " es un comodin que es para extraer cualquier clase de ese paquete.
aqui les dejo la documentacion de la api de java http://download.oracle.com/javase/6/docs/api/  ahi encontraran todo lo que contiene esa clase tanto metodos como los argumentos que reciben.

Mi Proyecto hereda todo de esta clase JFrame asi como otras clases de este paquete swing, JButton Container etc.

DOCUMENTACION


La documentacion en codigo de programacion sirve mucho para entender que hace ese codigo, no solo para nosotros, o el computador, si no para cuando alguien mas quiere modificarlos o darle mantenimiento.
Documentar un programa es una buena practica para un buen programador, ya que ningun programa esta excento de tener errores, documentarlo es una buena practica para que otra persona si en dado caso en un futuro pueda modificarlo sin tener muchos problemas, ya que si no esta documentado al querer leerlo y entenderlo otra persona tardara mucho en comprenderlo ya que cada programador tiene su estilo de programar diferente y claro que su logica tambien, asi que hay que empezar a documentar los proyectos cada vez que hagamos uno.

*Que hay que documentar? esto son unos pasos de los cuales se deben tomar en cuenta

• ¿de qué se encarga una clase? ¿un paquete?
• ¿qué hace un método?
• ¿cuál es el uso esperado de un método?
• ¿para qué se usa una variable?
• ¿cuál es el uso esperado de una variable?
• ¿qué algoritmo estamos usando? ¿de dónde lo hemos sacado?
• ¿qué limitaciones tiene el algoritmo? ¿... la implementación?
• ¿qué se debería mejorar ... si hubiera tiempo?

En el caso de mi proyecto yo lo documente, de pies a cabeza desde que hace una variable, hasta para que sirve un metodo por ejemplo esto:

    private final static int Naranja = 6;//es para saber que color se usara

    private int r;

    private int color = 0;

    private int x;//para coordenadas x

    private int y; //coordenadas y

    private int i; //tiene uso para for

    private int j;//for

    private int get=0;//ayudara para saber las coordenadas

    private int temp = 0;//solo para el getit

    private int temp2=0;//solo para cuando obtengo colores !!!!!!!! FIX IT

que son las variables que declare en mis proyecto asi como muchas mas o metodos:

       /*

*es el que hara los colores

*asi como el que pintara cada cuadro de las caras

*llama a los metodos getCoord() estableceCoord()

*para completar su funcionamiento

*/

    public void paintComponent(Graphics g){

super.paintComponent( g );

System.out.println("inicia paintComponent");

     }

que solo es un fragmento de todo mi codigo ya que no puedo poner todo el codigo aqui.

Hay diferentes tipos de comentarios que se expresan de diferente forma por ejemplo 

En Java disponemos de tres notaciones para introducir comentarios:

javadoc

Comienzan con los caracteres "/**", se pueden prolongar a lo largo de varias líneas (que probablemente comiencen con el carácter "*") y terminan con los caracteres "*/".

una línea

Comienzan con los caracteres "//" y terminan con la línea

tipo C

Comienzan con los caracteres "/*", se pueden prolongar a lo largo de varias líneas (que probablemente comiencen con el carácter "*") y terminan con los caracteres "*/".

Cada tipo de comentario se debe adaptar a un propósito:

javadoc

Para generar documentación externa (ver comentarios javadoc más abajo)

una línea

Para documentar código que no necesitamos que aparezca en la documentación externa (que genere javadoc)

Este tipo de comentarios se usará incluso cuando el comentario ocupe varias líneas, cada una de las cuales comenzará con "//"

tipo C

Para eliminar código. Ocurre a menudo que código obsoleto no queremos que desaparezca, sino mantenerlo "por si acaso". Para que no se ejecute, se comenta.
(En inglés se suele denominar "comment out")

aqui un muy buen tutorial para javadoc 

http://www.lab.dit.upm.es/~lprg/material/apuntes/doc/doc.htm

javadoc es muy recomendable para el momento de querer hacer documentacion siempre hay que ponerlos en esto lados

Por obligación (javadoc):

1. al principio de cada clase
2. al principio de cada método
3. ante cada variable de clase

Por conveniencia (una línea):

4. al principio de fragmento de código no evidente
5. a lo largo de los bucles

Y por si acaso (una línea):

6. siempre que hagamos algo raro
7. siempre que el código no sea evidente

y aqui ejemplos de mi codigo

/**

 *buscara en cada cara

 *con getCoord y el color a buscar

*@param getit[] contiene las coordenadas ya buscadas, esta declarado global

 */

temp2=0;

getCoord(Rojo);

        for(i = 0; i < 9; i++ ) {//buscara el color rojo (los 9 rojos)

   g.setColor(Color.RED);

    /**

     *@return LadoSuperior

     * si otro metodo o clase lo necesita

     */

    public int[][] getColorRojo(){

return LS; 

    }

get = LF[ i ] [ j ];//obtiene el color de la matriz en posicion i, j y los almacena en get

                    if(get==color)//si get es igual al color que mandamos a buscar, 

estableceCoord(i, j, 2);//mandar a establecer la coordenada con la posicion i, j, y el numero de la cara

   get=LD[ i ] [ j ];

ahi utilice todas las buenas practicas para documentar aqui dejare un buen tutorial por si alguien se interesa en esto

referencias: http://www.lab.dit.upm.es/~lprg/material/apuntes/doc/doc.htm

http://gpd.sip.ucm.es/rafa/docencia/programacion/tema1/javadoc.html

Codigo Auto-Generado

Despues de haber documentado todo tu codigo con los con etiquetas como @param, @author @return
etc dependiendo de que hayas documentado, existe una mejor manera de ver el codigo comentado, que genera de salida documentos HTML como si de una API se tratara.

aqui unas imagenes:

en esta se muestran todas las clases que documente

 aqui muestra metodos de esa clase y en la primera linea un parametro que puse

 en este tambien metodos de esa misma clase documentada y con javadoc me dice que regresa con @return que se queda doccumentadaa

enlista los metodos que tengo en la clase con lo que regresan en unos void en otros regresa matrices[][]

en este enlista las variables que declaramos y de que tipo son


esto es muy util para cuando desarrollamos un software muy complejo, o un software del que se pleanea darle mantenimiento cada cierto tiempo, y asi mejor su vida, la vida de software. para hacer esto es muy facil en linux ya se incluye con el jdk el javadoc que es el que se usa para generar el codigo HTML como el que ya puse.

para generarlo primero tenemos que irnos a la carpeta contenedora de las clases, en mi caso es cd Desktop/POO/Code/ y presionamos enter, una vez ubicados en la carpeta ponemos javadoc *.java que significa que autogenerara codigo de todas las clases de esa carpeta con terminacion .java y obtendremos como resultado varios archivos HTML.

para en windows este tutorial es muy bueno http://www.docstoc.com/docs/2539429/How-to-use-Javadoc-(for-Windows-computers)

ya con esto en practica vamos por un buen camino como programadores
para esta entrada es todo, nos vemos, saludos

Esqueleto de mi Proyecto (1ra Entrega)

Saludos companieros!!

Tengo un proyecto en mente y espero acabarlo para entregarlo a tiempo, mi proyecto trata de simulacion de un cubo rubik como este:

claro que no se vera asi tridimensionalmente, primero empezare con algo sencillo como por ejemplo, mostrar las 6 caras de forma de cubo estirado en 2d. Lo principal que tengo contemplado es la simulacion del cubo y sus movimientos para que el usuario pueda moverlo libremente hasta armarlo.

Este software la tenia contemplada en 4 clases pero resultaron ser mas, las mas importantes para la realizacion del cubo son las de los movimientos, que es una clase por cada cara. Estas clases contienen las intrucciones de como se movera cada cara del cubo. Las clases de movimientos las tenia en una misma clase hasta que vi que era un amontonadero, y era tedioso andar buscando donde estaba el error asi que decidi separarlos, tambien queria usarlo como una superclase, cosa que no hice por que eran varias clases, asi que mejor herede de JFrame para que me ayudara con las cosas graficas.

Despues tengo la clase GraficasCubito que genera las caras, independientemente de donde se encuentre, para esto tuve que deshacer la cara en cada cuadro, lo que hago es un barrido de todas las caras y consigo cada color de cada cara y dependiendo de la posicion en la que este en la matriz, calculara su valor en pixeles y lo acomodara mandandolo ala funcion predeterminada que realiza los cuadros

y la clase PruebaCubo, que contiene el constructor, el que genera las ventana botones, eventos, etc. esta es como el cubo en si, quien llama a las acciones para realizar su trabajo

aqui es como se veria en codigo en esqueleto

public class MueveLadoX{


  public void muevelo(recibe como argumentos las caras a mover){


*utilizo 4 vectores como ayudantes para extraer los colores y moverlos,

            ayudante[ 0 ] = LD [ 0 ] [ 0 ];
           ayudante[ 1 ] = LD [ 0 ] [ 1 ];
            ayudante[ 2 ] = LD [ 0 ] [ 2 ]; // para poder moverlo

*que despues lo pongo en otra posicion y esto para mover los colores de los lados

            ayudante[ 0 ] = LS [ 0 ] [ 2 ];
ayudante[ 1 ] = LS [ 1 ] [ 2 ];
ayudante[ 2 ] = LS [ 2 ] [ 2 ];//rojo
ayudante2[ 0 ] = LT [ 0 ] [ 2 ];
ayudante2[ 1 ] = LT [ 1 ] [ 2 ];
ayudante2[ 2 ] = LT [ 2 ] [ 2 ];//amarillo
ayudante3[ 0 ] = LIN [ 0] [ 0 ];
ayudante3[ 1 ] = LIN [ 1 ] [ 0 ];
ayudante3[ 2 ] = LIN [ 2 ] [ 0 ];//naranja
ayudante4[ 0 ] = LF [ 0 ] [ 2 ];
ayudante4[ 1 ] = LF [ 1 ] [ 2 ];
ayudante4[ 2 ] = LF [ 2 ] [ 2 ];//blanco


*y despues llamo a otro metodo de otra funcion para actualizar estos movimientos



           graficos.actualizarLadoSuperior(LD);
graficos.actualizarLadoFrontal(LS);
graficos.actualizarLadoDerecho(LT);
graficos.actualizarLadoTrasero(LIN);
graficos.actualizarLadoIzquierdo(LF);



}//termina el metodo muevelo
}//termina la clase

y asi para las demas clases de movimientos igual, solo que reciben diferentes caras como argumento, dependiendo del lado que sea

y para lo de los graficos

public class Graficos{
     public void pinta(){
     genera los cuadros de todas las caras
     y llama a las funciones para poder hacerlo }

     public void repinta(){
     despues de que haya una actualizacion, se llama a esta clase para repintarla
     }
     public void obtenLasCoordenadas(que recibe el color de la cara){
       aqui recibe el color de la cara desde pintar() que saca los colores de cara por cara
       y la almacena en un vector como ayuda
     }
     public void establececoordenadas(recibe la posicion del color){
          lo qu ehace es recibir la posicion en la matriz y la cara, y genera un valor en pixeles
     }
     public void obtencolor(el color){
     este es llamado por el cubo para que regrese las caras con sus valores
     }
     public void actualizaCara(Cara){
     solo es llamada cuando una cara es modificada, para que tenga efecto, los colores estan en esta clase
     }

*La clase Cubo es la que contiene todo lo del cubo como ventanas y botones

public class Cubo que hereda de JFrame{


   contructor Cubo(){
   que genera la ventana, botones, y los eventos de los botones asi como genera los que es el cubo
                    panelDerecho.add(botonRojo);
panelDerecho.add(botonBlanco);
panelDerecho.add(botonVerde);
panelDerecho.add(botonAmarillo);
panelDerecho.add(botonAzul);
panelDerecho.add(botonNaranja);


Container ventana = getContentPane();
        ventana.add(gr,BorderLayout.CENTER);
ventana.add(panelbotones, BorderLayout.SOUTH);
ventana.add(panelDerecho, BorderLayout.EAST);
setSize(450,400);
setVisible(true);
System.out.println("creo la ventana");
 

 tambien contiene el main que llama al constructor

public static void main(String args[]){
llama al constructor
Cubo c = new Cubo();contructor
pc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

ese seria el esqueleto de mi proyecto espero que este entendible, saludos.