LINKS DEL PROYECTO

Programaciòn Orientada a Objetos

http://www.youtube.com/watch?v=NfG67dhk86M

Taller de Programaciòn Orientada a Objetos

http://www.youtube.com/watch?v=wZz6-utFd8U

POO

RESUMEN DEL PROYECTO

Eventos: En nuestro proyecto contamos con varios eventos, que forman parte de la primera ventana del Login, en donde podemos encontrar un Jlabel, esto nos permite aplicar una imagen de fondo.Tambien con otros 4 botones que nos indican el usuario y contraseña. En la otra ventana tenemos mas botones de guardar, eliminar, modificar, salir, busqueda y nuevo.

Excepciones: aqui utilizamos en la interfaz gráfica, en el botón eliminar, ya que nos pediría la confirmación si realmente queremos eliminar un contacto y aparte para mandar la información a la base de datos de querer eliminarlo, hicimos lo mismo para la función de modificar.

Errores: los errores que se nos presentaron era que al momento de introducir el contacto pero no introducíamos la dirección o el nombre, este lo guardaba, pero lo pudimos arreglar con una excepción.

Sistemas Distribuidos:

Nuestro proyecto se puede distribuir mediant

e una empresa, es decir, que la agenda podría estar conectada a una red interna en la empresa, y ya conectada a la base de datos para guardar los registros, que el personal pueda acceder a sus contactos y también

poder comunicarse con ellos mediante la agenda

Interfaz grafica:

Nuestra interfaz gráfica cuenta con dos ventanas, la primera que nos aparece es para acceder a la agenda, es una ventana en donde tenemos que introducir nuestro nombre de usuario y nuestra contraseña.

En esta ventana es donde agregaremos, modificaremos, eliminaremos, guardemos y también podamos buscar a algún contacto en especifico. Contamos con varias areas como donde ingresamos los datos, una de botones, y una tabla.

Pruebas unitarias: Quisimos implementar pruebas unitarias en nuestro

proyecto ya que presenta varios modulos, por decir un area para modificar,

otra para guardar, salir, etc. y teniamos que verificar que cada una

funcionara correctamente.Lamentablemente no pudimos implementarlo. La herramienta con la que trabajarams era el JUnit

n

11. POO

Sistemas Distribuidos

Nuestro proyecto se puede distribuir mediante una empresa, es decir, que la agenda podría estar conectada a una red interna en la empresa, y ya conectada a la base de datos para guardar los registros, que el personal pueda acceder a sus contactos y también poder comunicarse con ellos mediante la agenda, o poder hacer otro tipo de cosas como mandarse mensajes entre ellos, mails, etc.

Pensamos en muchas formas de darle esta distribución al proyecto, pero esta fue la que mejor nos llamo la atención.



10. POO

.......INTERFAZ GRAFICA.......

 Nuestra interfaz gráfica cuenta con dos ventanas, la primera que nos aparece es para acceder a la agenda, es una ventana en donde tenemos que introducir nuestro nombre de usuario y nuestra contraseña. Utilizamos los botones para que el usuario acepte que quiera ingresar a la agenda, y el otro de cancelar, para omitir todo.

Una interfaz gráfica es cualquier medio por el cual uno puede interactuar con una computadora a través de algún tipo de software gráfico. Comúnmente, esto se consigue a través del control mediante el teclado y el mouse de cursores, menús, ventanas, íconos y cajas de diálogo, pero puede tomar cualquier forma imaginable. Gran parte del trabajo que se realiza en relación con el procesamiento digital de señales (DSP), el diseño de instrumentos interactivos, los sistemas para la interpretación en tiempo real y la síntesis gráfica (graphic synthesis) se ocupa del diseño de interfaces gráficas innovadoras y musicalmente apropiadas.

Como vemos en la imagen de arriba, se puede apreciar dos botones, que el primero nos muestra la barra en donde debemos de escribir nuestro nombre de usuario y abajo la contraseña, después de presionar la tecla aceptar se nos aparecerá la ventana de nuestra agenda. En esta ventana es donde agregaremos, modificaremos, eliminaremos, guardemos y también podamos buscar a algún contacto en especifico. Nuestro primer menú es el de los “Datos del contacto” en donde tenemos que introducir varios datos como el nombre, dirección, teléfono, email y el sexo. Hay que destacar que el id no lo podemos introducir, ya que automáticamente se le agrega a cada contacto que agreguemos.

