Programación Orientada a Objetos

Universidad Autónoma del Carmen
Facultad de Ciencias de la Información
Academia de Programación
Programación Visual
Manual de Prácticas de Laboratorio
Elaborado por:



M.C. Fernando Enrique Sánchez Martínez
M.I. Jesús Alejandro Flores Hernández
M.C. José Ángel Pérez Rejón
Cursos que apoya:



Programación Gráfica I (IDM)
Programación Visual (ICO e ISC)
Desarrollo de Aplicaciones con .NET
2015
CONTENIDO
Introducción ................................................................................................................................................. 1
Sección 1. ...................................................................................................................................................... 2
Lectura 1. Programación Orientada a Objetos ......................................................................................... 2
Práctica 1. Programación orientada a objetos vs. Programación estructurada. ...................................... 6
Lectura 2. Estructura de una clase. .......................................................................................................... 7
Práctica 2. Uso del IDE. ............................................................................................................................. 9
Práctica 3. Definición de clases y objetos. Parte 1. ................................................................................ 11
Práctica 4. Definición de clases y objetos. Parte 2. ............................................................................... 12
Sección 2. Manejo de Componentes. ......................................................................................................... 14
Práctica 5. Agenda Telefónica. ............................................................................................................... 14
Práctica 6. Calculadora. .......................................................................................................................... 15
Sección 3. Desarrollo de una aplicación integradora de POO. ................................................................... 16
Práctica 7. Proyecto integrador 1. .......................................................................................................... 16
Práctica 8. Proyecto integrador 2. .......................................................................................................... 17
Práctica 9. Proyecto integrador 3. .......................................................................................................... 18
Bibliografía.................................................................................................................................................. 19
INTRODUCCIÓN
La presente obra tiene como objetivo apoyar el curso de Programación Visual
ofertado a los alumnos de los programas educativos de Ingeniería en Computación
e Ingeniería en Sistemas Computacionales; Desarrollo de Aplicaciones con .NET que
se ofrece como Optativo; al igual, que a los alumnos de la Ingeniería en Diseño
Multimedia que cursan Programación Gráfica I de la Facultad de Ciencias de la
Información.
El manual de prácticas se encuentra estructurado en tres secciones. Las dos
primeras contemplan los aspectos teóricos y prácticos de los fundamentos de la
programación orientada a objetos. La segunda sección propone el desarrollo de un
proyecto integral que deberá estar basado en una necesidad real.
La primera sección propone dos lecturas y el desarrollo de cuatro actividades. En la
segunda, por no contener un alto contenido conceptual, será el profesor quién
mediante ejemplos deberá presentar a los alumnos las características de los
componentes visuales propios del lenguaje de programación. Por último, en la
tercera sección, se definen los pasos para completar en proyectos integrales.
Para este manual se utilizó el lenguaje de programación C# integrado en la suite de
Visual Studio .NET; sin embargo, tiene una estructura semejante a C++ y Java.
Programación Visual – Manual de Prácticas de Laboratorio
Página 1
SECCIÓN 1.
LECTURA 1. PROGRAMACIÓN ORIENTADA A OBJETOS
El paradigma de Programación Orientada a objetos (POO) es una forma
especial de programar, más cercana a como expresaríamos las cosas en la
vida real que otros tipos de programación.
Con la POO tenemos que aprender a pensar las cosas de una manera
distinta, para escribir nuestros programas en términos de objetos,
propiedades, métodos y otras cosas que veremos rápidamente para aclarar
conceptos y dar una pequeña base que permita soltarnos un poco con este
tipo de programación.
Durante años, los programadores se han dedicado a construir aplicaciones
muy parecidas que resolvían una y otra vez los mismos problemas. Para
conseguir que los esfuerzos de los programadores puedan ser utilizados por
otras personas se creó la POO. Que es una serie de normas de realizar las
cosas de manera que otras personas puedan utilizarlas y adelantar su
trabajo, de manera que consigamos que el código se pueda reutilizar.
La POO no es difícil, pero es una manera especial de pensar, a veces
subjetiva de quien la programa, de manera que la forma de hacer las cosas
puede ser diferente según el programador. Aunque podamos hacer los
programas de formas distintas, no todas ellas son correctas, lo difícil no es
programar orientado a objetos sino programar bien. Programar bien es
importante porque así nos podemos aprovechar de todas las ventajas de la
POO.
Conceptos clave





