Desarrollo Elemental OO

Dearrollo Elemental OO Hoja 1
DESARROLLO
ELEMENTAL
OO
LUIS ERNESTO
RUBIO TORRES
AGOSTO 2006
Luis Ernesto Rubio T.

Contenido
ELEMENTOS BÁSICOS DE ANÁLISIS, DISEÑO Y PROGRAMACIÓN OO....................................... 3
PATRÓN FUNDAMENTAL DE OPERATIVIDAD .................................................................................... 9
ESTRATEGIA ELEMENTAL DE APRENDIZAJE DE ANÁLISIS Y DISEÑO OO ............................ 11

ETAPA DE ANÁLISIS ( ¿QUÉ ? ) ............................................................................................................... 11
1. Análisis desde la Perspectiva del Usuario (User View): .................................................................. 11
2. Análisis desde la Perspectiva del Desarrollador (Structural View):................................................ 11
ETAPA DE DISEÑO ( ¿CÓMO ? ) ............................................................................................................... 12
3. Diseño del comportamiento de los objetos del sistema (Behavioral View): ..................................... 12
4. Diseño de la estructura del sistema (Structural View): .................................................................... 12
EJEMPLO 1: LA CUENTA BANCARIA DE TIM SOLLEY ................................................................... 13
EJEMPLO 2: LOS CURSOS DE SUPERSOFTWARE ............................................................................ 18
ALUMNO: ADA LOVELACE EXAMEN PARCIAL: 10.0 EXAMEN FINAL: 10.0 PROMEDIO: 10.0
.......................................................................................................................................................................... 20
ALUMNO: ADA LOVELACE EXAMEN PARCIAL: 10.0 EXAMEN FINAL: 10.0 PROMEDIO: 10.0
.......................................................................................................................................................................... 22
EJEMPLO 3: LOS INVENTORES .............................................................................................................. 23
EJEMPLO 4: UNA PERSONA DE TANTAS ............................................................................................. 27
EJEMPLO 5: CONTROL DE PROYECTOS ............................................................................................. 31

Elementos Básicos de Análisis, Diseño y Programación OO

Una aplicación (software) conforma una solución a un problema de alguna área de actividad
humana (por ejemplo: la industria automotriz, la petroquímica, instituciones de gobierno,
educativas, de salud, financieras, de manufactura, de entretenimiento; en fin negocios de todo
tamaño, que producen bienes y/o proporcionan servicios), en donde múltiples instancias, ya sean
personas, máquinas, leyes, documentos, dependencias, etc., se aglutinan para llevar a cabo la
multitud de tareas, operaciones y/o procesos.
Con base en los principios de desarrollo de software orientado a objetos (OO), un sistema (la
aplicación) se construye a partir de un conjunto de elementos (los objetos) enlazados de tal forma,
que proveen la solución al problema.
En el contexto de las aplicaciones, un objeto es una unidad que almacena información y es capaz
de efectuar operaciones; al cual se le asigna una misión dentro del sistema.
0xC1
:Inventor
nombre = Leonardo Da Vinci

arregloInventos = OxB1
0xB1
:Invento [ ]
[0] 0x11
[1] 0x15
[2] 0x1A
0x11
:Invento
nombre = Helicoptero
creador = OxC1
Estos objetos, colocados individualmente en alguna de las direcciones de la memoria de trabajo

de un equipo de cómputo, almacenan datos (sus propiedades o atributos) en sus variables
miembro y llevan a cabo operaciones a partir de sus métodos o funciones miembro asociadas.
Dichos objetos se “obtienen” a partir de la declaración y programación de piezas de código
denominadas Clases.
Una clase es el equivalente a un plano arquitectónico o instructivo de ensamble a partir del cual
una computadora produce los objetos.

Puede pensarse que una Clase, es un molde o plantilla a partir de la cual la computadora crea
múltiples instancias (los objetos), en dichas clases se declara la configuración (tipos de dato) de
las variables miembro que almacenarán los valores de las características o atributos de los
objetos; valores que en su conjunto determinan el estado de un objeto particular, en un cierto
instante de la ejecución de una aplicación.
Inventor
- nombre : String
- arregloInventos : Invento [ ]
+ getNombre ( ) : String
+ setNombre ( : String )
+ getInventos ( ) : Invento []
+ setInventos ( : Invento[] )
+ getInvento ( index : int )
+ setInvento ( : Invento, index : int )
También es en las Clases, en donde se incluyen los algoritmos o procedimientos que determinarán
el comportamiento de los objetos de una clase; estos algoritmos se codifican en las funciones
miembro (métodos), en donde, se declaran la configuración (tipo) de las variables argumento de
entrada de datos, se programan las instrucciones y se determina la forma del resultado (tipo de
retorno) del proceso efectuado.
public void setInventor(Inventor autor){

creador = autor;
}
public Inventor getInventor(){
return this.creador;
}
En una aplicación se enlazan los objetos, a fin de obtener datos e información de éstos, poder
realizar procesos y/o construir nuevos objetos.
Los Enlaces y Asociaciones son los medios para establecer relaciones entre objetos y clases. Un
enlace es una conexión física entre objetos a tiempo de ejecución de una aplicación. Por su parte
una asociación se emplea al nivel de Clases para describir un grupo de enlaces con estructura y
semántica comunes. De ese modo, puede pensarse en una asociación como un molde o plantilla
a partir de la cual se obtienen múltiples enlaces. Así, un enlace, es una instancia de una
asociación.
Inventor
arreglo Inventos
nombre
1..*
Invento
1 nombre
creador

0xC1
:Inventor

0x11
:Invento
creador = OxC1
0xB1
0x15
:Invento [ ]
:Invento
[0] 0x11
[1] 0x15 nombre = Submarino
[2] 0x1A creador = OxC1
0x1A
:Invento
nombre = Paracaidas
creador = OxC1
Las asociaciones suelen implementarse en los lenguajes de programación, mediante la declaración

de variables referencia (o bien, mediante variables puntero) dentro de las Clases, de forma
semejante a cómo se declaran las variables miembro (o atributos de dichas clases). De modo que,
para un cierto objeto activo en la memoria de un sistema, un enlace es el valor contenido en una
de sus variables, por medio del que hace referencia explícita a la dirección de memoria (handle –
manija) de otro objeto del sistema.
Puede decirse que una referencia es el nombre a través del cual se manipulan y controlan los
objetos. Un mismo objeto puede ser controlado a partir de múltiples y distintas referencias, en
diferentes partes de una aplicación.
Las asociaciones son inherentemente bidireccionales, aunque el nombre de la asociación suela

leerse en un cierto sentido, la asociación debe recorrerse en ambos (la dirección implicada por el
nombre es la dirección hacia delante y la opuesta es la dirección hacia atrás). Las asociaciones
pueden ser binarias, ternarias o de orden superior. En la práctica, la inmensa mayoría van a ser
binarias o ternarias, puesto que las asociaciones de orden más alto son más difíciles de dibujar, de
implementar y de pensar que las binarias y se deberían evitar siempre que fuera posible.
La multiplicidad de una asociación especifica el número de instancias que pueden estar

enlazadas con una única instancia de una clase asociada. Se suele describir la multiplicidad como
“uno” o “muchos”, configurándose así tres tipos elementales de asociaciones: uno-a-uno (1..1),
uno-a-muchos (1..*) y muchos-a-muchos (*..*).

