Talleres
"Las personas son más importantes que cualquier proceso.
Buenas personas con un buen proceso siempre actuarán mejor
que buenas personas sin procesos". <Grady Booch>
El Proceso Unificado se ha convertido en un proceso de desarrollo
de software de gran éxito para la construcción de sistemas orientados
a objetos. En particular, se ha adoptado ampliamente el Proceso
Unificado de Rational o RUP (Rational Unified Process).
El Proceso Unificado (PU) combina "buenas prácticas", tales como
ciclo de vida iterativo y desarrollo guiado por el riesgo. Es un buen
ejemplo de proceso para introducir el A/DOO.
En este enfoque, el desarrollo se organiza en una serie de mini-proyectos
cortos, de duración fija (p.ej. cuatro semanas) llamados iteraciones; el
resultado de cada uno es un sistema que puede ser probado, integrado y
ejecutado. Cada iteración incluye sus propias actividades de análisis de
requisitos, diseño, implementación y pruebas.
El ciclo de vida iterativo se basa en la ampliación y refinamiento sucesivos
del sistema mediante múltiples iteraciones, con retroalimentación cíclica y
adaptación como elementos principales que dirigen para converger hacia un
sistema adecuado. El sistema crece incrementalmente a lo largo del tiempo,
iteración tras iteración, y por ello, éste enfoque también se conoce como
desarrollo iterativo e incremental.
¿Por qué un desarrollo iterativo e incremental?
En pocas palabras... para obtener un software mejor.
Con más palabras...
<> Para afrontar los riesgos críticos y significativos desde el principio.
<> Para poner en marcha una arquitectura que guíe el desarrollo del
software.
<> Para facilitar un marco de trabajo que gestione de mejor forma los
inevitables cambios en los requisitos y en otros aspectos.
<> Para lograr una temprana retroalimentación, compromiso de los usuarios y adaptación, que nos lleva a un sistema refinado que se ajusta más a las necesidades reales del personal involucrado.
<> Para construir el sistema a lo largo del tiempo en lugar de hacerlo de
una sola vez cerca del final, cuando el cambiar algo se ha vuelto costoso.
<> Para proporcionar un proceso de desarrollo a través del cual el personal puede trabajar de manera más eficiente.
Desarrollo dirigido por Casos de Uso en pocas palabras...
<> Un caso de uso es una secuencia de acciones que el sistema lleva a cabo para ofrecer algún resultado observable de valor para un actor concreto. Se utiliza para captura de requisitos de sistemas software en general.
<> Un modelo de casos de uso está compuesto por todos los actores y todos los casos de uso de un sistema.
<> Los actores son el entorno del sistema. No todos los actores representan a personas. Pueden ser actores otros sistemas o hardware externo que interactuará con el sistema. Los actores se comunican con el sistema mediante el envío y recepción de mensajes.
Trabajo colaborativo:
1.) Un proyecto PU organiza el trabajo y las iteraciones en cuatro fases
fundamentales. Explíquelas.
2.) ¿Cómo se relacionan los casos de uso y la arquitectura?
3.) Elabore un diagrama parcial de casos de uso para un sistema
Hotel
4.) ¿Cuáles son los modelos del PU que representan al sistema como un todo?
5.) Un sistema de información orientado a objetos típico se diseña en función de varias capas arquitectónicas o subsistemas. Cuáles son?
___________________________________________________________________________________________
La siguiente es la forma de representar gráficamente una Clase en UML: Un rectángulo dividido verticalmente en tres secciones.
|
Notación gráfica de una Clase en UML |
Ejemplo de una Clase |
|
|
|
6.) Crear instancias de la clase CuentaBanco en un arreglo de objetos e implementar las funciones para leer_cuenta, actualizar_saldo y mostrar_cuenta. El saldo se actualiza según la transacción realizada por el cliente(1. Consignación, 2. Retiro). La transacción y el saldo mínimo en cada cuenta debe ser de $20000. Utilizar compilación separada de clases.
7.) Codificar el siguiente programa orientado a objetos en C++ :
El problema que se presenta frecuentemente en las finanzas domésticas es determinar cuánto dinero se acumulará en una cuenta en el banco después de N años si se deposita inicialmente una cantidad conocida P, y la cuenta acumula anualmente interés a un porcentaje i. La cantidad futura se puede determinar mediante la conocida fórmula de interés compuesto: F = P(1 + i)^N
#include "iostream.h"
#include "math.h"
#include "conio.h"
#include "iomanip.h"
// Clase interés compuesto
class INTERESC {
public:
INTERESC(void);
void cambiar(float cap1, float inter1, int tiemp1);
float valorf(void){
return(P*pow(1 + i),N);
}
~INTERESC(void);
private:
float capital, interesc;
int tiempo;
}
8.)
// El siguiente programa ilustra el uso de la herencia múltiple del C++
#include <iostream.h>
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#define cls clrscr()
class Monitor_video{
public:
void setdatos(){
cout << "Tipo : ";gets(tipo);
cout << "Colores : ";cin >> colores;
cout << "Resolucion X: ";cin >> resx;
cout << "Resolucion Y: ";cin >> resy;
}
void getdatos(){
cout << "Tipo : " << tipo << endl;
cout << "Colores : " << colores << endl;
cout << "Resolución X: " << resx << endl;
cout << "Resolución Y: " << resy << endl << endl;
}
private:
char tipo[30];
long colores;
int resx, resy;
};
class Tarjeta_ppal{
public:
void setdat_tp(){
cout << "Procesador : ";cin >> proces;
cout << "Velocidad : ";cin >> veloc;
cout << "Memoria : ";cin >> memor;
}
void getdat_tp(){
cout << "Procesador : " << proces << endl;
cout << "Velocidad : " << veloc << endl;
cout << "Memoria : " << memor << endl << endl;
}
private:
int proces, veloc, memor;
};
class Pc : public Monitor_video, public Tarjeta_ppal{ // Herencia multiple
public:
void setdat_pc(){
setdatos();
setdat_tp();
cout << "Marca : ";gets(marca);
cout << "Disco duro : ";cin >> discod;
cout << "Disco flexible: ";cin >> discof;
}
void getdat_pc(){
getdatos();
getdat_tp();
cout << "Marca : " << marca << endl;
cout << "Disco duro : " << discod << endl;
cout << "Disco flexible: " << discof << endl;
}
private:
char marca[30];
int discod;
float discof;
};
void main(void){
Pc comp;
cls;
comp.setdat_pc();
cls;
comp.getdat_pc();
sleep(5);
}
// TALLER DE PROGRAMACIÓN:
// a) Realizar compilación separada de clases
// b) Construir un ciclo indeterminado para leer por teclado los objetos
// c) Derivar la clase 'EstacionDeTrabajo'.
----------------------------------------------------------------------
9.). Crear en C++ la clase Docente y derivar las clases DocenTC y Catedratico. Cada clase tendrá una función setDatos( ) y otra función getDatos( ). Escribir un POO que lea por teclado un arreglo de instancias de cada clase derivada, según la elección del usuario, implementar una función miembro para calcular el sueldo de los objetos de la clase Catedratico y otra función para determinar el mayor sueldo de los objetos de la clase DocenTC.
----------------------------------------------------------------------
Talleres de POO en lenguaje JAVA
10.) Una aplicación interesante de los computadores, es dibujar gráficos de barra (a veces llamados "histogramas"). Escriba un programa que especifique la clase Histograma y lea 10 números (cada uno de ellos entre 1 y 25). Para cada uno de los números leídos, su programa deberá imprimir una línea, conteniendo dicho número en asteriscos adyacentes. Por ejemplo, si se lee por teclado el número 7, el programa deberá imprimir *******.
11.) Crear en Java la clase PersonalMedico y derivar las clases Medico y Enfermera. Cada clase tendrá un método setDatos( ) y otro método getDatos( ). Escribir un POO en modo gráfico que lea por teclado un arreglo de instancias de las clases derivadas, implementar los métodos para consultar una enfermera y actualizar la especialidad del médico.
___________________________________________________________________________________________
// Programa: EntAleatorio.java
// Enteros aleatorios escalados y desplazados
import javax.swing.JOptionPane;
public class EntAleatorio {
public static void main( String args[] )
{
int valor;
String output = "";
for ( int i = 1; i <= 20; i++ ) {
valor = 1 + (int) ( Math.random() * 7 );
output += valor + " ";
if ( i % 5 == 0 )
output += "\n";
}
JOptionPane.showMessageDialog( null, output,
"20 números aleatorios del 1 al 7",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
} // fin de main
} // fin de la clase EntAleatorio
// TALLER: Modificar el programa cambiando ciclo for por while y do/while.
**********************************************************
// Programa: TiraDados.java
// Tira 6000 veces un dado de seis lados
import javax.swing.*;
public class TiraDados {
public static void main( String args[] )
{
int frecuencia1 = 0, frecuencia2 = 0,
frecuencia3 = 0, frecuencia4 = 0,
frecuencia5 = 0, frecuencia6 = 0, cara;
// resume los resultados
for ( int tiro = 1; tiro <= 6000; tiro++ ) {
cara = 1 + (int) ( Math.random() * 6 );
switch ( cara ) {
case 1:
++frecuencia1;
break;
case 2:
++frecuencia2;
break;
case 3:
++frecuencia3;
break;
case 4:
++frecuencia4;
break;
case 5:
++frecuencia5;
break;
case 6:
++frecuencia6;
break;
} // fin de switch
} // fin de for
JTextArea areaSalida = new JTextArea( 7, 10 );
areaSalida.setText(
"Cara\tFrecuencia" +
"\n1\t" + frecuencia1 +
"\n2\t" + frecuencia2 +
"\n3\t" + frecuencia3 +
"\n4\t" + frecuencia4 +
"\n5\t" + frecuencia5 +
"\n6\t" + frecuencia6 );
JOptionPane.showMessageDialog( null, areaSalida,
"Lanzando 6000 veces un dado",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
} // fin de main
} // fin de la clase TiraDados
// TALLER: Modificar el programa para almacenar las frecuencias en un arreglo.
**********************************************************
// Un Applet de Java para leer un arreglo.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Ap extends Applet{
private TextField tf;
private Button bt;
private Button bs;
public int top = 0;
public float ar[] = new float[10];
public void init(){
tf = new TextField(10);
bt = new Button("Ok");
bs = new Button("Sum");
add(tf);
add(bt);
add(bs);
//listeners
bt.setActionCommand("boton_Ok");
bt.addActionListener(new MyActionListener());
bs.setActionCommand("boton_Sum");
bs.addActionListener(new MyActionListener());
}
/*
public void paint(Graphics g){
}
*/
//clase inner
class MyActionListener implements ActionListener{
//metodos evento
public void actionPerformed(ActionEvent e){
String c= e.getActionCommand();
String tem;
float sum=0;
if(c.equals("boton_Ok")){
tem = tf.getText();
if(top<10){
ar[top] = Float.parseFloat(tem);
tf.setText("");
top++;
}
}
if(c.equals("boton_Sum")){
for(int i=0;i<top;i++){
sum = sum + ar[i];
}
tf.setText(String.valueOf(sum));
}
tf.requestFocus();
}
}
} // TALLER: Visualizar el arreglo en orden descendente.
*********************************************************
<APPLET code="Ap.class" width = 500 heigth = 100>
</APPLET>
----------------------------------------------------------------------------
// Herenciap.java
// Declaracion de clase base y clases derivadas
import java.io.*;
class Publicacion{
private String editor,titulo;
private long fecha;
public void setDatos(String editor,String titulo,long fecha){
this.editor = editor;
this.titulo = titulo;
this.fecha = fecha;
}
public void getDatos(){
System.out.println("\nEDITOR : "+editor);
System.out.println("TITULO : "+titulo);
System.out.println("FECHA : "+fecha);
}
}
class Revista extends Publicacion{
private int numxano;
private long circula;
public void setDatosRev(int numxano, long circula){
this.numxano = numxano;
this.circula = circula;
}
public void getDatosRev(){
System.out.println("\nNUMEROS POR AÑO : "+numxano);
System.out.println("CIRCULACION : "+circula);
}
}
class Libro extends Publicacion{
private String ISBN;
private String autor;
public void setDatosLib(String ISBN, String autor){
this.ISBN = ISBN;
this.autor = autor;
}
public void getDatosLib(){
System.out.println("\nISBN : "+ISBN);
System.out.println("AUTOR : "+autor);
}
}
public class Herenciap{
public static void main(String arg[]){
Libro lib = new Libro();
lib.setDatos("McGraw-Hill","Programacion en Java2",990707);
lib.setDatosLib("84-481-2015-9","Joyanes Aguilar Luis");
lib.getDatos();
lib.getDatosLib();
}
}
// Taller de programación: Leer un arreglo de instancias de la
// clase derivada CD
---------------------------------------------------------------------------------
Es hora de familiarizarse con el código de Visual FoxPro. Para empezar, trate de comprender y ejecutar los siguientes archivos:
*** Main.prg
* Crea un ambiente inicial para una aplicación
*** GMV <9/9/2002>
set notify off
clear events
set echo off
set escape off
set clock off
set console off
set exclusive off
set intensity on
set talk off
set multilocks on
set deleted on
set exact on
set safety off
set near on
set sysmenu off
set century on
set status bar on
set date dmy
deactivate windows "standar"
_SCREEN.CAPTION = "ORIENTACIÓN A OBJETOS"
_Screen.MinButton = .T.
_Screen.MaxButton = .T.
_Screen.movable = .F.
_Screen.closable = .F.
public Fecha_sis,Hora_sis,Fecha_proc, Lmenus
*** Para definir PATHS ***
Lmenus = "\GMV\POO\MENUS\"
Fecha_sis = date()
Hora_sis = datetime()
Fecha_proc = date()
clear
@32,(wcols()-txtwidth("Fecha del Sistema:
"+dtoc(Fecha_sis),'Courier',13)*fontmetric(6,'courier',13)/fontmetric(6))/2;
say "Fecha Sistema: "+dtoc(Fecha_sis)font 'courier',13 style
"BT";
color RGB(0,0,255)
*** Library.prg
* Archivo de funciones y procedimientos
FUNCTION ExisTabla
*** Esta función permite validar la existencia de una tabla
*** específica en la Base de Datos
lparameters xestruc, xfisic
if pcount() < 1 or empty(xestruc)
return .F.
endif
local dev
public pfisic
xestruc = upper(alltrim(xestruc))
pfisic = ""
dev = .F.
if empty(xfisic)
pfisic = nombre_fisico(xestruc)
else
pfisic = upper(alltrim(xfisic))
endif
if file(Lbase + pfisic + 'DBF')
dev = .T.
else
dev = .F.
endif
RETURN dev
PROCEDURE Escritorio
*** Permite crear un ambiente de escritorio
parameters ptitulo, ptapiz, picono
ptitulo = "Programación Orientada a Objetos " + ptitulo
modify window screen;
title ptitulo;
font "MS Sans Serif",7;
float;
noclose;
minimize;
fill file &ptapiz;
icon file &picono;
RETURN
¿Cómo crear una Clase en Visual FOXPRO?
DEFINE CLASS miclase AS Custom
Nombre = " "
Tipo = " "
Es_nuevo = .F.
PROCEDURE Visualizar
?This.Nombre
?This.Tipo
IF This.Es_nuevo
?"Soy nuevo!"
ELSE
?"Soy antiguo!..."
ENDIF
ENDPROC
ENDDEFINE
Clases compuestas en VFP
DEFINE CLASS saludo AS Form
ADD OBJECT miboton AS CommandButton
WITH CAPTION = "Hola, mis pescaos!!!"
HEIGHT = 50
ENDDEFINE
Polimorfismo en VFP
OBJinterruptor = CREATEOBJECT("Interruptor")
OBJtelefono = CREATEOBJECT("Telefono")
OBJinterruptor.switch( )
OBJtelefono.switch( )
