Datos de Identificación

Asignatura Programación I
Código 3154
Semestre Tercero
Área Programación
Programa Ingeniería en Informática
Departamento Sistemas
Fecha de Elaboración 08/03/2012
Fecha Última actualización 21/11/2016
Primera Parte (Preliminares del Aprendizaje)
Introducción
Objetivos
Objetivo General
Objetivo Específico
Fuentes de Información
Evaluación de los aprendizajes
Segunda Parte (Desarrollo del Aprendizaje)
Conocimientos Previos
Metodología
Análisis del problema
Diseño orientado a objetos
Atributos
Métodos y Constructores
Patrón MVC
El Modelo
La Vista
El Controlador
Diagrama de clases con sus relaciones
Codificación del programa en el lenguaje de
programación (C++)
Las metodologías son un proceso
disciplinado que se siguen para el
desarrollo de software (programas), con el
fin de hacerlo de excelente calidad, de una
forma eficiente.

Existen variadas metodologías

que permiten el análisis,
implementación y
documentación de grandes
sistemas orientados a objetos.
En este curso visualizaremos como un programa orientado a
objetos está formado por una colección de objetos
interactuando conjuntamente a través del paso de mensajes,
para representar y solucionar algún problema.
El programa estará constituido por un conjunto de objetos
relacionados entre sí, los cuales permitirán: (a) hacer la entrada
de datos, (b) realizar los cálculos necesarios para resolver el
problema planteado y (c) suministrar la salida de datos, que no
es más que la información solicitada.

objeto 1 objeto 2

objeto 3 objeto 4 objeto 5

objeto 6 objeto 7
Construir soluciones programadas a problemas
planteados aplicando la metodología para el
desarrollo de programas orientados a objetos.

1. Comprender el problema.
2. Aplicar el patrón de diseño Modelo Vista
Controlador (MVC) a problemas de aplicación.
3. Utilizar un lenguaje de programación para la
implementación de programas de aplicación.
4. Valorar las pruebas efectivas en la solución de
los programas.
• Díaz, R, 2010 Lineamiento para La Programación
Orientada a Objetos, utilizando la Arquitectura Modelo
Vista Controlador y el Lenguaje C++. Trabajo de
ascenso. UCLA.
En esta guía se encuentra de forma detallada casi todo el
contenido de la unidad.

• López, L. 2006. Metodología de la Programación

Orientada a Objetos. Alfaomega Grupo Editor, S.A. de
C.V.
• Mestras, J, 2008. Estructura de las Aplicaciones Orientadas
a Objetos. El patrón Modelo-Vista-Controlador (MVC).
http://www.fdi.ucm.es/profesor/jpavon/poo/2.14.MV
C.pdf
La evaluación de tu aprendizaje en esta unidad será de la
siguiente manera:

Tendrás disponible una autoevaluación

que podrás tomar en el momento que te sientas preparado
mientras está disponible la Unidad.
Estarán disponibles un conjunto de
ejercicios propuestos, para profundizar y reforzar el
manejo del patrón MVC.

Esta unidad se evaluará en la primera

evaluación práctica de 5 pts.
Esta unidad se evaluará en el primer
parcial escrito de 25 pts.
Para el estudio exitoso de esta unidad requieres
tener el dominio de:
Nociones básicas de Programación Orientada a
Objetos.
Identificar los componentes de un diagrama de
clases.
Creación de diagramas de clases en el lenguaje
unificado UML.
Representar las clases en C++
La metodología para el desarrollo de
programas orientados a objetos planteada en
este curso, consta de tres etapas:
Análisis del problema.
Diseño orientado a objetos.
Codificación del programa en un lenguaje
de programación (C++).
Diseño

Análisis
Codificación
Para ilustrar la metodología, se irán explicando
cada una de las etapas antes mencionadas con el
siguiente enunciado de un problema:
Una compañía dedicada a la venta de repuestos
de automóviles, necesita que se le automatice el
proceso de ventas, de tal manera que al final del
mes se pueda determinar cuál será la comisión
por ventas que ganarán cada uno de sus
vendedores, así como también el sueldo neto de
los mismos.
Cuando un vendedor comienza a trabajar en la
compañía, se le solicitan algunos datos
personales, como son: cedula y nombre. Además
el vendedor tiene un sueldo base que es el que la
compañía le asigna desde el comienzo.
Actualmente cada vendedor tiene una deducción que
corresponde al 1% por Ley de Política Habitacional y al
4% por Seguro Social obligatorio, que son aplicados sobre
su sueldo base.
Además, la comisión por ventas de cada uno se determina
en función de un porcentaje que se aplica al monto total
de las ventas que éste obtuvo al final del mes,
considerando la siguiente tabla:

