miércoles, 31 de agosto de 2011

Ejemplo Moto

Clase Moto
public class Moto {
   //atributos
   private String placa;
   private boolean edoMotor;
   private int velocidad;
   private int vidaBateria;
   
   //constructor
   public Moto(String placa, boolean edoMotor, int velocidad, int vidaBateria)
   {
       this.placa = placa;
       this.edoMotor = edoMotor;
       this.velocidad = velocidad;
       this.vidaBateria = vidaBateria;
   }

   //métodos
   public String verPlaca ()
   {
       return placa;
   }
   
   public void encender()
   {
       edoMotor = true;
       if(vidaBateria>=0)
       {
           vidaBateria--;
       }
       
   }
   
   public void apagar()
   {
       edoMotor = false;
       velocidad = 0;
   }
   
   public void acelerar()
   {
       if(edoMotor = true)
       {
           velocidad = velocidad + 20;
       }
   }
   
   public void frenar ()
   {
       if(edoMotor = true && velocidad > 0)
       {
           velocidad = velocidad - 20;
       }
   }
   
   public void descMoto()
   {
       System.out.println("La placa es: "+placa);
       if(edoMotor == false){
       System.out.println("El motor esta apagado");
       }
       else {
       System.out.println("El motor esta encendido");
      }
       System.out.println("La velocidad es: "+velocidad);
       System.out.println("La vida de la Bateria es: "+vidaBateria);
       System.out.println("\n\n");
   }
}

Clase RunMoto

import java.util.Scanner;

public class RunMoto
{
   public static void main (String[] args)
   {
       
       Moto moto1 = new Moto("I4F230", false, 0, 100);
       
       int opcion = 0;
       Scanner read = new Scanner(System.in);
       
       do
       {
       System.out.println("1.-Describir Moto");
       System.out.println("2.-Encender Motor");
       System.out.println("3.-Apagar Motor");
       System.out.println("4.-Acelerar");
       System.out.println("5.-Frenar");
       System.out.println("6.- Salir\n");
                                   
       System.out.print("Ingrese: ");
       opcion = read.nextInt();
       System.out.println("\n");
       switch(opcion)
       {
           case 1:
               moto1.descMoto();
               break;
           case 2:
               moto1.encender();
               break;
           case 3:
                moto1.apagar();
               break;
           case 4:
               moto1.acelerar();
               break;
           case 5:
               moto1.frenar();
               break;
	 
       }
       }
while(opcion != 6);
   }
}


Programa realizado en equipo con mi compañero Sergio Rdz

martes, 30 de agosto de 2011

Esqueleto de clases

Clase Tablero
public class Tablero{
    private int color;
    private int tamano;
}

/*Constructor*/
public Tablero (int color, int tamano){
    this.color = color;
    this.tamano = tamano;
}

public void iniciar(){
}

public void empatar(){
}

public void salir(){
}


Clase Pieza
public class Pieza{
    private boolean activa;
    private int coordenada;
}
/*Constructor*/
public Pieza (boolean activa, int coordenada){
    this.activa = activa;
    this.coordenada = coordenada;
}

public void mover(int x, int y){
return coordenada;
}

public void capturar (){
}


Clase Reina
public class Reina{
    private boolean activa;
    int coordenada;

}
/*Constructor*/
public Reina (boolean activa, int coordenada){
    this.activa = activa;
    this.coordenada = coordenada;
   
}

public int mover(int x, int y){
return coordenada;
}

public void capturar (){
}


Clase Equipo
public class Equipo {
    private int cantidad;
    private int color;
    private string nombre;
    private boolean activo;
}
/*Constructor*/
public Equipo(int cantidad, int color, string nombre, boolean activo){
    this.cantidad = cantidad;
    this.color = color;
    this.nombre = nombre;
    this.activo = activo;
}

public void generar(){
}

Ejemplo

Programa simple para convertir de grados celsius a kelvin y fahrenheit

public class Temperatura {
    private double grados;
    private double kelvin = 273.15; //atributos

//constructor
public Temperatura(double grados){
    this.grados = grados;
}

//método
public double convertirk(){
    grados+=kelvin;
    return grados;
}

//método
public double convertirf(){
    grados=(1.8)*(grados)+32;
    return grados;
}

public static void main (String args[]){   
    Temperatura o1 = new Temperatura(10.5);
    Temperatura o2 = new Temperatura (30);
    System.out.println("Conversión a Kelvin es: "+o1.convertirk());
    System.out.println("Conversión a Fahrenheit es: "+o2.convertirf());
}
}

 