Objeto.
Comunicación entre objetos: mensajes.
Clases.
Herencia.
Polimorfismo.
¿Qué es la Programación Orientada a Objetos (POO)?
Booch define la POO como:
Un método de implementación en el que los programas se organizan como
colecciones cooperativas de objetos, cada uno de los cuales representan una
instancia a una clase, y cuyas clases son todas miembros de una jerarquía de
clases unidas mediante relaciones de herencia.
Existen tres partes importantes en la definición: la programación orientada a
objetos 1) utiliza objetos, no algoritmos, como bloques de construcción lógicos
Programación Visual – Manual de Prácticas de Laboratorio
Página 2
(jerarquía de objetos); 2) cada objeto es una instancia de una clase, y 3) las clases
se relacionan unas con otras por medio de relaciones de herencia.
El objeto
En programación convencional los programas se dividen en dos componentes:
procedimientos y datos. Este método permite empaquetar código de programa en
procedimientos, pero ¿Qué sucede con los datos? Las estructuras de datos utilizadas
en programación son globales o se pasan como parámetros. En esencia los datos se
tratan separadamente de los procedimientos.
En POO un programa se divide en componentes que contienen procedimientos y
datos. Cada componente se considera un objeto. Un objeto es una unidad que
contiene datos y las funciones que operan sobre esos datos. A los elementos de un
objeto se les conoce como miembros o atributos; las funciones que operan sobre los
datos se denominan métodos (en C++ también se llaman funciones miembro) y los
datos se denominan miembros datos. En C++ un programa consta de objetos. Los
objetos de un programa se comunican entre sí mediante el paso o envío de mensajes
(acciones que debe ejecutar el objeto).
En POO los objetos pueden se cualquier entidad del mundo real:




Objetos físicos
o automóviles en una simulación de tráfico
o aviones en un sistema de control de tráfico aéreo
o animales mamíferos, etc
Elementos de interfaces gráficos de usuarios
o ventanas
o iconos
o menús
o ratones
Estructuras de datos
o arrays
o pilas
o árboles binarios
Tipos de datos definidos por el usuario
o números complejos
o hora del día
Un objeto es una unidad que contiene datos y las funciones que operan
sobre esos datos. Los datos se denominan miembros dato o atributos y las
funciones métodos o funciones miembro.
Los datos y las funciones se encapsulan en una única entidad. Los datos o atributos
están ocultos y sólo mediante los métodos es posible acceder a ellos.
Programación Visual – Manual de Prácticas de Laboratorio
Página 3
Nombre del objeto
Métodos
Datos
V
Coad/Yourdon
Métodos
Nombre del
objeto
Variables
Taylor
Nombre
Atributos
Métodos
Booch
OMT
Notaciones Gráficas de Objetos
Datos
operaciones
y
Ejemplo
Coche 1
Placa
Marca
Modelo
Precio
Año_compra
Calcular_Precio_Actual
En resumen:
Atributos: Datos o variables que caracterizan el estado de un objeto.
Métodos: Procedimientos o acciones que cambian el estado del objeto.
Programación Visual – Manual de Prácticas de Laboratorio
Página 4
Encapsulación
El objeto retiene cierta información y sabe cómo realizar ciertas operaciones. La
encapsulación de operaciones e información es muy importante. Los métodos de un
objeto solo pueden manipular directamente datos asociados con ese objeto. Dicha
encapsulación es la propiedad que permite incluir en una sola entidad (objeto) la
información (atributos) y las operaciones (métodos o funciones) que operan sobre
esa información.
Métodos
Atributos y/o métodos
Sección privada
Sección pública
Métodos y mensajes
Los objetos pueden ser activados mediante la recepción de mensajes. Un mensaje es
simplemente una petición para que un objeto se comporte de una determinada
manera, ejecutando uno de sus métodos. La técnica de enviar mensajes se conoce
como paso de mensajes.
Estructuralmente un mensaje consta de tres partes:



la identidad del objeto receptor
la función miembro del receptor cuya ejecución se ha solicitado
cualquier otra información adicional que el receptor pueda necesitar para
ejecutar el método requerido (parámetros).
En C++ y Java, la notación utilizada es
nombre_del_objeto.función_miembro();
Ejemplo: Se tiene un objeto o1 con los siguientes atributos: nombre_alumno y curso
y con los métodos: leer_nombre e imprimir. Si el objeto o1 recibe el mensaje
imprimir, esto se expresa:
o1.imprimir();
La sentencia anterior se lee: "enviar mensaje imprimir al objeto o1". El objeto o1
reacciona al mensaje ejecutando método de igual nombre que el mensaje.
El mensaje puede llevar parámetros:
o1.leer_nombre("Pedro Pérez");
Programación Visual – Manual de Prácticas de Laboratorio
Página 5
Sin los mensajes los objetos que se definan no podrán comunicarse con otros
objetos. Desde un punto de vista convencional, el paso de mensajes no es más que
el sinónimo de llamada a una función.
Clases
Una clase es la descripción de un conjunto de objetos; consta de métodos y atributos
que resumen características comunes de un conjunto de objetos. Se pueden definir
muchos objetos de la misma clase. Dicho de otro modo, una clase es la declaración
de un tipo de objeto.
Las clases son similares a los tipos de datos y equivalen a modelos o plantillas que
describen cómo se construyen ciertos tipos de objetos. Cada vez que se construye un
objeto a partir de una clase estamos creando lo que se llama una instancia de esa
clase. Por consiguiente, los objetos no son más que instancias de una clase. Una
instancia es una variable de tipo objeto. En general, instancia de una clase y objeto
son términos intercambiables.
Programa Orientada a Objetos
Un programa orientado a objetos es una colección de clases. Necesitará una función
principal que cree objetos y comience la ejecución mediante la invocación de sus
métodos.
Esta organización conduce a separar partes diferentes de una aplicación en distintos
archivos. La idea consiste en poner la descripción de la clase para cada una de ellas
en un archivo separado. La función principal también se pone en un archivo
independiente. El compilador ensamblará el programa completo a partir de los
archivos independientes en una única unidad.
En realidad, cuando se ejecuta un programa orientado a objetos, ocurren tres
acciones:
1. Se crean los objetos cuando se necesitan
2. Los mensajes se envían desde unos objetos y se reciben en otros
3. Se borran los objetos cuando ya no son necesarios y se recupera la memoria
ocupada por ellos
PRÁCTICA 1. PROGRAMACIÓN ORIENTADA A OBJETOS VS. PROGRAMACIÓN
ESTRUCTURADA.
Objetivo
Analizar el contraste conceptual y de técnicas de programación entre los dos
paradigmas.
Programación Visual – Manual de Prácticas de Laboratorio
Página 6
Descripción
Para esta actividad el alumno deberá investigar las características de ambos
paradigmas y realizar un cuadro comparativo.
Procedimiento
1. Analizar las características de la programación orientada a objetos en la
Lectura 1.
2. Investigar las características de la programación estructurada.
3. Diseñar un cuadro comparativo que permita identificar las similitudes y
diferencias entre ambos paradigmas de programación. Considerar las
ventajas y desventajas de trabajar en uno u otro paradigma.
Materiales
La actividad deberá ser entregada en material impreso en la clase correspondiente.
LECTURA 2. ESTRUCTURA DE UNA CLASE.
En C#, una clase es un tipo de dato muy eficaz. Como las estructuras, las clases
definen los datos y el comportamiento del tipo de datos. Los programadores
pueden crear objetos que son instancias de una clase. A diferencia de las
estructuras, las clases admiten herencia, que es una parte fundamental de la
programación orientada a objetos.
Declarar clases
Las clases se definen mediante la palabra clave class, como se muestra en el
ejemplo siguiente:
C#
public class Customer
{
//Fields, properties, methods and events go here...
}
El nivel de acceso precede a la palabra clave class. En este caso, se utiliza public,
que significa que cualquiera puede crear objetos a partir de esta clase. El nombre
de la clase sigue a la palabra clave class. El resto de la definición es el cuerpo de
clase, donde se definen el comportamiento y los datos. Los campos, propiedades,
métodos y eventos de una clase se conocen colectivamente como miembros de
clase.
Programación Visual – Manual de Prácticas de Laboratorio
Página 7
Crear objetos
Aunque se utilizan a veces de forma intercambiable, una clase y un objeto son
cosas diferentes. Una clase define un tipo de objeto, pero no es propiamente un
objeto. Un objeto es una entidad concreta basada en una clase y, a veces, se
denomina instancia de una clase.
Los objetos se pueden crear con la palabra clave new seguida del nombre de la
clase en la que se basará el objeto, de la manera siguiente:
C#
Customer object1 = new Customer();
Cuando se crea una instancia de una clase, una referencia al objeto se vuelve a
pasar al programador. En el ejemplo anterior, object1 es una referencia a un objeto
basado en Customer. Esta referencia hace referencia el nuevo objeto, pero no
contiene los datos del propio objeto. De hecho, se puede crear una referencia a
objeto sin crear un objeto:
C#
Customer object2;
No se recomienda la creación de referencias a objetos como ésta, que no hace
referencia a un objeto, porque al intentar el acceso a un objeto a través de esa
referencia se producirá un error en tiempo de ejecución. Sin embargo, este tipo de
referencia se puede crear para hacer referencia a un objeto, ya sea creando un
nuevo objeto o asignándola a un objeto existente, de la forma siguiente:
C#
Customer object3 = new Customer();
Customer object4 = object3;
Este código crea dos referencias a objeto que se refieren al mismo objeto. Por
consiguiente, los cambios realizados en el objeto a través de object3 se reflejarán
en los usos posteriores de object4. El hecho de que las clases se conozcan como
tipos de referencia se debe a que se hace referencia a los objetos basados en clases
por referencia.
Ejemplo
En el ejemplo siguiente, se define una clase pública que contiene un campo único,
un método y un método especial denominado constructor. Luego se crean
instancias de la clase con la palabra clave new.
C#
public class Person
{
// Field
public string name;
Programación Visual – Manual de Prácticas de Laboratorio
Página 8
// Constructor
public Person()
{
name = "unknown";
}
// Method
public void SetName(string newName)
{
name = newName;
}
}
class TestPerson
{
static void Main()
{
Person person1 = new Person();
System.Console.WriteLine(person1.name);
person1.SetName("John Smith");
System.Console.WriteLine(person1.name);
}
}
Resultado
unknown
John Smith
PRÁCTICA 2. USO DEL IDE.
Objetivo
Utilizar el ambiente de programación del Visual Studio .NET.
Descripción
Implementar en Visual Studio .NET el ejemplo incluido en esta actividad y
compilarlo.
Procedimiento
1. Crear un proyecto de aplicación en Visual Studio .NET con lenguaje C# con
el nombre de EjemploCocheApp.
2. Agregar al proyecto una clase llamada Coche.
Programación Visual – Manual de Prácticas de Laboratorio
Página 9
class Coche
{
protected double velocidad=0;
public string Marca;
public string Modelo;
public string Color;
public string NumBastidor;
public Coche(string marca, string modelo, string color, string
numbastidor)
{
this.Marca=marca;
this.Modelo=modelo;
this.Color=color;
this.NumBastidor=numbastidor;
}
public double Velocidad
{
get
{
return this.velocidad;
}
}
public void Acelerar(double cantidad)
{
// Aquí se le dice al motor que aumente las revoluciones
pertinentes, y...
Console.WriteLine("Incrementando la velocidad en {0} km/h",
cantidad);
this.velocidad += cantidad;
}
public void Girar(double cantidad)
{
// Aquí iría el código para girar
Console.WriteLine("Girando el coche {0} grados", cantidad);
}
public void Frenar(double cantidad)
{
// Aquí se le dice a los frenos que actúen, y...
Console.WriteLine("Reduciendo la velocidad en {0}
cantidad);
this.velocidad -= cantidad;
}
}
km/h",
3. En el método Main implementar el siguiente código.
class EjemploCocheApp
{
static void Main()
{
Coche
MiCoche=new
"Azul","1546876");
Coche("Peugeot",
"306",
Console.WriteLine("Los datos de mi coche son:");
Console.WriteLine("Marca: {0}", MiCoche.Marca);
Console.WriteLine("Modelo: {0}", MiCoche.Modelo);
Programación Visual – Manual de Prácticas de Laboratorio
Página 10
Console.WriteLine("Color: {0}", MiCoche.Color);
Console.WriteLine("Número
de
bastidor:
MiCoche.NumBastidor);
MiCoche.Acelerar(100);
Console.WriteLine("La
km/h",MiCoche.Velocidad);
MiCoche.Frenar(75);
Console.WriteLine("La
km/h",MiCoche.Velocidad);
{0}",
velocidad
actual
es
de
{0}
velocidad
actual
es
de
{0}
MiCoche.Girar(45);
}
}
4. Compilar el programa y comprobar los resultados.
Los datos de mi coche son los siguientes:
Marca: Peugeot
Modelo: 306
Color: Azul
Número de bastidor: 1546876
Incrementando la velocidad en 100 km/h
La velocidad actual es de 100 km/h
Reduciendo la velocidad en 75 km/h
La velocidad actual es de 25 km/h
Girando el coche 45 grados
Materiales
Equipo de cómputo con Visual Studio .NET instalado.
PRÁCTICA 3. DEFINICIÓN DE CLASES Y OBJETOS. PARTE 1.
Objetivo
Diseñar una clase que contemple los tres elementos: atributos, constructores y
métodos.
Descripción
Un cliente requiere de una aplicación que le permita administrar su lista de
contactos comerciales. Como primera solicitud define los datos que requiere
organizar de cada uno de sus contactos: nombre, apellido paterno, apellido
materno, teléfono, celular, nextel, email, empresa y puesto.
Programación Visual – Manual de Prácticas de Laboratorio
Página 11
Crear una clase que permita el almacenamiento y administración de los datos que
integran a un contacto.
Procedimiento
5. Crear una clase llamada Contacto que incluya los siguientes atributos:
nombre, apellido paterno, apellido materno, teléfono, celular, nextel, email,
empresa y puesto
6. Implementar un constructor que reciba todos los datos por parámetro.
7. Implementar el conjunto de métodos que reciban los datos de manera
individual por parámetro (métodos “set”).
8. Implementar el conjunto de métodos que retornen los datos de manera
individual (métodos “get”).
9. Implementar un método que retorne todos los datos del contacto como
instancia de la clase Contacto. (Investigar como retornar objetos a través de
un método).
Materiales
La clase deberá diseñarse en papel usando el lenguaje de programación C#. Deberá
crearse la clase en Visual Studio .NET una vez aprobado por el profesor.
PRÁCTICA 4. DEFINICIÓN DE CLASES Y OBJETOS. PARTE 2.
Objetivo
Implementar una clase que administre los procesos de ingreso, eliminación y
modificaciones de una lista de contactos.
Descripción
En la actividad anterior se creó una clase llamada Contacto donde se integran los
atributos y métodos que identifican y gestionan los procesos de un registro. En esta
actividad se implementará una clase que incluya como atributo un vector de
Contactos y que incluya los métodos que gestionen los procesos básicos de un
sistema de información.
Programación Visual – Manual de Prácticas de Laboratorio
Página 12
Procedimiento
1. Investigar los métodos de la clase Vector.
a. Como se declaran.
b. Como se obtiene el tamaño del arreglo.
c. Como se declaran arreglos de objetos.
d. La clase Vector, sus métodos y como se utilizan.
2. Diferencia entre arreglo unidimensional y la clase Vector.
3. Al proyecto creado en la actividad anterior agregar una clase llamada
Agenda.
4. En la clase Agenda, incluir un vector como atributo que almacene objetos de
la clase Contacto.
5. La clase debe contener los métodos:
a. Nuevo para agregar un nuevo contacto al vector,
b. Editar para sustituir un contacto existente,
c. Eliminar para borrar a un contacto del vector.
Materiales
La clase deberá diseñarse en papel usando el lenguaje de programación C#. Deberá
crearse la clase en Visual Studio .NET una vez aprobado por el profesor.
Programación Visual – Manual de Prácticas de Laboratorio
Página 13
SECCIÓN 2. MANEJO DE COMPONENTES.
PRÁCTICA 5. AGENDA TELEFÓNICA.
Objetivo
Implementar la interfaz gráfica de la agenda telefónica.
Descripción
Crear la interfaz gráfica de la aplicación donde el usuario pueda ingresar nuevos
contactos a la agenda, visualizar los almacenados, editarlos y eliminarlos.
Procedimiento
1. Crear una ventana principal donde se pueda seleccionar a un contacto y se
desplieguen sus datos.
2. Incluir una barra de menús con la opción principal (Contactos) y como
submenú las opciones Nuevo, Editar y Eliminar.
3. Integrar una barra de herramientas con las cuatro botones (Nuevo, Editar,
Guardar y Eliminar) incluyendo imágenes.
4. El botón guardar debe estar deshabilitado.
5. Para agregar un nuevo contacto se debe abrir un cuadro de diálogo captura
de los datos.
6. Para eliminar un contacto debe enviar un cuadro de diálogo que confirme la
eliminación del contacto.
7. Se debe agregar un ComboBox que muestre todos los Apodos de los
contactos y al seleccionar uno se deben desplegar todos los datos que le
corresponden en la ventana principal.
8. Todos los componentes gráficos donde se muestran los datos del contacto
seleccionado debes estar deshabilitados, para que no se puedan modificar.
9. Al presionar el botón de Editar se deben habilitar los componentes gráficos y
también el botón de guardar, para que éste al ser presionado almacene los
cambios.
Materiales
Equipo de cómputo con Visual Studio .NET instalado.
Programación Visual – Manual de Prácticas de Laboratorio
Página 14
PRÁCTICA 6. CALCULADORA.
Objetivo
Implementar una calculadora.
Descripción
Analizar el funcionamiento de una calculadora gráfica sencilla e implementar una
con las funciones aritméticas básicas.
Procedimiento
1. Analizar el funcionamiento de la calculadora
Windows.
2. Crear un nuevo proyecto de Visual Studio .NET
3. Crear una ventana.
4. Incluir el cuadro de texto.
5. Integrar los botones.
6. Implementar funcionalidad a los números.
7. Implementar funcionalidad a los operadores.
de
Materiales
Equipo de cómputo con Visual Studio .NET instalado.
Programación Visual – Manual de Prácticas de Laboratorio
Página 15
SECCIÓN 3. DESARROLLO DE UNA APLICACIÓN INTEGRADORA DE POO.
PRÁCTICA 7. PROYECTO INTEGRADOR 1.
Objetivo
Implementar una aplicación basada en dos clases, donde el alumno debe aplicar la
comunicación entre objetos.
Descripción
Implementar el proyecto de un banco, para el manejo de una cuenta única que
permita realizar depósitos y retiros; permitiendo mantener actualizado el saldo. Los
alumnos deberán seguir el procedimiento en la secuencia señalada en un lenguaje
orientado a objetos. El proyecto deberá realizarse en equipo.
Procedimiento
1.
2.
3.
4.
5.
6.
7.
8.
10.
11.
Crear una clase llamada Cuenta con los siguientes atributos: número de
cuenta, nombre del cliente y saldo.
Agregar los métodos set y get correspondientes a la clase Cuenta.
Incluir en la clase Cuenta un método llamado “deposito” que reciba por
un monto por parámetro y se sume al saldo. El método debe retornar el
saldo final.
Incluir en la clase Cuenta un método llamado “retiro” que reciba un
monto por parámetro y lo reste al saldo en caso de contar con recursos
suficientes. El método debe retornar el saldo final si se aplicó el retiro y
en caso contrario retornar -1 (este valor servirá para reconocer cuando se
aplicó o no el retiro).
Crear una clase llamada Operaciones con 1 objeto de la clase Cuenta
como atributo.
En la clase Operaciones agregar un método llamado “nuevaCuenta” que
solicite los datos al usuario y los agregue al objeto de la clase Cuenta.
En la misma clase, implementar el método “nuevoDeposito” que solicitará
al usuario el monto que desea depositar y se deberá hacer una llamada al
método “deposito” de la clase Cuenta para completar la operación y por
ultimo mostrará al usuario el nuevo saldo del cliente.
En la misma clase, implementar el método “nuevoRetiro” que solicitará al
usuario el monto que desea retirar y se deberá hacer una llamada al
método “retiro” de la clase Cuenta para completar la operación y por
ultimo mostrará al usuario el nuevo saldo del cliente o en su caso indicar
que no se pudo realizar la operación por falta de fondos.
En la clase Operaciones, desarrollar el método “consulta” que mostrará
En la función principal, Implementar el menú de opciones: nuevo cliente,
consulta, depósito, retiro y salir con sus respectivas llamadas a los
métodos de la clase Operaciones.
Materiales
Equipo de cómputo con Visual Studio .NET instalado, Netbeans o C++.
Programación Visual – Manual de Prácticas de Laboratorio
Página 16
PRÁCTICA 8. PROYECTO INTEGRADOR 2.
Implementar una aplicación basada en dos clases, donde el alumno debe aplicar la
comunicación entre objetos.
Descripción
Implementar el proyecto de un banco, para el manejo de una cuenta única que
permita realizar depósitos y retiros; permitiendo mantener actualizado el saldo. Los
alumnos deberán seguir el procedimiento en la secuencia señalada en un lenguaje
orientado a objetos. El proyecto deberá realizarse en equipo.
Procedimiento
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
Crear una clase llamada Cliente con los siguientes atributos: Número de
cuenta, nombre del cliente, límite de crédito y saldo.
Agregar un constructor sin parámetros que inicialice el saldo en 0.
Agregar los métodos set y get correspondientes a la clase Cliente.
Incluir en la clase Cliente un método llamado “compra” que reciba el
monto de la compra por parámetro e incremente el saldo, siempre y
cuando no sobre pase el límite de crédito, en caso de hacerlo la compra
no debe registrarse y se debe retornar un -1. El método debe retornar el
saldo final.
Incluir en la clase Cliente un método llamado “abono” que reciba un
monto por parámetro y lo reste al saldo. El método debe retornar el
saldo final.
Crear una clase llamada Tienda con 1 objeto de la clase Cliente como
atributo.
En la clase Tienda agregar un método llamado “nuevoCliente” que solicite
los datos al usuario y los agregue al objeto de la clase Cliente.
En la misma clase, implementar el método “nuevaCompra”, donde el
usuario ingresará el monto de la compra, actualizar el saldo del Cliente y
mostrar el monto al que asciende la deuda o en su caso indicar que no se
puede aplicar la compra porque excede del límite de crédito.
En la misma clase, implementar el método “nuevoPago” que solicitará al
usuario el monto que desea abonar a la cuenta. Se deberá mostrar el
saldo después de aplicar el pago.
En la clase Tienda, desarrollar el método “consulta” que mostrará los
datos actuales del Cliente.
En la función principal, implementar el menú de opciones: nuevo cliente,
consulta, compra, pago y salir con sus respectivas llamadas a los
métodos de la clase Tienda.
Materiales
Equipo de cómputo con Visual Studio .NET instalado, Netbeans o C++.
Programación Visual – Manual de Prácticas de Laboratorio
Página 17
PRÁCTICA 9. PROYECTO INTEGRADOR 3.
Objetivo
Implementar una aplicación real donde el alumno aplique los conocimientos
adquiridos en el curso.
Descripción
Definir, diseñar e implementar un proyecto integrador. Los alumnos en equipo
definirán un proyecto real, identificando las necesidades de información, diseñando
la interfaz, las clases e implementado el mismo en Visual Studio .NET. El proyecto
deberá realizarse en equipo.
Procedimiento
1. En equipo, los alumnos definirán el proyecto, su objetivo y alcances.
2. Se redactará la especificación de requisitos del proyecto con base a las
necesidades de información.
3. Se diseñarán las clases de entidad y control.
4. Se diseñará la interfaz en papel o software de edición de imágenes.
5. Implementación del proyecto en C#.
6. Implementación de captura de errores.
7. Pruebas de la aplicación.
8. Integración de la documentación técnica
9. Presentación formalmente el proyecto.
Materiales
Equipo de cómputo con Visual Studio .NET instalado, Netbeans o C++.
Programación Visual – Manual de Prácticas de Laboratorio
Página 18
BIBLIOGRAFÍA
Básicas:
1. Joyanes Aguilar, Luis. Fundamentos de la programación. 1ª. Edición. McGraw-Hill / Interamericana de
España, S.A. 2008. ISBN: 9788448161118.
2. Leobardo López Román, “Metodología de la programación orientada a objetos”, 1ª edición, Alfaomega
Grupo Editor México, ISBN: 970-15-1173-5, ASIN: B0038ALDJQ, 2006.
3. Carlos Alberto Vanegas, “Lenguaje de Programación I Programación Orientada a Objetos”,
UNIVERSIDAD DISTRITAL, ISBN-10: 9588247918, ISBN-13: 978-9588247915, ASIN: B0038ASXS0, 2007.
4. Ceballos, Francisco Javier. C/C++ Curso de Programación. Alfaomega Ra-Ma. 2002.
5. López Román, Leobardo. Metodología de la programación orientada a objetos. Alfaomega Ra-Ma.
2006.
6. Peñaloza Romero, Ernesto. Fundamentos de programación C/C++. Alfaomega Ra-Ma. 2006
7. Ceballos, Francisco Javier. Programación orientada a objetos con C++. Alfaomega Ra-Ma. 2008.
8. DALE, Programación y resolución de problemas con C++.
McGraw-Hill. 2008.
9. Barnes David J., Kölling Michael, “Programación Orientada a Objetos con Java: Una Introducción
Practica usando Blue J”, 3ª edición, Pearson Education, ISBN-10: 8483223503, ISBN-13: 9788483223505, 2007.
10. E. ET AL. Pimentel, “Programación Orientada A Objetos con Java”, Ediciones Paraninfo, ISBN-10:
8497325729, ISBN-13: 978-8497325721, 2007.
11. Terán Jorge, “Resolviendo problemas con el lenguaje de programación C++”, CodeRoad SRL, 2011.
Web:
1. La Web del Programador: Comunidad de Programadores: http://www.lawebdelprogramador.com
2. Pagina de recursos de UML http://www.uml.org
3. Tutor java nivel básico: http://www.programacion.com/articulo/tutorjava_nivel_basico_97/1
4. Conceptos básicos de la POO (en C++):
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/clases.htm
5. Programación Orientada a Objetos Conceptos de POO
http://www.ii.uam.es/~castells/docencia/poo/1-conceptos.pdf
Programación Visual – Manual de Prácticas de Laboratorio
Página 19