Monto de las ventas Porcentaje

Mayor o igual a 20000,00 7
Menor que 20000,00 4

Es importante resaltar que la compañía, además de la

información de cada uno de sus vendedores, también
requiere que se le suministre cuál es el monto total que
debe cancelar por la nómina.
En la etapa de análisis, el elemento central es el
objeto, es decir, se estudia el problema y se
identifican los objetos involucrados.

Estudiar el problema
implica que se debe
entender claramente
cuales son los
requerimientos del
usuario, esto se logra
obteniendo respuesta a las
siguientes preguntas:
¿Qué datos se necesitan para
resolver el problema?
Se obtienen los datos que hay que
ingresar para la solución.

¿Qué información debe proporcionar la

resolución del problema?
Se obtienen los resultados deseados.

¿Cómo obtener la información que

proporcionará la resolución del problema?

Se definen los diferentes procesos, en los cuales

se usarán los datos proporcionados por el
usuario, para obtener la solución.
Se debe leer detenidamente la definición del
problema planteado, para obtener respuesta a las
preguntas mencionadas anteriormente. En el
problema planteado, se tiene las siguientes
respuestas:

¿Qué datos se necesitan para resolver el problema?

Por cada vendedor:

cedula,
nombre,
sueldo_base,
monto_ventas
 ¿Qué información debe proporcionar
la resolución del problema?

Por cada vendedor:

cedula
nombre
comision
sueldo_neto

Por la compañía:
monto_total_nomina
 ¿Cómo obtener la información que proporcionará
la resolución del problema?
Para obtener la comisión
if (monto_ventas >= 20000.00)
comisión = monto_ventas * 0.07
else comisión = monto_ventas * 0.04
Para obtener la deducción
deducción = sueldo_base * 0.05
Para obtener el sueldo neto
sueldo_neto = sueldo_base + comisión – deducción
Para obtener el monto total de la nomina
monto_total_nomina = monto_total_nomina + sueldo_neto
 En la etapa de análisis, también se debe determinar el
objeto o colección de objetos, que el programa debe
representar y manejar para solucionar el problema
planteado.
Los objetos se determinan subrayando cada sustantivo
(nombre) presentes en la definición y algunos criterios a
seguir para clasificar los objetos son:
1. Cosas tangibles (mesa, carro, avión).
2. Organizaciones (empresa, departamentos,
divisiones)
3. Incidentes (representa un suceso, por
ejemplo: vuelo, accidente, transacción).
4. Papeles o roles (cliente, empleado, médico)
5. Interacciones (compras, ventas).
6. Lugares (ciudad, muelle de carga, sala de
embarque)
No todos los nombres (sustantivos)
identificados son buenos candidatos a objetos,
ya que, algunos serán atributos de los mismos.
En el enunciado del problema planteado, los
sustantivos que pueden representar a los
objetos que dan la solución al problema son:

1. Vendedor
2. Compañía
Este es un proceso, cuyo objetivo es
construir el diagrama de clases del problema
que se desea resolver.

El diagrama de clases
contiene todas las clases con
sus respectivos atributos y
comportamiento, que
aparecen en la solución del
problema, así como también
las relaciones entre ellas.
Durante el diseño se seguirán los siguientes
pasos para construir el diagrama de clases:
1. Identificar las clases: Los objetos identificados en
el análisis se convierten en clases.
En el problema planteado,
las clases serían Vendedor y Compannia.

En los diagramas de clases y

en los programas no se permite
el caracter ñ y el acento ( ‘ )
2. Asignación de atributos y comportamientos
de cada clase: Se debe determinar las
responsabilidades de las clases identificadas.

Primera responsabilidad:
Información que un objeto
de una clase ha de
mantener (atributos).
Segunda responsabilidad:
Operaciones que un objeto
de la clase puede realizar,
(métodos).
Los atributos de un objeto pueden ser de dos
tipos:

Atributos que tendrán

almacenados datos que
provienen de algún
dispositivo de entrada.

Atributos que tendrán

datos que se generan
mediante cálculos.
Los métodos que un objeto de una clase puede
poseer son:
Métodos Setters para cada atributo, que permiten
colocarle a cada uno el valor que tomará, dicho
valor proviene del exterior de la clase.
Métodos Getters para cada atributo, que permiten
darle salida al valor que contiene cada uno, a
quien lo esté solicitando .
Los métodos Setters y Getters son indispensables
en una clase, debido a que los atributos son
privados, y solo pueden se accedidos a través de
estos métodos.
Métodos que retornan un valor, resultado
de alguna operación de cálculo o lógica
realizada con los atributos de la clase.
Métodos de procesamiento, que contienen
operaciones de cálculo, lógicas, entre otras,
que actualizan el contenido de los atributos
de una clase.

Las clases definidas deben incluir

los constructores requeridos.
Las responsabilidades (atributos y métodos) de cada clase se deben
ir diseñando utilizando la notación gráfica de una clase en UML.
A continuación se presentan las clases del problema planteado:
Vendedor
- cedula : string
- nombre : string
- sueldo_base : float
- monto_ventas : float
+ Vendedor ()
+ SetCedula(c : string) : void Método que calcula la
+ SetNombre (n : string ) : void
+ SetSueldoBase (s : float ) : void comisión del vendedor
+ SetMontoVentas(m:float) : void
+ GetCedula () : string Método que calcula las
+ GetNombre() : string
+ GetSueldoBase() : float deducciones del vendedor
+ GetMontoVentas () : float
+ ComisionVentas() : float Método que calcula el
+ Deduccion () : float
+ SueldoNeto() : float
sueldo neto del vendedor
Compannia
- monto_nomina : float
+ Compannia ()
+ SetMontoNomina(m : float) : void
+ GetMontoNomina() : float
+ ProcesarVendedor(v : Vendedor) : void

Método que recibe un objeto

de la clase Vendedor, con el
propósito de solicitarle el
sueldo neto a dicho objeto y
acumularlo en el atributo
monto_nomina
Aplicación del patrón de diseño Modelo Vista
Controlador (MVC) e identificación de las
relaciones entre clases
La arquitectura Modelo Vista Controlador establece
que un programa orientado a objetos está formado
por tres partes:
El Modelo
La Vista
El Controlador
Es la clase o conjunto de clases identificadas
en el dominio del problema, ellas
representan al objeto u objetos presentes en
el problema.
Para identificar que son clases del modelo, se
le antepone la letra M al nombre de la clase.

En el problema planteado
las clases Vendedor y
Compannia ya analizadas,
quedarían con los nuevos
nombres: MVendedor y
MCompannia.
En la vista se encuentra la interfaz del usuario,
representa la entrada de datos y salida de la
información.
La entrada de datos es lo que el usuario del
programa proporciona a través de un dispositivo
de entrada, por ejemplo el teclado.
La salida de la información es lo que el usuario
observará en la pantalla, impresora u otro
dispositivo de salida de la computadora, al
operar el programa.
A cada clase de la Vista se le debe anteponer al
nombre de la clase, la letra V.
Normalmente las clases Vista no poseen
atributos
En el problema planteado, se necesitan dos
clases Vista:

Clase VVendedor: que contiene los

métodos que lean por el teclado cada uno
de los datos del Vendedor y un método
que muestre la información por pantalla
del vendedor.

Clase VCompannia: que contiene un

método que muestre por pantalla el
monto total de la nomina.
Clases de la Vista utilizando la notación gráfica de una
clase en UML.
VVendedor Métodos
que leen los
+ VVendedor () datos del
+ LeerCedula() : string vendedor
+ LeerNombre() : string
+ LeerSueldoBase () : float
+ LeerMontoVentas () : float Muestra la
+ ImprimirVendedor (c : string,
n : string, información
co : float, del vendedor
sn : float) : void

VCompannia
Muestra el
monto total
+ VCompannia ()
+ ImprimirMontoNomina(mtn : float) : void de la nomina
 Es la clase que lleva el control del funcionamiento
del programa, auxiliándose de las clases de la
Vista, que es lo que el usuario verá en la pantalla,
impresora u otro dispositivo de salida; y de las
clases del Modelo que es la parte que representa y
soluciona el problema.

IMPORTANTE: En el patrón de diseño

MVC, las clases de la Vista y las clases
del Modelo no se relacionan entre sí, es
el controlador el que lleva el control del
funcionamiento del programa,
mandando los mensajes respectivos a
estas clases, que permitirán obtener la
solución del problema
Clase Controlador utilizando la notación gráfica de una clase
en UML.
Controlador
- mc : MCompannia
+ Controlador ()
+ ProcesarVendedores() : void
+ ReporteCompannia() : void
En el método
ReporteCompannia se le
solicita al objeto de la
clase MCompannia, la
información que se
necesita pasar a la
VCompannia para ser
mostrada por pantalla
En el método ProcesarVendedores se
realizarán secuencialmente las
siguientes tareas:
1. El objeto de la clase VVendedor
solicitará al usuario el ingreso por el
teclado de los datos que se necesitan.
2. Los datos leídos, se utilizarán para
darle estado al objeto de la clase
MVendedor, con los métodos Setters.
3. El Controlador solicitará al objeto de la
clase MVendedor, la información que
se necesita pasar a la VVendedor para
ser mostrada por pantalla.
4. Se activa el método ProcesarVendedor
de la clase MCompannia que se
encargara de totalizar los sueldos.
5. Debe existir una estructura repetitiva
ya que se van a procesar varios
vendedores
 MVendedor VVendedor

- cedula : string
- nombre : string
- sueldo_base : float
- monto_ventas : float
+ MVendedor ()
+ SetCedula(c : string) : void
+ SetNombre (n : string ) : void
+ SetSueldoBase (s : float ) : void
+ SetMontoVentas(m : float) :void
+ GetCedula () : string
+ GetNombre() : string
+ GetSueldoBase() : float
+ GetMontoVentas () : float
+ ComisionVentas() : float
+ Deduccion () : float
+ SueldoNeto() : float
+ VVendedor ()
+ LeerCedula() : string
+ LeerNombre() : string
+ LeerSueldoBase () : float
+ LeerMontoVentas () : float
+ ImprimirVendedor (c : string,
n : string,
co : float,
sn : float) : void
VCompannia
+ VCompannia ()
+ ImprimirMontoNomina(mtn : float):void

MCompannia
Controlador
- monto_nomina: float
- mc : MCompannia
+ MCompannia ()
+ SetMontoNomina(m : float) : void + Controlador ()
+ GetMontoNomina() : float + ProcesarVendedores() : void
+ ProcesarVendedor(mv : MVendedor) : void + ReporteCompannia() : void
#ifndef MVENDEDOR_H
#define MVENDEDOR_H
#include <string>
using namespace std;

class MVendedor
{
private:
string cedula, nombre;
float sueldo_base,
monto_ventas; string GetCedula();
public: string GetNombre();
MVendedor(); float GetSueldoBase();
void SetCedula(string); float GetMontoVentas();
void SetNombre(string); float ComisionVentas();
void SetSueldoBase(float); float Deduccion();
void SetMontoVentas(float); float SueldoNeto();
};
#endif
#include "MVendedor.h"
MVendedor::MVendedor(){}
void MVendedor::SetCedula(string c)
{
cedula = c;
}
:::
string MVendedor::GetCedula()
{
return cedula;
}
:::
float MVendedor::ComisionVentas()
{
if (monto_ventas>=20000)
return monto_ventas * 0.07;
else
return monto_ventas * 0.04;
}
float MVendedor::Deduccion()
{
return sueldo_base * 0.05;
}
float MVendedor::SueldoNeto()
{
return sueldo_base + ComisionVentas() - Deduccion();
}
#ifndef MCOMPANNIA_H
#define MCOMPANNIA_H
#include "MVendedor.h "
class MCompannia
{
private:
float monto_nomina;
public:
MCompannia();
void SetMontoNomina(float m);
float GetMontoNomina();
void ProcesarVendedor (MVendedor mv);
};
#endif
#include "MCompannia.h"

MCompannia::MCompannia()
{ monto_nomina = 0; }

:::

/* Se actualiza el atributo monto_nomina de MCompannia,

acumulando en dicho atributo el sueldo neto del
vendedor. Para obtener el sueldo neto del vendedor
se debe pasar como parámetro el objeto de MVendedor */
void MCompannia::ProcesarVendedor (MVendedor mv)
{
monto_nomina += mv.SueldoNeto();
}
#ifndef VVENDEDOR_H
#define VVENDEDOR_H

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
class VVendedor
{
public:
VVendedor();
string LeerCedula();
string LeerNombre();
float LeerSueldoBase();
float LeerMontoVentas();
void ImprimirVendedor (string c, string n, float co,
float sn);
};
#endif
#include "VVendedor.h“
VVendedor::VVendedor(){}
string VVendedor::LeerCedula()
{
string c;
cout<<"Cedula : " ;
cin.sync(); // blanquea el buffer de entrada
getline(cin,c); /* lee el string hasta el final de la línea */
return c;
}
float VVendedor::LeerSueldoBase()
{
float sb;
cout << "Sueldo Base : " ;
cin >> sb;
return sb;
}
:::::
void VVendedor::ImprimirVendedor (string c, string n,
float co, float sn)
{
cout << "INFORMACION DEL VENDEDOR" << endl;
cout << "==================" << endl;
cout << "Cedula : " << c << endl;
cout << "Nombre : " << n << endl;
cout << "Comision de Ventas : "
<< setiosflags(ios::fixed)<< setprecision(2)
<< co << endl;
cout << "Sueldo Neto : "
<< setiosflags(ios::fixed)<< setprecision(2)
<< sn << endl;
}
#ifndef VCOMPANNIA_H
#define VCOMPANNIA_H

#include <iostream>
#include <iomanip>
using namespace std;

class VCompannia
{
public:
VCompannia();
void ImprimirMontoNomina (float mtn);
};
#endif
#include "VCompannia.h"

VCompannia::VCompannia(){}

void VCompannia::ImprimirMontoNomina (float mtn)

{

cout << "INFORMACION POR LA EMPRESA"<< endl;

cout << "==================" << endl;
cout << "Monto total a cancelar por la nomina : “
<< setiosflags(ios::fixed)
<< setprecision(2) << mtn << endl;

}
#ifndef CONTROLADOR_H_
#define CONTROLADOR_H_

#include "MCompannia.h“
// MCompannia automáticamente incluye a MVendedor

#include "VVendedor.h"
#include "VCompannia.h“

class Controlador
{ private:
MCompannia mc; // relación de composición con
// MCompannia
public:
Controlador();
void ProcesarVendedores();
void ReporteCompannia();
};
#endif
#include "Controlador.h"
Controlador::Controlador(){}
void Controlador::ProcesarVendedores()
{
MVendedor mvend; // relación de agregación con
VVendedor vvend; // MVendedor y VVendedor
string c,n;
float sb,mv;
int resp;
do // ciclo repetitivo para procesar varios vendedores
{
cout << "DATOS DEL VENDEDOR" << endl;
cout << "==================" << endl;
/* Se solicita al objeto de la clase VVendedor, cedula,
nombre, sueldo base y el monto de las ventas */
c = vvend.LeerCedula();
n = vvend.LeerNombre();
sb = vvend.LeerSueldoBase();
mv = vvend.LeerMontoVentas();
 // Se le da estado al objeto de la clase MVendedor
mvend.SetCedula(c);
mvend.SetNombre(n);
mvend.SetSueldoBase(sb);
mvend.SetMontoVentas(mv);
/* Se pasa información al método del objeto de la
clase VVendedor, para que la imprima */
vvend.ImprimirVendedor(mvend.GetCedula(),
mvend.GetNombre(),
mvend.ComisionVentas(),
mvend.SueldoNeto());
/* Se activa el método que procesa al vendedor
realizado por el objeto de la clase MCompannia y se
le pasa como parámetro el objeto de la clase Vendedor */
mc.ProcesarVendedor(mvend);
cout <<"Desea procesar otro Vendedor (1)Si (2)No“
<< endl;
cin >> resp;
}
while (resp == 1); }
void Controlador::ReporteCompannia()
{
VCompannia vc; // relación de agregación con
//Vcompannia

/* Se pasa información al método del objeto

de la clase VCompannia para que la imprima */
vc.ImprimirMontoNomina (mc.GetMontoNomina());
}
#include "Controlador.h"

int main()
{
Controlador c;
c.ProcesarVendedores();
c.ReporteCompannia();
return 0;
}
Ahora debes programar los
siguientes requerimientos
adicionales

Determinar la mayor comisión

entre todos los vendedores

Porcentaje de vendedores
con una comisión mayor o
superior a 20000,00

Promedio de
las comisiones
Debes revisar en la Zona de Recursos de esta
Unidad, el directorio Material Didáctico, en
donde se presentan dos planteamientos (Ejercicio
Aplicación Unidad IV Taller Mecánico y Ejercicio
Aplicación Unidad IV Competencias de Natación), de
los cuales se hace el análisis del problema para
finalmente desarrollar el programa en el lenguaje
de programación.
Estos proyectos y además el
Proyecto Vendedores, los
puedes encontrar desarrollados
en la Zona de Recursos,
directorio Ejercicios
Demostrativos.