Ligas a Youtube

Taller de programacion orientada a objetos --> http://www.youtube.com/watch?v=wZz6-utFd8U

Programacion orientada a objetos --> http://www.youtube.com/watch?v=NfG67dhk86M

Proyecto Final (Resumen)

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

POO (session 11)

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 tip

o 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.

TALLER POO

Tipos de sistemas distribuidos

Se clasifican los sistemas cliente servidor de

acuerdo al nivel de abstracción del servicio que se

ofrece. Se distinguen tres componentes básicos de

software:

1-Interaccion con el usuario

2-Logica de aplicacion

3-Repositorio de datos

Los sistemas distribuidos necesitan un software distinto al de los sistemas centralizados. Los S. O. para sistemas distribuidos han tenido importantes desarrollos pero todavía existe un largo camino por recorrer.

Ventajas de los sistemas distribuidos con respecto de los centralizados.

Economía: es la razón número uno de la tendencia hacia los sistemas distribuidos ya que estos sistemas tienen en potencia una proporción precio/desempeño mucho mejor que la de un sistema centralizado.

Velocidad: un sistema distribuido puede tener mayor poder de cómputo que una mainframe.

Distribución inherente: otra razón para la construcción de un sistema distribuido es que ciertas aplicaciones son distribuidas en forma inherente; es decir, algunas aplicaciones utilizan máquinas que están separadas a cierta distancia.

Confiabilidad: un sistema distribuido ofrece mayor confiabilidad: al distribuir la carga de trabajo en muchas máquinas, la falla de un circuito descompondrá a lo más una máquina y el resto seguirá intacto.

Crecimiento por incrementos: si se necesita añadir poder de cómputo a la compañía, con un sistema distribuido, podrían añadirse sólo más procesadores al sistema, lo que permite un desarrollo gradual conforme surjan las necesidades.

Desventajas de los diferentes sistemas distribuidos

Software: No hay mucha experiencia en el diseño, implantación y uso del software distribuido, además existe poco software para los sistemas distribuidos en la actualidad.

Redes: Una vez que el sistema llega a depender de la red, la pérdida o saturación de ésta puede negar algunas de las ventajas que el sistema distribuido debía conseguir.

Seguridad: si las personas pueden tener acceso a los datos en todo el sistema, entonces también pueden tener acceso a datos con los que no tienen nada que ver.

1. 1. 
      

Taller POO (Interfaz Grafica)

En la interfaz grafica para nuestro proyecto utilizamos diversos botones llamados Jbutton, utilizamos 6 botones en total, y a cada boton tuvimos que cambiarle el valor de la variable, para que al momento de usar el codigo, cada boton sea independiente y le podamos dar las instrucciones adecuadas. Tambien insertamos campos de texto para cada dato del usuario. Al momento de querer insertar un contacto los campos de texto estan desabilitados, pero al hacer click en nuevo se activan para poder ingresar los datos.

Aqui podemos ver como los campos de id, direccion, telefono, nombre, direccion y sexo estan desactivados, despues de hacer click en el boton nuevo los campos se activan, menos el dato "id" ya que si cambiamos ese dato nos pondra un error, ya que se va agregando automaticamente y no podremos cambiarlo.

Un ejemplo de los botones fue el que usamos para el boton Nuevo, ya que cuando seleccionamos este boton habilita los campos de texto y podemos ingresar texto o numeros.

POO (session 10)

Interfaz Gráfica de Usuario

La interfaz gráfica de usuario, conocida también como GUI es un programa informático que actúa de interfaz de usuario, utilizando un conjunto de imágenes y objetos gráficos para representar la información y acciones disponibles en la interfaz. Su principal uso, consiste en proporcionar un entorno visual sencillo para permitir la comunicación con el sistema operativo de una máquina o computador.

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.

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.

Extra POO

Frase "No hay lonche gratis"