Un atributo de enlace es una propiedad de los enlaces de una asociación. Cuando las
asociaciones tienen atributos de enlace frecuentemente se modelan como clases (cada enlace
pasa a ser entonces, una instancia de tales clases), de modo que pueden poseer además de
atributos (de enlace), un nombre y métodos (del enlace). Todo atributo de enlace tiene un valor
para cada enlace.
public class Invento{ public class Inventor{

private String nombre; private String nombre;
private Inventor creador; private Invento[] arregloInventos;
} }
Resulta útil modelar las asociaciones como clases cuando los enlaces pueden participar en
asociaciones con otros objetos o cuando están sometidos a operaciones. Las asociaciones
muchos-a-muchos proporcionan el caso de uso mas frecuente de los atributos de enlace, pues
tales atributos son, una propiedad particular del enlace y de ningún modo pueden asociarse
individualmente con alguno de los objetos relacionados.
Otros tipos especiales de relaciones son las asociaciones de Agregación/Composición y la

Generalización (Herencia). Se define una agregación/composición como la relación “parte-todo” o
“una-parte-de” en la cual los objetos que representan los componentes de algo se asocian a un
objeto que representa el ensamblaje completo. Por su parte la relación de generalización
(herencia) “es-un/es-una” se utiliza para compartir similitudes entre clases, al mismo tiempo que se
mantienen sus diferencias.
La generalización (herencia) es la relación entre una clase y una o más versiones refinadas de esa
misma clase. La que se está refinando se denomina superclase (clase base o clase padre) y cada
versión refinada se llama una subclase (clase derivada o clase hija).
Las asociaciones de herencia son transitivas a través de un número arbitrario de niveles. Una
instancia de una subclase, es simultáneamente una instancia de todas sus clases ancestro. El
estado de una instancia incluye un valor para cada uno de los atributos de todas sus clases
ancestro. Todo método aplicable a una clase ancestro podrá ser aplicado a una instancia suya.
Además una subclase añade a sus miembros heredados, sus propios atributos y métodos
específicos
Entre las principales necesidades de la industria de desarrollo de sistemas a gran escala, destaca
la de integración, estandarización y generalización de código, de la cual se desprende la
posibilidad de reutilización de software.
Un ejemplo representativo de esta problemática es el de la programación de interfaces gráficas de

usuario (GUIs), que implica la integración de múltiples componentes visuales estandarizados para
recibir o presentar resultados de procesos en muy diversas aplicaciones de negocio. Otros
ejemplos semejantes incluyen la gestión de I/O, bases de datos, comunicación en redes,
multiprogramación y, un largo etc.

El lenguaje de programación Java ofrece una serie de mecanismos avanzados de sus clases para
lograr de una forma efectiva la integración y generalización de procesos, así como para promover
la estandarización y reutilización de código. Estos mecanismos incluyen a las Clases Abstractas,
las Interfaces, y las Clases Anidadas.
Las Clases Abstractas son superclases que declaran métodos que no tienen implementación (es
decir que carecen de instrucciones). A dichos métodos se les llama métodos abstractos y por
tanto las clases que los contienen se denominan Clases Abstractas. La implementación
(instrucciones) de los métodos abstractos se proporciona en las subclases de la clase abstracta.
La utilidad de las clases abstractas radica en que aprovecha el mecanismo de invocación virtual
de métodos para permitir la programación de métodos genéricos (esto es, permitir que un solo
método sea empleado para cumplir adecuadamente las tareas de objetos de múltiples subclases).
Otro poderoso mecanismo de estandarización e integración de código, lo conforman las

Interfaces. Una interface es una construcción que incluye un conjunto de "declaraciones" de
métodos sin implementación (sin instrucciones) que pueden ser implementados (codificados) por
otras clases.
Una clase “implementa” una interface cuando define las instrucciones de todos y cada uno de los
métodos declarados por dicha interface. La misma interface puede ser implementada por múltiples
clases, mientras que a su vez, una clase puede implementar varias interfaces (a diferencia de la
herencia, pues cada clase únicamente puede extender a sólo una superclase).

//Animal.java
public abstract class Animal {
protected int legs;
protected Animal(int legs) {

this.legs = legs;
}
public abstract void eat(); //Pet.java

public interface Pet {
public void walk() { public void setName(String name);
System.out.println("This animal walks on " + public String getName();
legs + " legs."); public void play();
} }
}
//Spider.java
public class Spider extends Animal {
public Spider() {
super(8);
} //Cat.java
public class Cat extends Animal implements Pet {
public void eat() { private String name;
System.out.println("Spiders catch flies in their webs to eat.");
} public Cat(String name) {
} super(4);
this.name = name;
}
public Cat() {
this("");
}
public void setName(String name) {

// TestAnimals.java
this.name = name;
public class TestAnimals {
}
public static void main(String[] args) {
public String getName() {
Fish f = new Fish();
return name;
Cat c = new Cat("Fluffy");
}
Animal a = new Fish();
public void play() {
Animal e = new Spider();
System.out.println(name + " likes to play with string.");
Pet p = new Cat();
}
// Demonstrate different implementations of an interface
public void eat() {
f.play();
System.out.println("Cats like to eat spiders and mice.");
c.play();
}
}
// Demonstract virtual method invocation
e.eat();
e.walk();
// Demonstrate calling super methods

a.walk();
}
}

Problemas y Ejercicios Elementales de Modelado OO Hoja 9
Patrón Fundamental de Operatividad

Un patrón (como en costura) se utiliza como una guía para hacer confecciones que pueden usarse. A continuación se muestra un patrón para
confeccionar clases de modo que sean operativas, es decir que contengan los métodos necesarios para que al momento de generar objetos,
éstos puedan interactuar con otros dentro de un programa.
Para utilizar este patrón, basta sustituir las variables X, Y, Z, por conceptos que se relacionen en el mundo real bajo asociaciones “a uno” y “a
muchos”. Por ejemplo si se sustituyen X = Médico, Y = Hospital, Z = Pacientes, en los modelos UML siguientes, pueden escribirse las clases para
generar objetos en donde un médico trabaja en un hospital y tiene muchos pacientes. Si X = Corporación, Y = Departamento, Z = Empleado;
puede escribirse código para crear objetos en donde un departamento con muchos empleados pertenece a una corporación.
Otro ejemplo sería, cuando se hace que X = Industria, Y = Almacén, Z = Producto; el almacén de una industria guarda muchos productos. Otro
más, si X = Juego, Y = Personaje, Z = Arma, podrían generarse objetos como las muchas armas de Batman, en el juego de la “Liga de la
Justicia”.
En la siguiente página se ilustran los modelos de diseño del el patrón de código, con métodos para gestionar – alta, baja, cambio, consulta, los
enlaces entre objetos de las clases X,Y, Z y la misión de cada una – por ejemplo el método misión de un objeto médico incluiría instrucciones para
aliviar a sus pacientes.
X
oneY : Y
data : type
misiónX ( )
oneX : X
oneY 1 collectionZs
collectionZs
Y z
:Z
:Z
:Z
Modelo de Objetos
Modelo de Diseño Conceptual
public class X {
private type data; X
private Y oneY;
private Zs collectionZs; data : type
misiónX ( ) {... } misiónX ( )
X ( ) { // the X Constructor ... }
void setData (type aData)
{data = aData; } X()
type getData ( ) {return data; }
void deleteData ( ) {... }
Modelo de Diseño Operativo
void setY (Y oneY)
setData (:type )
{ this.oneY = oneY} getData ( ) :type
Y getY ( ) {return oneY }
void deleteY ( ) {oneY = null }
deleteData ( )
void setZs (Zs collectionZs ) {... }
Zs getZs ( ) { return collectionZs } setY ( :Y)
void deleteZs ( ) getY ( ) : Y
{ collectionZs = null }
deleteY ( )
int sizeZs ( ) {... }
boolean isEmptyZs ( ) {... }
setZs ( : Zs)
void add/setZ ( Z oneZ) {... } getZs ( ) : Zs
Z getZ ( ) {... }
boolean contains (Z oneZ ) {... } deleteZs ( )
void remove/deleteZ (Z oneZ ) {... }
Z nextZ ( ) {... } sizeZs ( ) : int

boolean hasNextZ ( ) {... } oneY 1 isEmptyZs ( ) : collectionZs 1..*
Z previousZ ( ) {... }
boolean hasPreviousZ ( ) {... }
Y bool z
}
add/setZ ( : Z)
contains/getZ ( ): Z
remove/deleteZ (:Z
Patrón en Lenguaje Java
)
nextZ ( ) : Z
hasNextZ ( ) : bool
previousZ ( ) : Z
hasPreviousZ()
:bool
Estrategia Elemental de Aprendizaje de Análisis y Diseño OO
ANÁLISIS Y DISEÑO
ITERATIVO
Etapa de Análisis ( ¿Qué ? )
1. Análisis desde la Perspectiva del Usuario (User View):
¿Qué puede hacer el usuario con el Sistema?
Responde a la pregunta modelando un Diagrama de Casos de Uso en UML.
2. Análisis desde la Perspectiva del Desarrollador (Structural View):
¿Qué objetos intervienen en la solución al problema?

¿Qué características tienen dichos objetos?
¿Qué enlaces existen entre esos objetos?
Responde a las preguntas imaginando e inventando una serie de cosas (tangibles o intangibles,
reales o artificiales, concretas o abstractas, animadas o inanimadas) a las cuales dotarás de
capacidades de procesamiento dinámicas para resolver el problema; y con ellas modela (dibuja)
un Diagrama de Instancias UML y a partir de éste, modela el correspondiente Diagrama de Clases
UML al nivel de Análisis es decir, sólo especifica los nombres de los atributos y asociaciones.
Nota: Diagrama de Instancias.- representa gráficamente a los objetos que en la memoria de la

computadora llevan a cabo los procesos del sistema, incluyendo sus atributos (características) y
enlaces (conexiones).
Nota: Diagrama de Clases.- representa las plantillas o moldes del sistema que permiten crear los
objetos en la memoria de la computadora para efectuar los procesos y así satisfacer los Casos de
Uso.

Etapa de Diseño ( ¿Cómo ? )
3. Diseño del comportamiento de los objetos del sistema (Behavioral View):
¿Cómo se efectúan las tareas y procesos con nuestros objetos?

¿Cómo se accede a los datos contenidos en nuestros objetos?
Puedes responder a la pregunta modelando un Diagrama Secuencia/Colaboración UML. En esta

etapa debes imaginar que los objetos pueden comunicarse unos con otros a través de mensajes o
llamadas, que contienen datos (parámetros), estos mensajes son equivalentes a órdenes o
solicitudes, de modo que un objeto le puede pedirle a otro que haga algo; piensa qué mensajes o
solicitudes puede recibir un cierto objeto para llevar a cabo una actividad importante dentro del
sistema.
Nota: Para acceder a los datos (propiedades o atributos) diseña un par de mensajes de acceso
set/get.
Nota: Para acceder a los objetos mediante un enlace de cardinalidad “a uno” diseña un par de
mensajes de acceso set/get. Para acceder a los objetos mediante un enlace de cardinalidad “a
muchos” diseña dos pares de mensajes de acceso set/get; el primero para acceder a la colección
total, y el segundo par set/get para acceder a un elemento individual de la colección.
4. Diseño de la estructura del sistema (Structural View):
¿Cómo se definen las características (propiedades/atributos) de los objetos diseñados?

¿Cómo se define el comportamiento (métodos/mensajes/operadores/funciones/algoritmos)
de los objetos diseñados?
Puedes responder a la pregunta modelando un Diagrama de Clases al nivel de Diseño (incluye

tipos de datos de los atributos, nombres de métodos, argumentos y sus tipos de datos, así como
los tipos de retorno de los métodos).

Ejemplo 1: La Cuenta Bancaria de Tim Solley

ETAPA DE ESPECIFICACIÓN DEL PROBLEMA
Tim Solley abrió una cuenta con $ 500.00 USD en el banco más importante de su comunidad, y realizó una
serie de transacciones durante la semana subsecuente a la apertura de su cuenta bancaria. Dichas
transacciones incluyeron: un retiro inicial de $150.00, un depósito de $ 22.50, otro retiro de $ 47.62 y
finalmente la impresión del balance (saldo) de su cuenta.
Modele mediante ADOO una aplicación que permita llevar el registro del balance para diferentes cuentas
bancarias semejantes a las de Tim Solley y codifique en Java un programa que despliegue en la pantalla de
la consola un reporte con las transacciones de este cliente bancario:
Apertura con balance inicial de: $ 500.00

Retiro: $ 150.00
Depósito: $ 22.50
Retiro: $ 47.62
Balance: $ 324.88
ETAPA DE ANÁLISIS ( ¿QUÉ ? )
1. Análisis desde la Perspectiva del Usuario (User View):
Se responde a la pregunta modelando un Diagrama de Casos de Uso en UML.

¿Qué objetos intervienen en el despliegue del reporte?

Se responde a las preguntas imaginando e inventando una serie de cosas (tangibles o intangibles, reales
o artificiales, concretas o abstractas, animadas o inanimadas) a las cuales dotaras de capacidades de
procesamiento dinámicas para resolver el problema; y con ellas se modela (dibuja) un Diagrama de
Instancias UML y a partir de éste, se modela el correspondiente Diagrama de Clases UML al nivel de
Análisis es decir, sólo especifica los nombres de los atributos y asociaciones.
Diagrama de Instancias.- representa gráficamente a los objetos que en la memoria de la computadora llevan a
cabo los procesos del sistema, incluyendo sus atributos (características) y enlaces (conexiones).
Analysis Class Diagram
TestBanking Account
balance
Diagrama de Clases.- representa las plantillas o moldes del sistema que permiten crear los objetos en la
memoria de la computadora para efectuar los procesos y así satisfacer los Casos de Uso.

ETAPA DE DISEÑO ( ¿CÓMO ? )
¿Cómo se hace la operación de apertura con nuestros objetos?

¿Cómo se hace los depósitos y retiros mediante los objetos?
¿Cómo obtiene el saldo de una cuenta con los objetos?
Se puede responder a las preguntas modelando un Diagrama Secuencia o un Diagareama de

colaboración UML En esta etapa debes imaginar que los objetos pueden comunicarse unos con otros a
través de mensajes o llamadas, que contienen datos (parámetros), estos mensajes son equivalentes a
órdenes o solicitudes, de modo que un objeto le puede pedirle a otro que haga algo; piensa qué
mensajes o solicitudes puede recibir un cierto objeto para llevar a cabo una actividad importante dentro
del sistema.

¿Cómo se define el comportamiento (métodos/mensajes/operadores/funciones/algoritmos) de los
objetos diseñados?
Se responde a la pregunta modelando un Diagrama de Clases al nivel de Diseño (incluye tipos de datos
de los atributos, nombres de métodos, argumentos y sus tipos de datos, tipos de retorno de los métodos).

ETAPA DE PROGRAMACIÓN ( CODIFICACIÓN )

5. Se transcriben a algún lenguaje de programación OO (Java, C++, Visual Basic, etc.) las clases obtenidas
en el Diagrama de Clases UML de la etapa de Diseño, y se incluye la lógica de los algoritmos
correspondientes a cada uno de los métodos, de modo que se lleven a cabo las tareas esperadas (tip:
recuerda que para este caso, la generación y despliegue de las calificaciones de los tres objetos alumno
puede efectuarla el método main de la aplicación. Finalmente se edita, compila y ejecuta la aplicación de
modo que en la pantalla se despliegue el reporte:
package banking;
public class Account {
private double balance;
public Account(double bal) {

balance = bal;
import banking.*; }
public double getBalance() {
public class TestBanking { return balance;
}
public static void main(String[] args) { public boolen deposit(double amount) {
Account account; balance = balance + amount;
return true;
// Create an account that can has a 500.00 balance. }
System.out.println("Creating an account with a 500.00 balance."); public boolean withdraw(double amount) {
account = new Account(500.00); if (amount <= balance){
balance = balance - amount;
System.out.println("Withdraw 150.00"); return true;
account.withdraw(150.00); } else {
return false;
System.out.println("Deposit 22.50"); }
account.deposit(22.50); }
}
System.out.println("Withdraw 47.62");
account.withdraw(47.62);
// Print out the final account balance

System.out.println("The account has a balance of " + account.getBalance( ) );
}
}

Creating an account with a 500.00

balance.
Withdraw 150.00
Deposit 22.50
Withdraw 47.62
The account has a balance of 324.88

Ejemplo 2: Los Cursos de SuperSoftware
La empresa SuperSoftware ofrece cursos de certificación en el manejo de sus herramientas de

desarrollo de aplicaciones. El instructor de “Lenguaje C + o –“, desea contar con una aplicación
Orientada a Objetos para desplegar la lista con las calificaciones de los tres mejores alumnos de su
último curso:
Alumno: Ada Lovelace Examen Parcial: 10 Examen Final: 10 Promedio: 10

Alumno: James Gosling Examen Parcial: 10 Examen Final: 8 Promedio: 9
Alumno: Grady Booch Examen Parcial: 9 Examen Final: 7 Promedio: 8
Desarrolle una aplicación OO para obtener la lista de los alumnos del instructor de SuperSoftware y
codifíquela en lenguaje Java. Modele mediante ADOO la clase necesaria para generar los objetos
que permitan registrar y recuperar los datos: nombre, calificación del examen parcial y calificación
del examen final, y que proporcione el cálculo de la calificación final de los alumnos.

ETAPA DE ANÁLISIS ( ¿QUÉ ? )
1. Análisis desde la Perspectiva del Usuario (User View)::
Responde a la pregunta modelando un Diagrama de Casos de Uso en UML.
Tip: Revisa el “Use Case Diagram” del Ejemplo 1: La Cuenta Bancaria de Tim Solley
Tip: Hay de 3 a 5 casos de uso, dos de ellos son “Ingresar Datos del Alumno” y “Calcular Promedio”
¿Qué objetos intervienen en el despliegue de la lista de calificaciones?

Responde a las preguntas imaginando e inventando una serie de cosas (tangibles o intangibles, reales o
artificiales, concretas o abstractas, animadas o inanimadas) a las cuales dotaras de capacidades de
procesamiento dinámicas para resolver el problema; y con ellas modela (dibuja) un Diagrama de
Instancias UML y a partir de éste, modela el correspondiente Diagrama de Clases UML al nivel de
Análisis es decir, sólo especifica los nombres de los atributos y asociaciones.
Tip: Revisa el “Instance Diagram” y el “Class Diagram” del Ejemplo 1: La Cuenta Bancaria de Tim Solley
Tip: El diagrama de instancias debe tener 4 objetos, uno de ellos tiene 3 atributos: el nombre “Ada_Lovelace”
y dos calificaciones de 10
ETAPA DE DISEÑO ( ¿CÓMO ? )
¿Cómo se ingresan los datos de Ada Lovelace mediante nuestros objetos?
Puedes responder a la pregunta modelando un Diagrama Secuencia UML En esta etapa debes imaginar
que los objetos pueden comunicarse unos con otros a través de mensajes o llamadas, que contienen
datos (parámetros), estos mensajes son equivalentes a órdenes o solicitudes, de modo que un objeto le
puede pedirle a otro que haga algo; piensa qué mensajes o solicitudes puede recibir un cierto objeto para
llevar a cabo una actividad importante dentro del sistema.
Tip: Revisa el “Secuence Diagram” del Ejemplo 1: La Cuenta Bancaria de Tim Solley
Tip: Los mensajes para el objeto alumno podrían ser new Alumno() y setNombre(“Ada Lovelace”)

4. Diseño del comportamiento de los objetos del sistema (Behavioral View)::
¿Cómo se califica a Ada Lovelace mediante nuestros objetos?
Puedes responder a la pregunta modelando un Diagrama de Colaboración UML.
Tip: Revisa el “Collaboration Diagram” del Ejemplo 1: La Cuenta Bancaria de Tim Solley
Tip: Otro de los mensajes para el objeto alumno puede ser: setCalificaciónParcial(10)
¿Cómo se despliega en la lista de calificaciones el promedio de Ada Lovelace?
Puedes responder a la pregunta modelando un Diagrama de Colaboración UML.
Tip: Revisa el “Collaboration Diagram” del Ejemplo 1: La Cuenta Bancaria de Tim Solley
Tip: incluye mensajes como: getNombre() y calculaPromedio()

¿Cómo se define el comportamiento (métodos/mensajes/operadores/funciones/algoritmos) de los
objetos diseñados?
Puedes responder a la pregunta modelando un Diagrama de Clases al nivel de Diseño (incluye tipos de
datos de los atributos, nombres de métodos, argumentos y sus tipos de datos, tipos de retorno de los
métodos).
Tip: Revisa el “Class Diagram” del Ejemplo 1: La Cuenta Bancaria de Tim Solley
Tip: por ejemplo puedes especificar que el atributo nombre es privado y de tipo String así: - nombre: String
Tip: podrías especificar métodos como: +calculaPromedio( ):double y +
setCalificacionParcial(:double):void
ETAPA DE PROGRAMACIÓN ( CODIFICACIÓN EN JAVA )

7. Transcribe al lenguaje de programación Java las clases obtenidas en el Diagrama de Clases UML de la
etapa de Diseño, incluye la lógica de los algoritmos correspondientes a cada uno de los métodos, de
modo que se lleven a cabo las tareas esperadas (tip: recuerda que para este caso, la generación y
despliegue de las calificaciones de los tres objetos alumno puede efectuarla el método main de la
aplicación. Finalmente, edita, compila y ejecuta la aplicación de modo que en la pantalla se despliegue el
reporte:
Alumno: Ada Lovelace Examen Parcial: 10.0 Examen Final: 10.0 Promedio: 10.0
Tip: Revisa el código Java del Ejemplo 1: La Cuenta Bancaria de Tim Solley

I AppListaTop3
Ingresar Datos Personales
Calificar Alumno + main( args : String [] ): void
II Desplegar Lista <<usa>>
Diagrama UML de Casos de Uso

Alumno
– nombre : String
:AppListaTop3 ada : Alumno – exParcial : int
<<usa>> – exFinal : int
nombre = “Ada Lovelace”
exParcial = 10 + setNombre( argumentoNombre: String ) :
exFinal = 10 + setParcial ( argumentoParcial : double ) :
+ setFinal ( argumentoFinal : double) : void
Diagrama UML de Instancias
+ getNombre( ) : String
III + getParcial ( ) : double
AppListaTop3 <<usa>> Alumno + getFinal ( ) : double
nombre + calculaPromedio ( ) : double

exParcial
exFinal
DISEÑO III
Diagrama UML de Clases para Diseño
Diagrama UML de Clases para Análisis

:AppListaTop3 ada : Alumno
:AppListaTop3 ada : Alumno 1: getNombre( )
nombre
I no m b re
2: getParcial( )
new Alumno ( )
exParcial
setNombre(“Ada Lovelace”)
3: getFinal( )
setParcial( 10 )
exFinal
setFinal( 10 ) 4: calcularPromedio( )
DISEÑO II
(exParcial + exFianal) / 2
Diagrama UML de Secuencia

Luis Ernesto Rubio T. Diagrama UML de Colaboración
// AppListaTop3.java // Alumno.java
public class AppListaTop3{ public class Alumno{
public static void main(String[] args){ private String nombre;

private double exParcial;
Alumno ada; private double exFinal;
ada = new Alumno(); public void setNombre(String argumentoNombre){

ada.setNombre("Ada Lovelace"); nombre = argumentoNombre;
ada.setParcial(10); }
ada.setFinal(10); public void setParcial(double argumentoParcial){
exParcial = argumentoParcial;
System.out.println("Alumno: " + }
ada.getNombre() + public void setFinal(double argumentoFinal){
" Examen Parcial: " + exFinal = argumentoFinal;
ada.getParcial() + }
" Examen Final: " +
ada.getFinal() + public String getNombre( ){
" Promedio: " + return nombre;
ada.calculaPromedio() ); }
public double getParcial( ){
} return exParcial;
}
} public double getFinal ( ){
return exFinal;
}
public double calculaPromedio( ){

double promedio;
promedio = ( exParcial + exFinal ) / 2;
Alumno: Ada Lovelace Examen Parcial: 10.0 Examen Final: 10.0 Promedio: 10.0 return promedio;
}

Ejemplo 3: Los Inventores
I) Un inventor puede crear uno ó más inventos.
II) La idea de un invento pertenece únicamente a un inventor.
:Inventor
:Invento :Invento :Invento
nombre = Helicoptero nombre = Paracaidas nombre = Submarino
Diagrama de Instancias

Inventor
arreglo Inventos
nombre
1..*
Invento
1 nombre
creador
Diagrama de Clases a Nivel de Análisis
Inventor
- nombre : String
- arregloInventos : Invento [ ]
Invento
- nombre : String
- creador : Inventor
Diagrama de Clases a Nivel de Diseño
package learning.business.inventos;
public class Inventor{
private String nombre;

private Invento[] arregloInventos;
package learning.business.inventos;
public class Invento{ Código Java

private Inventor creador;

public class Inventor{

Inventor private Invento[] arregloInventos;
public void setNombre(String nombre){

- nombre : String this.nombre = nombre;
- arregloInventos : Invento [ ] }
public String getNombre(){
+ getNombre ( ) : String return this.nombre;
+ setNombre ( : String ) }
+ getInventos ( ) : Invento [] public void setInventos(Invento[] creaciones ){
+ setInventos ( : Invento[] ) this.arregloInventos = creaciones;
+ getInvento ( index : int ) }
+ setInvento ( : Invento, index : int ) public Invento[] getInventos(){
return this. arregloInventos;
}
public void setInvento(Invento creacion, int indice){
this.arregloInventos[indice] = creacion;
}
public Invento getInvento(int indice){
public class Invento{ return this.arregloInventos[indice];
private String nombre; }
private Inventor creador; }

this.nombre = nombre;
}
return this.nombre;
}
public void setInventor(Inventor autor){
creador = autor;
}
public Inventor getInventor(){
return this.creador;
}
}
Invento maquina = new Invento();

maquina.setNombre("Submarino");
maquina.setInventor( new Inventor() );

maquina.getInventor().setNombre("Leonardo Da Vinci");
String reporte = new String("La maquina llamada: ");
reporte = reporte + maquina.getNombre() + "\n";
reporte = reporte + "Fue inventada por : ";
reporte = reporte +maquina.getInventor().getNombre() + "\n";
textAreaGUI.append(reporte);
System.out.print(reporte);

0xC1
:Inventor

0x11
:Invento
creador = OxC1
0xB1
0x15
:Invento [ ]
:Invento
[0] 0x11
[1] 0x15 nombre = Submarino
[2] 0x1A creador = OxC1
0x1A
:Invento
nombre = Paracaidas
creador = OxC1
Inventor leonardo = new Inventor();

leonardo.setNombre("Leonardo Da Vinci");
leonardo.setInventos( new Invento[ 3 ] );
for (int i = 0; i < 3; i++){

leonardo.setInvento( new Invento(), i );
if ( i == 0) {
leonardo.getInvento( i ).setNombre("Helicoptero");
} else if ( i == 1) {
leonardo.getInvento( i ).setNombre("Submarino");
} else if ( i == 2) {
leonardo.getInvento( i ).setNombre("Paracaidas");
}
}
String reporte = new String("El inventor: ");

reporte = reporte + leonardo.getNombre() + "\n";
reporte = reporte + "Invento las siguientes maquinas: \n";
for (int i = 0; i < 3; i++){

reporte = reporte + leonardo.getInvento( i ).getNombre() + "\n";
}
textAreaGUI.append(reporte);

Ejemplo 4: Una persona de tantas

<< En cualquier sociedad las personas desempeñan diversos papeles, o roles, en su vida diaria (padre de familia, profesionistas, ama de casa,
estudiantes, etc.), cada uno de estos roles implica una serie de actitudes y formas de comportamiento particulares >>.
María y Juan, son hermanos, ambos profesionistas Ingenieros de Software; por las tardes, después del trabajo, Juan desempeña el papel de
padre de familia y María, por su parte, estudia una maestría.
A propósito de los roles personales, María debe desarrollar un software de análisis con fines estadísticos, que facilite el registro de los distintos
roles que una persona asume. Se desea que dicho estudio estadístico contemple a personas de los distintos estados de nuestro país;
considerando además, para fines de control algunos datos del acta de nacimiento de las personas.
María debe registrar para cada persona, el nombre, la edad, su sexo y un número consecutivo de identificación; en el caso de los roles contempla
un número de rol y la descripción del rol (por ejemplo al rol padre de familia corresponde el número de rol 10 y su descripción es "padre_familia").
Con respecto de las Actas de Nacimiento, María sabe que los datos número de libro y folio bastan para localizar cada acta, sin embargo, adicionó
un número secuencial a cada acta, a fin de emplearlo como único identificador de estas. Finalmente, de los estados del país, decide registrar el
nombre del estado y un número de control que ella misma asignó a cada estado.
:Persona
numero = 2
nombre = Eva
:Estado
:Acta
numero = 10
numero = 77777 nombre = Veracruz
Libro = 007
folio = 70
:Rol :Rol :Rol :Rol
numero = 1 numero = 2 numero = 3 numero = 4

nombre = Profesionista nombre = Estudiante nombre = Esposa nombre = Ama de Casa

Persona Estado
numero : int edoNac numero : int

nombre : char * 1 nombre : char *
edad : double
sexo : char
acta
Acta Rol
numero : int roles numero : int

libro : int 1..* nombre : char *
folio : int
Persona
numero : int
nombre : char *
edad : double
sexo : char
acta : Acta
edoNac : Estado
roles : Rol [ ]

public class Persona{
public class Estado{ private int numero;
private int numero; private String nombre;
private String nombre; private double edad;
private Acta acta;
public void setNumero(int numero){ private Estado edoNac;
if (numero <= 0){ private Rol[] arregloRoles;
numero = 1;
} public void setNumero(int numero){
if (numero > 32){ this.numero = numero;
numero = 32; }
} public int getNumero(){
this.numero = numero; return this.numero;
} }
public int getNumero(){ public void setNombre(String nombre){
return this.numero; this.nombre = nombre;
} }
public void setNombre(String nombre){ public String getNombre(){
this.nombre = nombre; return this.nombre;
} }
public String getNombre(){ public class Rol{
public void setEdad(double edad){
return this.nombre; private int numero; if(edad < 0){
} private String nombre; edad = 0;
} }else if(edad > 125){
public void setNumero(int numero){ edad = 125;
this.numero = numero; }
} this.edad = edad;
public int getNumero(){ }
public class Acta{ return this.numero;
private int numero; public double getEdad(){
} return this.edad;
private int libro; public void setNombre(String nombre){
private int folio; }
this.nombre = nombre; public void setActa(Acta acta){
} this.acta = acta;
public void setNumero(int num){ public String getNombre(){
numero = num; }
return this.nombre; public Acta getActa(){
} }
public int getNumero(){ return this.acta;
} }
return numero;
} public void setEstado(Estado estado){
public void setLibro(int lib){ this.edoNac = estado;
libro = lib; }
} public Estado getEstado(){
public int getLibro(){ return this.edoNac;
return this.libro; }
} public void setRoles(Rol[] roles){
public void setFolio(int fol){ this.arregloRoles = roles;
this.folio = fol; }
} public Rol[] getRoles(){
public int getFolio(){ return this.arregloRoles;
return folio; }
} public void setRol(Rol rol, int indice){
this.arregloRoles[indice] = rol;
}
}
public Rol getRol(int indice){
return this.arregloRoles[indice];
Luis Ernesto Rubio T. }
}
Estado objEstado;
objEstado = new Estado();
Problemas y Ejercicios Elementales de Modelado----------------------------------------
objEstado.setNumero(10); OO Hoja 30
objEstado.setNombre("Veracruz"); <<< Reporte de la Prueba con Objetos >>>
Me llamo Eva, tengo 18.0 años de edad
Persona objPersona = new Persona(); Los datos de mi Acta de Nacimiento son:
#Libro: 555
objPersona.setNumero(1); #Folio: 777
objPersona.setNombre("Eva");
Las actividades que desempeño son:
objPersona.setEdad(18);
Profesionista
objPersona.setEstado(objEstado); Estudiante String reporte = "----------------------------------------" + "\n";
Conyuge reporte = reporte + "<<< Reporte de la Prueba con Objetos >>>" + "\n";
objPersona.setActa( new Acta() ); ----------------------------------------
objPersona.getActa().setNumero(333); reporte = reporte + "Me llamo " + objPersona.getNombre()
objPersona.getActa().setLibro(555); + ", tengo " + objPersona.getEdad()
objPersona.getActa().setFolio(777); + " años de edad" + "\n";
objPersona.setRoles(new Rol[3]); reporte = reporte + "Los datos de mi Acta de Nacimiento son:" + "\n"
+ "\t#Libro: " + objPersona.getActa().getLibro() + "\n"
for (int i = 0; i < 3; i++){ + "\t#Folio: " + objPersona.getActa().getFolio() + "\n";
objPersona.setRol(new Rol(), i);
objPersona.getRol(i).setNumero(i + 1); reporte = reporte + "Las actividades que desempeño son:" + "\n";
if(i == 0){ for (int i = 0; i <= 2; ++i){
objPersona.getRol(i).setNombre("Profesionista"); reporte = reporte + "\t" + objPersona.getRol(i).getNombre() + "\n";
}else if(i == 1){ }
objPersona.getRol(i).setNombre("Estudiante"); reporte = reporte + "----------------------------------------" + "\n";
}else if(i == 2){
objPersona.getRol(i).setNombre("Conyuge"); System.out.print(reporte);
}
}
0xA1
0xB1
0xD1 :Persona
:Rol [ ]
:Acta
numero = 1
0xC1 nombre = Eva [0] 0x11
numero = 21 edad = 18 [1] 0x15
libro = 88 sexo = F [2] 0x1A
:Estado
folio = 22 acta = 0xD1 [3] 0x1B
numero = 10 edoNac = 0xC1
nombre = Veracruz roles = 0xB1
0x11 0x15 0x1A 0x1B
:Rol :Rol :Rol :Rol
numero = 1 numero = 2 numero = 3 numero = 4

nombre = Profesionista nombre = Estudiante nombre = Esposa nombre = Ama de Casa

Ejemplo 5: Control de Proyectos

Una cierta empresa dedicada al desarrollo de nuevos medicamentos requiere de un sistema
automatizado para el control de los múltiples proyectos de investigación que lleva a cabo. En la
empresa laboran 20 investigadores de diversas especialidades (Biología, Química, Medicina, etc.),
quienes participan en uno o más proyectos en un periodo determinado.
En cada proyecto laboran en promedio de 3 a 4 investigadores, dedicando horarios variables a

cada proyecto de media jornada de trabajo, o bien trabajando tiempo completo, si el proyecto así lo
requiere. Cada investigador participa en dos o tres proyectos de forma simultánea. Cada proyecto
es responsabilidad de un investigador, y un investigador no puede ser responsable de más de un
proyecto.
A cada proyecto se asigna un presupuesto determinado, e igualmente cada investigador recibe un

pago dependiendo de la complejidad del proyecto y de las horas de trabajo que tenga asignadas.
Por su parte, los líderes de proyecto también reciben un pago por cada proyecto que gestionan,
dicho pago esta determinado por la dificultad e importancia del proyecto y de las horas de trabajo
que el investigador líder dedique a la administración del proyecto.
Se desea crear un sistema que registre la siguiente información: nombre, teléfono y especialidad
de los investigadores; de cada proyecto: el nombre, el tiempo estimado de desarrollo, la fecha de
inicio, el presupuesto asignado y el objetivo del proyecto. Así también se desean obtener reportes
con los horarios y pagos correspondientes a cada investigador por proyecto, y los horarios y pagos
correspondientes por proyecto a cada líder, así como los pagos totales por persona. A continuación
se ilustran algunos de los reportes que debe obtener el sistema:
Proyecto: Aspirinix AB
Líder: Lili
Horario/gestión de proyecto: 6:00 – 9:00 hrs.
Salario/gestión de proyecto: USD $ 100.00
Investigadores:
Nombre: Lola Horario: 09:00 – 14:00 Salario: USD $ 95.00
Nombre: Lulú (I) Horario: 09:00 – 15:00 Salario: USD $ 120.00
Nombre: Leda Horario: 09:00 – 15:00 Salario: USD $ 150.00
Nombre: Lili Horario: 09:00 – 15:00 Salario: USD $ 125.00
Proyecto: Ultimate Thin Diet

Líder: Lola
Horario/gestión de proyecto: 15:00 – 18:00 hrs.
Salario/gestión de proyecto: USD $ 200.00
Nota: Investigadores:
Nombre: Lili Horario: 16:00 – 21:00 Salario: USD $ 175.00
Lulú (I) y Lulú (II) son Nombre: Leda Horario: 17:00 – 22:00 Salario: USD $ 200.00
solo un par de los Nombre: Lulú (II) Horario: 15:00 – 21:00 Salario: USD $ 180.00
homónimos que se
tienen en la compañía.
Curiosamente ambas Proyecto: Top Secret SX
investigadores tienen Líder: Leda
la misma especialidad Horario/gestión de proyecto: 21:00 – 22:30 hrs.
(QFB). Se llaman igual Salario/gestión de proyecto: USD $ 100.00
(Lourdes Pérez Pérez) Investigadores:
y comparten el mismo Nombre: Lina Horario: 17:00 – 23:00 Salario: USD $ 275.00
domicilio y teléfono ¡¡!! Nombre: Lulú (II) Horario: 21:00 – 23:00 Salario: USD $ 200.00

public class Investigador{

private String idInvestigador;
private Asignacion [ ] proyectosAsignados;
public void setID(String id){

this.idInvestigador = id;
}
public String getID(){
return this.idInvestigador;
}
this.nombre = nombre;
}
return this.nombre;
}
public void setProyectosAsignados(Asignacion[] asignaciones ){

this.proyectosAsignados = asignaciones;
}
public Asignacion[] getProyectosAsignados(){
return this. proyectosAsignados;
}
public void setProyectoAsignado(Asignacion asignacion, int indice){
this.proyectosAsignados[indice] = asignacion;
}
public Asignacion getProyectoAsignado(int indice){
return this.proyectosAsignados[indice];
}
}
public class Proyecto{

private String idProyecto;
public class Asignacion{ private String nombre;
private String horario;
private double salario; public void setID(String id){
private Proyecto proyecto; this.idProyecto = id;
}
public void setHorario(String horario){ public String getID(){
this.horario = horario; return this.idProyecto;
} }
public String getHorario(){ public void setNombre(String nombre){
return this.horario; this.nombre = nombre;
} }
public void setSalario(double salario){ public String getNombre(){
this.salario = salario; return this.nombre;
} }
public double getSalario(){ }
return this.salario;
}
public void setProyecto(Proyecto proyecto){
this.proyecto = proyecto; public class Lider extends Investigador{
}
public Proyecto getProyecto(){ private Asignacion proyectoDirigidoAsignado;
return this.proyecto;
} ////// Qué métodos hacen falta aquí ??? ///////
}
}

// Código: TestInvestigador
Investigador leda = new Investigador();

leda.setID("inv004");
leda.setNombre("Leda");
leda.setProyectosAsignados( new Asignacion[ 2 ] );
for (int i = 0; i < 2; i++){

leda.setProyectoAsignado( new Asignacion(), i );
if ( i == 0) {
leda.getProyectoAsignado( i ).setProyecto( new Proyecto() );
leda.getProyectoAsignado( i ).getProyecto().setID("proy001");
leda.getProyectoAsignado( i ).getProyecto().setNombre("Aspirinix AB");
leda.getProyectoAsignado( i ).setHorario("09:00 - 15:00");
leda.getProyectoAsignado( i ).setSalario(150.0);
} else if ( i == 1) {
leda.getProyectoAsignado( i ).setProyecto( new Proyecto() );
leda.getProyectoAsignado( i ).getProyecto().setID("proy002");
leda.getProyectoAsignado( i ).getProyecto().setNombre("Ultimate Thin Diet");
leda.getProyectoAsignado( i ).setHorario("17:00 - 22:00");
leda.getProyectoAsignado( i ).setSalario(200.0);
}
}
String reporte = new String("La investigadora: ");

reporte = reporte + leda.getID() + " --> ";
reporte = reporte + leda.getNombre() + "\n";
reporte = reporte + "Participa en los siguientes proyectos: \n";
for (int i = 0; i < 2; i++){

reporte = reporte + leda.getProyectoAsignado( i ).getProyecto().getID();
reporte = reporte + " --> ";
reporte = reporte + leda.getProyectoAsignado( i ).getProyecto().getNombre();
reporte = reporte + leda.getProyectoAsignado( i ).getHorario();
reporte = reporte + " --> $ ";
reporte = reporte + leda.getProyectoAsignado( i ).getSalario() + "\n";
}

// Código: TestLider
Lider lili = new Lider();

lili.setID("inv001");
lili.setNombre("Lili");
lili.setProyectoDirigidoAsignado( new Asignacion() );

lili.getProyectoDirigidoAsignado().setProyecto( new Proyecto() );
lili.getProyectoDirigidoAsignado().getProyecto().setID("proy001");
lili.getProyectoDirigidoAsignado().getProyecto().setNombre("Aspirinix AB");
lili.getProyectoDirigidoAsignado().setHorario("06:00 - 09:00");
lili.getProyectoDirigidoAsignado().setSalario(100.0);
lili.setProyectosAsignados( new Asignacion[ 2 ] );
for (int i = 0; i < 2; i++){

lili.setProyectoAsignado( new Asignacion(), i );
if ( i == 0) {
lili.getProyectoAsignado( i ).setProyecto( lili.getProyectoDirigidoAsignado().getProyecto() );
lili.getProyectoAsignado( i ).setHorario("09:00 - 15:00");
lili.getProyectoAsignado( i ).setSalario(125.0);
} else if ( i == 1) {
lili.getProyectoAsignado( i ).setProyecto( new Proyecto() );
lili.getProyectoAsignado( i ).getProyecto().setID("proy002");
lili.getProyectoAsignado( i ).getProyecto().setNombre("Ultimate Thin Diet");
lili.getProyectoAsignado( i ).setSalario(175.0);
}
}

reporte = reporte + lili.getID() + " --> ";
reporte = reporte + lili.getNombre() + "\n";
reporte = reporte + "Directora del Proyecto: ";
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getProyecto().getID();

reporte = reporte + lili.getProyectoDirigidoAsignado( ).getProyecto().getNombre();
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getHorario();
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getSalario() + "\n";
for (int i = 0; i < 2; i++){

reporte = reporte + lili.getProyectoAsignado( i ).getProyecto().getID();
reporte = reporte + lili.getProyectoAsignado( i ).getProyecto().getNombre();
reporte = reporte + lili.getProyectoAsignado( i ).getHorario();
reporte = reporte + lili.getProyectoAsignado( i ).getSalario() + "\n";
}

Problemas y Ejercicios Elementales
import javax.microedition.midlet.*; de Modelado OO Hoja 35
import javax.microedition.lcdui.*;
public class TestLider extends MIDlet{
private Display display;

private Form screen;
private Lider lili;
public void startApp()

throws MIDletStateChangeException {
display = Display.getDisplay(this);
screen = new Form("Test Lider");
lili = new Lider();
display.setCurrent(screen);
this.printReport();
}
public void pauseApp(){
lili = null;
screen = null;
}
public void destroyApp(boolean incondicional){
lili = null;
screen = null;
display = null;
}
public void printReport()
lili.setID("inv001");
lili.setNombre("Lili");
lili.setProyectoDirigidoAsignado( new Asignacion() );

lili.getProyectoDirigidoAsignado().setProyecto( new Proyecto() );
lili.getProyectoDirigidoAsignado().getProyecto().setID("proy001");
lili.getProyectoDirigidoAsignado().getProyecto().setNombre("Aspirinix AB");
lili.getProyectoDirigidoAsignado().setHorario("06:00 - 09:00");
lili.getProyectoDirigidoAsignado().setSalario(100);
lili.setProyectosAsignados( new Asignacion[ 2 ] );

for (int i = 0; i < 2; i++){
lili.setProyectoAsignado( new Asignacion(), i );
if ( i == 0) {
lili.getProyectoAsignado( i ).setProyecto( lili.getProyectoDirigidoAsignado().getProyecto() );
lili.getProyectoAsignado( i ).setSalario(125);
} else if ( i == 1) {
lili.getProyectoAsignado( i ).setProyecto( new Proyecto() );
lili.getProyectoAsignado( i ).getProyecto().setID("proy002");
lili.getProyectoAsignado( i ).getProyecto().setNombre("Ultimate Thin Diet");
lili.getProyectoAsignado( i ).setSalario(175);
}
}
reporte = reporte + lili.getID() + " --> ";
reporte = reporte + lili.getNombre() + "\n";
reporte = reporte + "Directora del Proyecto: ";
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getProyecto().getID();
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getProyecto().getNombre();
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getHorario();
reporte = reporte + lili.getProyectoDirigidoAsignado( ).getSalario() + "\n";
for (int i = 0; i < 2; i++){
reporte = reporte + lili.getProyectoAsignado( i ).getProyecto().getID();
reporte = reporte + lili.getProyectoAsignado( i ).getProyecto().getNombre();
reporte = reporte + lili.getProyectoAsignado( i ).getHorario();
reporte = reporte + lili.getProyectoAsignado( i ).getSalario() + "\n";
}
screen.append(reporte);
}
} Luis Ernesto Rubio T.

Desarrollo Elemental OO

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Desarrollo Elemental OO

Hochgeladen von

Copyright:

Verfügbare Formate

Dearrollo Elemental OO Hoja 1

Luis Ernesto Rubio T.

ELEMENTOS BÁSICOS DE ANÁLISIS, DISEÑO Y PROGRAMACIÓN OO....................................... 3

PATRÓN FUNDAMENTAL DE OPERATIVIDAD .................................................................................... 9

ESTRATEGIA ELEMENTAL DE APRENDIZAJE DE ANÁLISIS Y DISEÑO OO ............................ 11

EJEMPLO 2: LOS CURSOS DE SUPERSOFTWARE ............................................................................ 18

EJEMPLO 3: LOS INVENTORES .............................................................................................................. 23

EJEMPLO 4: UNA PERSONA DE TANTAS ............................................................................................. 27

EJEMPLO 5: CONTROL DE PROYECTOS ............................................................................................. 31

Luis Ernesto Rubio T.

Elementos Básicos de Análisis, Diseño y Programación OO

nombre = Leonardo Da Vinci

Estos objetos, colocados individualmente en alguna de las direcciones de la memoria de trabajo

Luis Ernesto Rubio T.

public void setInventor(Inventor autor){

Luis Ernesto Rubio T.

nombre = Leonardo Da Vinci

Las asociaciones suelen implementarse en los lenguajes de programación, mediante la declaración

Las asociaciones son inherentemente bidireccionales, aunque el nombre de la asociación suela

La multiplicidad de una asociación especifica el número de instancias que pueden estar

Luis Ernesto Rubio T.

public class Invento{ public class Inventor{

Otros tipos especiales de relaciones son las asociaciones de Agregación/Composición y la

Un ejemplo representativo de esta problemática es el de la programación de interfaces gráficas de

Luis Ernesto Rubio T.

Otro poderoso mecanismo de estandarización e integración de código, lo conforman las

Luis Ernesto Rubio T.

protected Animal(int legs) {

public abstract void eat(); //Pet.java

public void setName(String name) {

// Demonstrate calling super methods

Luis Ernesto Rubio T.

Patrón Fundamental de Operatividad

Z nextZ ( ) {... } sizeZs ( ) : int

Estrategia Elemental de Aprendizaje de Análisis y Diseño OO

Etapa de Análisis ( ¿Qué ? )

1. Análisis desde la Perspectiva del Usuario (User View):

¿Qué puede hacer el usuario con el Sistema?

Responde a la pregunta modelando un Diagrama de Casos de Uso en UML.

2. Análisis desde la Perspectiva del Desarrollador (Structural View):

¿Qué objetos intervienen en la solución al problema?

Nota: Diagrama de Instancias.- representa gráficamente a los objetos que en la memoria de la

Luis Ernesto Rubio T.

Etapa de Diseño ( ¿Cómo ? )

3. Diseño del comportamiento de los objetos del sistema (Behavioral View):

¿Cómo se efectúan las tareas y procesos con nuestros objetos?

Puedes responder a la pregunta modelando un Diagrama Secuencia/Colaboración UML. En esta

4. Diseño de la estructura del sistema (Structural View):

¿Cómo se definen las características (propiedades/atributos) de los objetos diseñados?

Puedes responder a la pregunta modelando un Diagrama de Clases al nivel de Diseño (incluye

Luis Ernesto Rubio T.

Ejemplo 1: La Cuenta Bancaria de Tim Solley

Apertura con balance inicial de: $ 500.00

ETAPA DE ANÁLISIS ( ¿QUÉ ? )

1. Análisis desde la Perspectiva del Usuario (User View):

¿Qué puede hacer el usuario con el Sistema?

Se responde a la pregunta modelando un Diagrama de Casos de Uso en UML.

Luis Ernesto Rubio T.

2. Análisis desde la Perspectiva del Desarrollador (Structural View):

¿Qué objetos intervienen en el despliegue del reporte?

Analysis Class Diagram

Luis Ernesto Rubio T.

ETAPA DE DISEÑO ( ¿CÓMO ? )