Otra cosa importante es que hicimos que estén inactivos los campos de texto, ya que queríamos que al momento de presionar el botón de nuevo (icono azul) se pueda habilitar estos campos, para después introducir los datos. Después de esto sigue el menú de botones, que contamos con 5 botones, el primero es para agregar un nuevo contacto, después tenemos para modificar un contacto seleccionado en la tabla que se muestra en la parte de abajo.

Después de esto tenemos el botón de eliminar (rojo) en donde igual que al modificar, primero tendremos que seleccionar un contacto de la tabla y después seleccionar el botón de eliminar, se nos preguntara si realmente deseamos eliminar ese contacto. Después tenemos el botón de guardar, ya que hemos activado los campos de texto e introducir todos los datos, debemos de oprimir este botón para que automáticamente se guarde en nuestra base de datos. Al final del menú tenemos el botón de salir.

CLASE POO EXTRA

MapReduce

MapReduce es un framework introducido por Google para dar soporte a la computación paralela sobre grandes colecciones de datos en grupos de computadoras. Se han escrito implementaciones de MapReduce en C++, Java, Python y otros lenguajes.

Las funciones Map y Reduce están definidas ambas con respecto a datos estructurados en pares (clave, valor). Map toma uno de estos pares de datos con un tipo en un dominio de datos, y devuelve una lista de pares en un dominio diferente:

Map(k1,v1) -> list(k2,v2)

La función de mapeo es aplicada en paralelo para cada ítem en la entrada de datos. Esto produce una lista de pares (k2,v2) por cada llamada. Después de eso, el framework de MapReduce junta todos los pares con la misma clave de todas las listas y los agrupa, creando un grupo por cada una de las diferentes claves generadas.

La función reduce es aplicada en paralelo para cada grupo, produciendo una colección de valores para cada dominio:

Reduce(k2, list (v2)) -> list(v2)

Cada llamada a Reduce típicamente produce un valor v2 o una llamada vacía, aunque una llamada puede retornar más de un valor. El retorno de todas esas llamadas se recoge como la lista de resultado deseado.

Por lo tanto, el framework MapReduce transforma una lista de pares (clave, valor) en una lista de valores. Este comportamiento es diferente de la combinación "map and reduce" de programación funcional, que acepta una lista arbitraria de valores y devuelve un valor único que combina todos los valores devueltos por mapa.

Este ejemplo de MapReduce es un proceso para contar las apariciones de cada palabra en un conjunto de documentos:

map(String name, String document):
 // clave: nombre del documento
 // valor: contenido del documento
 for each word w in document:
   EmitIntermediate(w, 1);

reduce(String word, Iterator partialCounts):
 // word: una palabra
 // partialCounts: una lista parcial de la cuenta agregada
 int result = 0;
 for each v in partialCounts:
   result += ParseInt(v);
 Emit(result);

Aquí, cada documento es dividido en palabras, y cada palabra se cuenta con valor inicial "1" por la función Map, utilizando la palabra como el resultado clave. El framework reúne todos los pares con la misma clave y se alimenta a la misma llamada Reduce, por lo tanto, esta función sólo necesita la suma de todos los valores de su entrada para encontrar el total de las apariciones de esa palabra.

Taller de POO

8. Demo Parcial de Mi Proyecto

En este post les mostrare las funcionalidades que ahorita cuenta mi proyecto de la agenda personal, cuenta con los botones basicos como nuevo, modificar, salir, guardar y quitar. Aun me falta agregar varios eventos a varios botones, pero les mostrare como puedo agregar y quitar un contacto.

Aqui primero compilo mi programa y nos saldra el menu con las opciones correspondientes, despues de eso yo escogo el boton "Nuevo" y a continuacion se abren los campos de texto para rellenar el nombre, direccion, sexo, etc.

Una vez hecho esto, nos dirigimos al botón de "Guardar" y automáticamente se conectara a nuestra base de datos y almacenara en una tabla el contacto que acabamos de teclear, con su respectiva información.

Esto es todo lo que llevamos con el proyecto, aun faltan mas cosas como agregar las citas, pero eso espero y pronto poder implementarlo

Programación Orientada a Objetos

9. Detectar eventos, errores y excepciones en nuestro proyecto

Los eventos que tengo en el proyecto, es la ventana y botones, como el de nuevo, quitar, modificar, salir y guardar, asi como un boton aparte de busqueda, todo esto es el menu de mi proyecto. Tambien tengo una parte en donde se muestran la busqueda de mis contactos y clasifica segun el id, nombre, direccion y teléfono.

Entre los errores que e tenido es que no e podido lograr que se muestren los contactos de la búsqueda, pero lo arreglare muy pronto, ya que no no reconoce los contactos que están guardados en la base de datos.

Tambien me falta darle instrucciones a algunos botones como el de salir, ya que si presionamos ese boton no hace nada, ya que los otros tiene ya su funcion correspondiente.

------------------------------------------------------------------------------------------------------------

Try - catch

El bloque try contiene el código protegido que puede causar la excepción. Este bloque se ejecuta hasta que se produce una excepción o hasta completarse satisfactoriamente. Es posible utilizar más de una cláusula catch específica en la misma instrucción try-catch. En este caso, el orden de las cláusulas catch es importante, ya que las cláusulas catch se examinan por orden. Las excepciones más específicas se capturan antes que las menos específicas.

Ahora les mostrare una parte de mi código en donde utiliza el bloque try-catch, lo utilice en la interfaz gráfica, en el botón quitar, ya que nos pediría la confirmación si realmente queremos eliminar un contacto y aparte para mandar la información a la base de datos de querer eliminarlo.

---------------------------------------------------------------------------------------------------

private void jBQuitarActionPerformed(java.awt.event.ActionEvent evt) {

int resp = JOptionPane.showConfirmDialog(this,"Desea Realmente eliminar este contacto",

"Confirmacion", JOptionPane.YES_NO_OPTION);

if(resp == JOptionPane.YES_NO_OPTION){

try {

ContactoDatos datos = new ContactoDatos();

} catch (SQLException ex) {

Logger.getLogger(jTAgendadeContactos.class.getName()).log(Level.SEVERE, null, ex);

}

}

}

---------------------------------------------------------------------------------------------------

 

Taller de Programación Orientada a Objetos

*Clase con al menos 3 metodos

*Clase de prueba utilizando junit

public class caja

{
 private double ancho;
 private double altura;
 private double largo;
 public double volumen()
 {
 }
 return ancho*altura*largo;

 public void setAncho(double an) {
 ancho = an;
 }
 public void setAltura(double al){
 altura = al;
 }
 public void setLargo(double l){
 largo = l;
 }
 public double getAncho(){
 return ancho;
 }
 public double getAltura(){
 return altura;
 }
 public double getLargo(){
 return largo;
 }
}

public class Example{
public static void main (String args[]) {
caja primercaja = new caja(); // creación de la caja
primercaja.setancho(4.3);
primercaja.setaltura6.9);
primercaja.setlargo(3);
System.out.println("El volumen es " + primeraja.volumen());
}
}

Clase POO

No hay lonche gratis

'Gratis' nunca fue realmente gratis.

• Envío 100% gratis-- otra manera de decir que el costo de envío esta incluido en el costo del producto.
• Compra uno y el segundo es completamente gratis-- otra manera de decir que te dan un 50% de descuento.
• Muestra gratis-- otra manera de decir que necesitas comprarlo.
• Llévalo gratis ahorita, y paga después-- Se siente como gratis!, aunque sea por un momento.

 Pero claro, la palabra gratis es mágica. Por eso todo mundo la usa, y por eso todo mundo la busca

Por ejemplo este blog. Lo estas leyendo, gratis, y no tiene anunciantes. Entonces este sí es 100% gratis, o no? Tampoco. Lo estas pagando con tu tiempo, te esta costando tu atención. Y tu tiempo y atención mejoran mi reputación (No, no todo se paga con dinero). Lonche gratis o no, creo que lo interesante de esta discusión son los subsidos cruzados, y la manera en que puedes usar la palabra 'gratis' para generarle valor a tu negocio

Programación Orientada a Objetos

8. Antipatron de diseño



Un antipatrón de diseño es un patrón de diseño que invariablemente conduce a una mala solución para un problema.

Al documentarse los antipatrones, además de los patrones de diseño, se dan argumentos a los diseñadores de sistemas para no escoger malos caminos, partiendo de documentación disponible en lugar de simplemente la intuición.

Los antipatrones se consideran una parte importante de una buena práctica de programación. Es decir, un buen programador procurará evitar los antipatrones siempre que sea posible, lo que requiere su reconocimiento e identificación tan pronto como sea posible, dentro del ciclo de vida del software.

Algunos ejemplos de estos serian:

• Poltergeist

Esta mala práctica se refiere a objetos de un ciclo de vida corto cuya única función suele ser invocar métodos de otros objetos. Esto hace que crezca la dificultad para mantener el sistema. Suelen identificarse por su nombre: “start_”, “manager_”. La solución para evitarlos es eliminarlos y poner su funcionalidad en la clase a la que invocan.

• Spaghetti Code

Este antipatrón se refiere a un código mal estructurado, ausente de estructuras de control etc… Es frecuente cuando usamos GOTOs, programamos a base de interrupciones o excepciones etc. También es frecuentemente denominado “Código canguro” por lo contiguos saltos que hay que hacer en él para seguir el flujo de ejecución.

Programación Orientada a Objetos

8. Los Patrones de Diseño

Brindan una solución ya probada y documentada a problemas de desarrollo de software que están sujetos a contextos similares. Debemos tener presente los siguientes elementos de un patrón: su nombre, el problema (cuando aplicar un patrón), la solución (descripción abstracta del problema) y las consecuencias (costos y beneficios).

Los patrones de diseño son relativamente fáciles de comprender, no son nada del otro mundo. Lo que a veces se hace complejo es utilizarlos. Por ello hay que conocerlos bien, especialmente los más importantes, porque realmente facilitan el trabajo, y sobre todo, hacen el código más legible. 

Clasificación:

• Creacionales: El objetivo de estos patrones es de abstraer el proceso de instanciación y ocultar los detalles de cómo los objetos son creados o inicializados.
• Estructurales: Los patrones estructurales describen como las clases y objetos pueden ser combinados para formar grandes estructuras y proporcionar nuevas funcionalidades.
• Comportamiento: Los patrones de comportamiento nos ayudan a definir la comunicación e iteración entre los objetos de un sistema.

Aquí 2 ejemplos de patrones de diseño serían los siguientes:

PATRON COMPOSITE (ESTRUCTURAL)

sirve para construir objetos complejos a partir de otros más simples y similares entre sí, gracias a la composición recursiva y a una estructura en forma de árbol.

Esto simplifica el tratamiento de los objetos creados, ya que al poseer todos ellos una interfaz común, se tratan todos de la misma manera.

PATRON BUILDER (CREACIONAL)

Como Patrón de diseño, el patrón builder (Constructor) es usado para permitir la creación de una variedad de objetos complejos desde un objeto fuente (Producto), el objeto fuente se compone de una variedad de partes que contribuyen individualmente a la creación de cada objeto complejo a través de un conjunto de llamadas a interfaces comunes de la clase Abstract Builder.



Taller de POO

DIAGRAMA UML

Para crear el siguiente diagrama de clases hice uso del software BOUML  que permite definir y generar código en C++, Java, Idl y PHP. Es compati
ble con Unix/Linux/Solaris, MacOS X y Windows, es muy rápido y no requiere mucha memoria para manejar varios miles de clases.

Crisis del Software

Crisis del software era un término usado en los días tempranos de tecnología de dotación lógica, antes de él estaba un tema establecido. El término fue utilizado para describir el impacto de aumentos rápidos en energía de computadora y la complejidad de los problemas que podrían ser abordados. Esencialmente, refiere a la dificultad de la escritura correcta, comprensible, y comprobable programas de computadora. Las raíces de la crisis del software son complejidad, expectativas, y cambio.

Los requisitos que estaban en conflicto han obstaculizado siempre el proceso del desarrollo del software. Por ejemplo, mientras que los usuarios exigen una gran cantidad de características, los clientes desean generalmente reducir al mínimo la cantidad que deben pagar por el software y el tiempo requeridos para su desarrollo.

El término crisis del software fue acuñado cerca F. L. Bauer en la primera conferencia de la tecnología de dotación lógica de la OTAN adentro 1968 en Garmisch, Alemania. Un uso temprano del término está adentro Edsger Dijkstra's 1972 Concesión de ACM Turing Dé una conferencia, “el programador humilde” (EWD340), publicado en Comunicaciones del ACM. Estados de Dijkstra.