Entre el significado que le podemos encontrar a esta frase, es que no llegará el día en que un descubrimiento milagroso, un invento mágico, un genio, resuelva todos nuestros problemas, y nunca llegara algo similar. Es decir, se podría argumentar que ciertos inventos han transformado radicalmente la vida del hombre, mejorando significativamente sus comodidades. Sí, pero no

resolvieron todo y no fueron gratis.

Ningún invento nos salvará milagrosamente de la crisis

energética , o de otro problema grande que se nos presente,

tendremos que ir paso a paso,

incrementando eficiencias, buscando fuentes alternas, mejorando la seguridad de

los procesos nucleares, reduciendo el consumo; en fin, usando todas las

herramientas a nuestra disposición para atacar el problema. Y no será gratis.

Taller de POO 8 (Demo parcial)

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

POO (session 9)

Eventos, errores y excepciones

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. Otros botones con los que contamos son con 4 Jbutton, estos botones nos permite darles instrucciones, como el de identificar el botón de usuario y contraseña, además de otros dos botones que son el de “aceptar” y “cancelar” como el nombre nos lo indica, el primero botón hace que pasemos a la siguiente ventana que es la interfaz donde manejaremos nuestros contactos, y el botón cancelar hace que se cierre la ventana automáticamente. El usuario y contraseña lo puse por defecto en el código, pero se puede cambiar cuando se necesite. También agregamos campos de texto para poder ingresar los datos, estos son llamados TextField, y lo acomode en el botón de usuario, por otra parte hay un campo de texto especial por si uno desea poner una contraseña, así lo aplique para poder ingresar nuestra contraseña.

Aquí aparece la parte del código, es corto, y además fácil, pero muy eficiente, le dimos la instrucción de que primero apareciera la ventana del login, después de esto al introducir el usuario y contraseña nos mandara directamente a la página 2, a la otra ventana que tenemos hecha.

Excepciones: dentro de las excepciones en nuestro proyecto se encuentran varias, ya que las use más que nada en los botones que use en la interfaz. 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 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 en nuestro proyecto si fueron varios, por ejemplo, al momento de hacer la búsqueda de un contacto en la tabla aparecían celdas de más, o por ejemplo cuando escribíamos un nombre en el cuadro de búsqueda nos aparecían la mayoría de los contactos. Otro error 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, en tanto a los otros errores también pudimos solucionarlos con éxito.

POO (sesion 8)

Patrones de diseño

Los patrones de diseño son la base para la búsqueda de soluciones a problemas comunes en el desarrollo de software y otros ámbitos referentes al diseño de interacción o interfaces. Los patrones de diseño se pueden clasificar en 3 grupos:

1. Patrones creacionales
2. Patrones estructurales
3. Patrones de comportamiento
   

Existen en total 23 patrones de diseño, con sus respectivas funciones y aqui pondre dos ejemplos.

• Command: Este patrón permite solicitar una operación a un objeto sin conocer realmente el contenido de esta operación, ni el receptor real de la misma. Para ello se encapsula la petición como un objeto, con lo que además se facilita la parametrización de los métodos

Propósito: Encapsula un mensaje como un objeto, con lo que permite gestionar colas o registro de mensaje y deshacer operaciones, soportar restaurar el estado a partir de un momento dado, y Ofrecer una interfaz común que permita invocar las acciones de forma uniforme y extender el sistema con nuevas acciones de forma más sencilla

• Mediator: Cuando muchos objetos interactúan con otros objetos, se puede formar una estructura muy compleja, con objetos con muchas conexiones con otros objetos. En un caso extremo cada objeto puede conocer a todos los demás objetos. Para evitar esto el patrón Mediator encapsula el comportamiento de todo un conjunto de objetos en un solo objeto.

Aplicabilidad:

• Un conjunto grande de objetos se comunica de una forma bien definida, pero compleja.
• Reutilizar un objeto se hace difícil por que se relaciona con muchos objetos.
• El comportamiento de muchos objetos que esta distribuido entre varias clases, puede resumirse en una o variaspor subclasificación.