lunes, 29 de agosto de 2011

Instalación de herramientas

Para desarrollar el proyecto utilizaré Ubuntu en su versión 11.04.



Para el proyecto, utilizare el lenguaje de programación orientado a objetos Java. Para poder crear herramientas en java es necesario instalar el JDK (Java Development Kit), el cual nos permitirá compilar.


Para descargarlo e instalarlo, en la terminal ponemos lo siguiente:

sudo apt-get install openjdk-6-jdk



Esperamos a que se descargue y se instale. Finalmente para comprobar que se ha instalado correctamente, en la terminal ponemos javac y si no nos marca error ya se encuentra instalado.

El editor de texto voy a utilizar es Emacs, uno de los mas populares.



Para instalarlo en la terminal ponemos lo siguiente:

sudo apt-get install emacs23



Esperamos a que se descargue y se instale, para verificar que se ha instalado correctamente, ponemos en la terminal emacs y se ejecutara el programa.




Una herramienta importante que nos ayudara en la creación de diagramas de clases y casos de uso es el Umbrello.



Para descargar e instalar el Umbrello ponemos en la terminal lo siguiente:

sudo apt-get install umbrello



Esperamos a que se descargue y se instale. Finalmente para verificar que se ha instalado correctamente, ponemos en la terminal umbrello y se ejecuta el programa



Referencias

Metodologías de análisis y diseño de software

Metodología de desarrollo de software es utilizada en la ingeniería de software, se define como una serie de pasos que nos permite controlar, realizar la estructura y planificar un sistema.

 Algunas de metodologías:
  • Proceso Racional unificado (RUP): Es utilizada junto el UML en los sistemas orientados a objetos
  • Programación extrema (XP): Mantiene en su equipo al usuario final y además es de las más populares en la actualidad.
  • Microsoft Solution Framework: Se basa en los modelos de proceso y deja a un lado las elecciones tecnológicas
  • Proceso Unificado Ágil (AUP): Se basa en la metodología RUP y además que describe de manerasimple entender las aplicaciones de software.

Cada metodología tiene varios enfoques, podemos encontrar los siguientes:
  • Cascada: Ordena las etapas para el desarrrollo de software y espera a que termine cada capa.      
  • Espiral: Creado para fortalecer las debilidades del modelo cascada.
  • Incremental: Cada ciclo, representa el conjunto de actividades que hay que realizar y comienza desde el interior.

Para decidir que metodología elegir es necesario evaluar lo siguiente:
  • Determinar el alcance.
  • Determinar el tiempo.
  • Cual se acomoda, para poder aplicarla.


Espiral


Cascada


Referencias




Diagramas casos de uso y clases

Buscaminas


Siase



Angry Birds

Clase
Atributos
Métodos
Pájaro
sonido
color
forma
fuerza
lanzarse
destruir
Cerdo
posición
color
forma
resistencia
restar vida


Otras clases: obstáculo, resortera y escenario


Equipo: Julio Garcia, Horacio Ibarra, Jair Viezca y Jesus Antonio

domingo, 28 de agosto de 2011

Crisis del software

El termino crisis del software se utilizó por primera vez en 1968, en una conferencia que trataba sobre el desarrollo de software por OTAN (Organización del Tratado de Atlántico del Norte). Este problema ha ido avanzando con el transcurso de los años y en la actualidad no es un problema que se encuentre resuelto.

Al hablar sobre crisis de software, nos referimos a las siguientes características:
  •          Incumplir con los plazos de entrega.
  •          Difícil hacer presupuesto.
  •          Baja calidad del software.
  •          No cumplía con lo especificado.
  •          Dificultad de mantenimiento.

Uno de los grandes problemas  que hay  actualmente, es que no hay una manera precisa, para poder determinar los costos y el tiempo que dura cada proyecto.

Para tratar de evitar este problema, tendríamos que ponernos a tratar de tener una mejor planeación, cumplir con los objetivos de plazo, presupuestos y tratar de hacer software de calidad. Una de las metodologías que ha tratado de resolver este problema, es la orientada a objetos.