Las causas de la crisis del software fueron ligadas a la complejidad total del proceso del software y a la inmadurez relativa de la tecnología de dotación lógica como profesión. La crisis se manifestó de varias maneras:

• Proyectos que funcionan el sobre-presupuesto.
• Proyectos que funcionan en horas extras.
• El software estaba de baja calidad.
• El software no resolvió a menudo requisitos.
• Los proyectos eran unmanageable y código difíciles de mantener.

Vario procesos y metodologías se han convertido sobre las últimas décadas “domestican” la crisis del software, con grados que variaban de éxito. Sin embargo, se conviene extensamente que hay ninguna “bala de plata” que es, ningún acercamiento que prevendrá los sobrantes y las faltas del proyecto en todos los casos. Generalmente proyectos del software que son grandes, complicados, pobre-especificado, e implican aspectos desconocedores, siguen siendo particularmente vulnerables a los problemas grandes, inesperados.

Programacion orientada a objetos

DOCUMENTACION EN DOXYGEN

 

El programa que use para hacer la prueba de documentacion de las clases de mi proyecto fue con el Doxygen, lo instale en Windows 7.

Instalado y todo precedemos a montar los archivos de las clases para que nos lo muestre en una pagina HTML.

-------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------

Avance de clases en el proyecto final

En este avance identificamos las clases que usaremos
mientras para el proyecto, en esta clase llamada Usuarios 
es donde se registraran obviamente las personas que agreguemos, cuenta 
con una "id", "nombre", "apellido", "telefono", "celular", "correo"
"direccion".
-------------------------------------------------------------------------
public class Contacto {

   private Long id;
   private String nombre;
   private String direccion;
   private String telefono;
   private String email;
   private String sexo;

   public String getDireccion() {
       return direccion;
   }

   public void setDireccion(String direccion) {
       this.direccion = direccion;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getNombre() {
       return nombre;
   }

   public void setNombre(String nombre) {
       this.nombre = nombre;
   }

   public String getSexo() {
       return sexo;
   }

   public void setSexo(String sexo) {
       this.sexo = sexo;
   }

   public String getTelefono() {
       return telefono;
   }

   public void setTelefono(String telefono) {
       this.telefono = telefono;
   }


}
-------------------------------------------------------------------------
En esta clase usaremos las Citas programadas, que
contaran con tambien un "id", "el nombre del contacto", 
"fecha", "hora" y "evento".

public class Cita {
int id;
Contacto contacto;
String direccion;
String fecha;
String hora;
String evento;

public Cita() {
}

public String getevento() {
    return evento;
}

public void setevento(String evento) {
    this.evento = evento;
}

public Contacto getContacto() {
    return contacto;
}

public void setContacto(Contacto contacto) {
    this.contacto = contacto;
}

public String getFecha() {
    return fecha;
}

public void setFecha(String fecha) {
    this.fecha = fecha;
}

public String getHora() {
    return hora;
}

public void setHora(String hora) {
    this.hora = hora;
}

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getDireccion() {
    return lugar;
}

public void setDireccion(String direccion) {
    this.direccion = direccion;
}

}
------------------------------------------------------------------------

Proyecto final

En el proyecto final, trataremos de crear una agenda personal, primeramente con los aspectos basicos que debe de tener, como dar de alta un contacto, con sus respectivos detalles (nombre, direccion, telefono, email, datos personales, etc) o darlo de baja. Tambien agregaremos las opciones de busqueda, editar, borrar, cambiar, etc. Con el paso del tiempo iremos agregando mas funciones, como que se conecte a una base de datos y se guarden y actualizen todo lo que el usuario quiera. El programa lo realizaremos con Java, y despues veremos si lo pasamos a Android.

Herramientas que usaremos:

• jdk java development kit
• Linux
• emacs para escribir el codigo
• Mysql para la base de datos
• Android para dispositivos moviles

En el programa usaremos objetos como "agenda", "contactos", "busqueda", "menu", entre otros, cada uno con sus respectivos metodos y clases.

Integrantes: Alejandro Josafat Loera Ramirez

Blanca Gabriela Martinez Ponce