Antipatrones de diseño

Un antipatrón de diseño es un patron de diseño que invariablemente conduce a una mala solución para un problema.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.

El concepto de antipatrón se puede aplicar a la ingenieria en general, e incluso a cualquier tarea realizada por el hombre. Aunque no se escucha con frecuencia fuera del campo ingenieril, la noción está ampliamente extendida.

Entre estos patrones existen varias clasificaciones, en donde se encuentran numerosos antipatrones, a continuacion les dejo sus categorias:

• Antipatrones de gestión
• Antipatrones de gestión de proyectos
• Antipatrones generales de diseño de software
• Antipatrones de diseño orientado a objetos
• Antipatrones de programación
• Antipatrones metodológicos
• Antipatrones de gestión de la configuración

Taller de programacion

Diagrama de ejemplo con BOUML

Este es un ejemplo del diagrama hecho con el programa BOUML, donde podemos indentificar mas facilmente las clases, metodos y operaciones del programa.

Proyecto presentacion

Proyecto

View more presentations from dani.

Documentacion en doxygen

Programacion orientada a objetos

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", "direccion", "telefono", "email" y "sexo"
-------------------------------------------------------------
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; }  }

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

Taller de programacion orientada a objetos

Programa con varias clases multiples (3 clases)

Este programa que intente realizar es sencillo, ya que nos muestra el ID y el saldo de un cliente, este programa tiene 3 clases: Principal, Cliente y Cuenta.

--------------------------------------------------------------------------------------------------------------------------------------
en la clase Principal, le damos la instruccion que muestre el valor y el sueldo del cliente 1 (c1) y nos lo muestre en la pantalla, aqui le asignamos un numero de cliente y numero de cuenta que en la siguiente clase la declaramos privados
--------------------------------------------------------------------------------------------------------------------------------------

public class Principal {
public static void main (String[] args) {
Cliente c1 = new Cliente("1453478","Alejandro");
Cuenta cuenta1 = new Cuenta(c1,"001",25000);

System.out.print("Nombre:" + cuenta1.getCliente().getNombre());
System.out.println("Saldo:" + cuenta1.getSaldo());
}
}
--------------------------------------------------------------------------------------------------------------------------------------
en esta clase Cliente le damos las instrucciones para que se le asigne el nombre del id y del nombre, dandole atributos privados.


public class Cliente {
private String id;
private String nombre;

public Cliente(String id,String nombre) {
this.id=id;
this.nombre=nombre;

}

public String getId(){
return id;
}
public String getNombre(){
return nombre;
}
}
--------------------------------------------------------------------------------------------------------------------------------------
en la ultima clase que es Cuenta, es casi lo mismo que la clase anterior, que es para asignarle el numero de cuenta que es privado.

public class Cuenta {
private Cliente cliente;
private String numCuenta;
private double saldo;

public Cuenta(Cliente cliente,String numCuenta,double saldo){
this.cliente=cliente;
this.numCuenta=numCuenta;
this.saldo=saldo;
}

public Cliente getCliente() {
return cliente;
}
public String getNumCuenta() {
return numCuenta;
}
public double getSaldo(){
return saldo;
}
}

Crisis del Software

El término más conocido es "crisis del software", referida no tan solo a la época en que se comenzaron a desarrollar sistemas de software de tamaño mediano y grande, en la década de 1960, sino también en la actualidad, en pleno siglo XXI. La crisis del software es la falta de capacidad de las organizaciones que producen software para dominar la complejidad inherente del software y desarrollar productos en tiempo y forma pactado. Algunas referencias útiles para comprender cuáles eran los conocimientos estables para el desarrollo de software en 1968 son:

• En 1962 se publicó el primer algoritmo para búsquedas binarias

• C.Böhm y G. Jacopini publicaron en 1966 el documento que creaba una fundación para la eliminación de "GoTo" y la creación de la programación estructurada.

• En 1968 los programadores se debatían entre el uso de la sentencia GoTo, y la nueva idea de programación estructurada; ese era el caldo de cultivo en el que Edsger Dijkstra escribió su famosa carta "GoTo Statement Considered Harmful" en 1968.

Por último, las aplicaciones de hoy en día son programas muy complejos, inabordables por una sola persona. En sus comienzos se valoró como causa también la inmadurez de la ingeniería de software, aunque todavía hoy en día no es posible realizar estimaciones precisas del coste y tiempo que necesitará un proyecto de software.

Englobó a una serie de sucesos que se venían observando en los proyectos de desarrollo de software:

• Los proyectos no terminaban en plazo.
• Los proyectos no se ajustaban al presupuesto inicial.
• Baja calidad del software generado.
• Software que no cumplía las especificaciones.
• Codigo inmantenible que dificultaba la gestión y evolución del proyecto.

En clase vimos un ejemplo de como hace tiempo en un aeropuerto hubo muchas fallas en un sistema para organizar el equipaje, esto se debio al mal desarrollo de este proyecto y a la pesima calidad que se le puso, aqui les dejo un video de como en una conferencia de microsoft surge el famoso error de "la pantalla azul de la muerte" , esto quiere decir que ni grandes empresas como Microsoft estan invulnerables a este tipo de fallas y queda mucho por arreglar.

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

Gabriela Martinez Ponce

Clase: Taller de programacion orientada a objetos

Practica 1

Herramientas

Las herramientas que utilizare para el avance del curso sera Python, ya que se me hace un lenguaje sencillo pero potente. Ubuntu por defecto ya cuenta con varios lenguajes de programación, por lo que ya cuenta con en lenguaje Python.

Python es un lenguaje de programación de alto nivel cuya filosofía hace hincapié en una sintaxis muy limpia y que favorezca un código legible.
Se trata de un lenguaje de programación multiparadigma ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación multifuncional. Es un interpretado, usa tipado dinámico, es fuertemente tipado y es multiplataforma.
Este es un programa sencillo que hice en python, que muestra las poblaciones de 4 ciudades en total
--------------------------------------------------------------------------------------------------------------------------------------
#le damos nombre a la clase u objeto, aqui solo pongo un objeto
class Ciudad:
#despues de esto con la instruccion def_init_ le damos valores a los atributos, en este caso ciudad y habitantes, y las instrucciones para los metodos
def __init__(self, ciudad, habitantes):

self.nombrec = ciudad
self.habitantes = habitantes
def getNombre(self):
return self.nombrec

def getNumeroHabitantes(self):
return self.habitantes
def main():
#aqui ponemos las ciudades y el numero de habitantes que aparezcan en la pantalla
ciudad1 = Ciudad("Madrid", 170.187)
ciudad2 = Ciudad("Cataluna", 143.933)
ciudad3 = Ciudad("Monterrey", 1.130960)
ciudad4 = Ciudad("Paris", 2.193031)
#mandamos a imprimir los numeros de habitantes con sus respectivas ciudades
print ciudad1.getNombre()
print ciudad1.getNumeroHabitantes()
print ciudad2.getNombre()
print ciudad2.getNumeroHabitantes()
print ciudad3.getNombre()
print ciudad3.getNumeroHabitantes()
print ciudad4.getNombre()
print ciudad4.getNumeroHabitantes()
main()
#fin del programa #alejandro josafat-1453478
--------------------------------------------------------------------------------------------------------------------------------------

Captura de pantalla

Fuentes:
me base en los métodos y atributos de la siguiente pagina
http://www.linuxhispano.net/2009/10/29/metodos-estaticos-en-python/

Dra. Sara no pude como poner el syntax highlight espero y poder preguntarle para corregirlo