Se creó el Lenguaje Unificado de Modelos (UML) el cual combina elementos de las siguientes metodologías:
  •          Booch
  •          OSSE
  •          OMT


Lo ideal que se busca actualmente, es el poder realizar software de calidad a bajo costo.




Algunos ejemplos de casos fallidos

Se colapsó el aeropuerto de los Ángeles en el año 2007, en total más de 17000 personas se vieron afectadas, alrededor de 9 horas debido a un problema en el software, que causo que la tarjeta de red se bloqueara.



Otro ejemplo ocurrió recientemente en Abril de 2011, fue el ataque al sistema de seguridad de la compañía de Sony Computer Entertainment, una compañía de las más importantes a nivel mundial.  Un grupo de hackers atacaron el sistema de seguridad de la consola PS3, el PlayStation Network (PSN), consiguiendo así robar información de datos personales, como lo son las tarjetas de crédito.

El servicio de PSN apareció por primera vez en el 2006, se caracteriza por ser un servicio gratuito y cuenta actualmente con más de 77 millones de usuarios. El servicio duró aproximadamente un mes fuera de servicio  y fue un problema que dio la vuelta al mundo.


Referencias 

Casos de uso

Diagrama casos de uso "Damas"


Tabla casos de uso "Damas"

Caso de uso
Actor(es) involucrado(s)
Descripción
Casos de uso relacionados
Mover
Usuario
El jugador realiza el movimiento de una de sus fichas.
Capturar y Coronar

Capturar
Usuario
El jugador elimina a la pieza.

Coronar
Usuario
Al llegar al extremo del tablero se convierte en reina.

Ver  puntuación
Usuario
El jugador puede checar su historial de estadísticas.

Configurar
Usuario
El jugador puede configurar el color del tablero y además color de las fichas.

Ver ayuda
Usuario
Se explica una breve introducción de como poder jugar a las damas.

miércoles, 24 de agosto de 2011

Descomposición en clases

Para el proyecto utilizare las siguientes clases:


1.- Clase (pública) Tablero
  • Atributos (privados): color, tamaño
  • Métodos (públicos):  iniciar, empatar, salir

Responsabilidad: Sirve para diseñar donde los demás objetos interactúan al momento de jugar.


2.- Clase (pública) Pieza:
  • Atributos (privados): activa, desactiva
  • Métodos (públicos): mover, capturar

Responsabilidad: Sirve para poder diseñar como mover la pieza de manera inclinada y además poder capturar las piezas contrarias.


3.- Clase (pública) Reina:
  • Atributos (privados): activa, desactiva
  • Métodos (públicos): mover, capturar

Responsabilidad: Sirve para poder diseñar como mover la pieza de manera inclinada, además poder moverse hacia atrás y capturar las piezas contrarias.


4.- Clase (pública) Equipo:
  • Atributos (privados): cantidad, color, nombre, activo
  • Métodos (públicos) : generar

Responsabilidad: Sirve para diseñar el cómo administrar el equipo de fichas, del jugador 1 y jugador 2.

Conforme vaya avanzando, voy a ir agregando cosas que me falten.

Definición del proyecto

Para la materia de programación orientada a objetos, como proyecto pensé en programar el juego de damas inglesas. Lo elegí por que me gusta jugarlo en tiempo libre, además considero que es un juego en el que se requiere pensar, para poder crear estrategias. Para el proyecto utilizare el lenguaje de Java.

El juego de damas inglesas consiste en un tablero, el cual esta formado por 8 filas y 8 columnas lo que en total forma 64 casillas. El juego se compone de 12 piezas por cada jugador y las cuales se acomodan de una manera intercalada. El juego consiste en ir capturando piezas  del rival, hasta dejarlo en 0 o que ya no pueda realizar movimientos.


En el juego manejas las piezas, las cuales tienen como característica que solo se pueden mover una casilla en diagonal y también el que no pueden retroceder, sin embargo cuando una pieza llega al otro extremo del tablero, esta pieza se convierte en reina. La reina tiene como característica además de poder moverse en diagonal, el que puede retroceder.

Otras reglas:

  •         Cada jugador mueve una ficha por turno.
  •          Es obligatorio capturar, es decir no puedes moverte hacia otro lado.
  •          Cuando un jugar ya no puede realizar movimientos, el jugador pierde.
  •          Es de 2 jugadores.


Referencias: