guia de laboratorio #1 - Universidad Don Bosco

Ciclo 1-2013
Introducción a la Programación
UNIVERSIDAD DON BOSCO
FACULTAD DE ESTUDIOS TECNOLOGICOS
ESCUELA DE COMPUTACION
Material Semana 14
CICLO: 01-2013 " UNIDAD 10: Programación Orientada a Objetos (POO)”
MATERIA: INTRODUCCIÓN A LA PROGRAMACIÓN
Índice:
Objetivos Específicos-------------------------------------------------------------------------------------------------------------------------2
Paradigmas de la Programación Orientada a Objetos (POO)----------------------------------------------------------------------2
A. ENCAPSULACIÓN-----------------------------------------------------------------------------------------------------------2
B. POLIMORFISMO-------------------------------------------------------------------------------------------------------------3
C. HERENCIA--------------------------------------------------------------------------------------------------------------------3
¿Qué es un OBJETO?------------------------------------------------------------------------------------------------------------------------3
Clase-----------------------------------------------------------------------------------------------------------------------------------------------3
Objetos--------------------------------------------------------------------------------------------------------------------------------------------3
Creación de Clases y Objetos en Lenguaje C------------------------------------------------------------------------------------------5
Paso 1: definir a la Clase----------------------------------------------------------------------------------------------------5
Modificadores de Alcance de variables y funciones------------------------------------------------------------5
Miembros de una clase--------------------------------------------------------------------------------------------------6
Paso 2: Implementando los Objetos (instancias de una Clase)-------------------------------------------------6
Ejemplos de programación con POO-----------------------------------------------------------------------------------------------------7
"Bibliografía"-----------------------------------------------------------------------------------------------------------------------------------10
Facultad de Estudios Tecnológicos
pagina 1 de 10
Ciclo 1-2013
Introducción a la Programación
Objetivos Específicos
 Definir concepto de "Clase".
 Diferenciar la programación orientada a objetos (POO) con la Estructurada.
 Enumerar los conceptos de la POO: Objetos, Propiedades y Métodos.
Paradigmas de la Programación Orientada a Objetos (POO)
Los programas estructurados se basan en estructuras de control bien definidas (if, for, while, etc.),
bloques de código, subrutinas (funciones) independientes que soportan recursividad y variables locales.
La esencia de la programación estructurada es la reducción de un programa a sus elementos
constituidos.
La programación orientada a objetos (POO), permite descomponer un problema en subgrupos
relacionados. Cada subgrupo pasa a ser una entidad (objeto) autocontenida, que consta de sus propias
instrucciones y datos que le relacionan con ese objeto.
Entre los objetivos de la POO se tienen los siguientes:
1. Aumentar la abstracción de los programas para una mejor comprensión
2. Modularización de componentes
3. Reducir la redundancia de código
4. Reducir los tiempos de implementación
5. Aumentar la fiabilidad mediante la reutilización de componentes
Todos los lenguajes POO comparten tres características: Encapsulación, Polimorfismo y Herencia.
A. ENCAPSULACIÓN
Es el mecanismo que utiliza una clase para agrupar el código y los datos/informacion que maneja.
Ademas mantiene protegidos a estos datos, ocultando la información frente a cualquier interferencia y
mal uso. Cuando el código y los datos están enlazados de esta manera se ha creado un
objeto. Ese código y datos pueden ser privados para ese objeto o públicos para otras partes del
programa.
Facultad de Estudios Tecnológicos
pagina 2 de 10
Ciclo 1-2013
Introducción a la Programación
B. POLIMORFISMO
Es la cualidad que permite que un nombre se utilice para dos o más propósitos relacionados pero
técnicamente diferentes. El propósito es poder usar un nombre para especificar una clase general de
acciones. Por ejemplo en C tenemos tres funciones distintas para devolver el valor absoluto. Sin
embargo en C++ incorpora Polimorfismo y a cada función se puede llamar abs().El Polimorfismo se
puede aplicar tanto a funciones como a operadores
.
C. HERENCIA
Proceso mediante el cual un objeto puede adquirir las propiedades de otro objeto. La información se
hace manejable gracias a la clasificación jerárquica.
¿Qué es un OBJETO?
Conjunto de variables y funciones pertenecientes a una clase encapsulados. A este encapsulamiento es
al que se denomina objeto. Por tanto la clase es quien define las características y funcionamiento del
objeto.
Clase
Una Clase se describe normalmente como la plantilla o el proyecto a partir del cual se hace/construye
realmente el objeto. La forma normal de imaginarse a una clases es pensando en ella como una
“plantilla” (por ejemplo, el plano/diseño para hacer un billete, o un avión) que explica “como funcionara
un objeto cuando este se construya”; mientras que el “objeto” propiamente dicho es una
representación real (por ejemplo, un billete de $20 o un Boing 747) obtenida a partir de dicha plantilla.
Por lo tanto, una Clase es un tipo de Datos que contiene una serie de características, denominadas
ATRIBUTOS y un comportamiento definido mediante MÉTODOS. Cuando se crea un objeto a partir de
una clase, se dice que el programador ha creado una Instancia de dicha clase.
Objetos
Un Objeto es un elemento real o abstracto que tiene un estado, un comportamiento y una identidad. Un
objeto es, pues, una mesa, un alumno, un avión, etc., porque estos son elementos reales y están bien
definidos. También lo puede ser un concepto abstracto como un elemento llamado “Ordenador” que es
capaz de recibir un conjunto de números y ordenarlos ascendente o descendentemente.
Las características que definen un objeto son tres:
•
Identidad: Es la propiedad característica que tiene un objeto que le distingue de todos los demás
Por ejemplo, para hacer referencia al alumno “Juan Diego Pérez” se puede seleccionar alguno de los
datos que lo identifique durante toda su vida, como su nombre o su cédula de ciudadanía.
Facultad de Estudios Tecnológicos
pagina 3 de 10
Ciclo 1-2013
•
Introducción a la Programación
Estado: Viene determinado para el conjunto de propiedades o atributos que tiene el objeto (Estructura Estática), junto con los valores que pueden asumir cada uno de esos atributos (Estructura Dinámica).
Ejemplo:
Para el objeto alumno “Juan Diego Pérez”, se crearía en base a la clase siguiente:
Clase: Alumno
-
Nombres y Apellidos
-
Edad
-
Sexo
-
Dirección
-
Curso
-
Asignaturas
Su estructura dinámica en 1996:
-
Nombres y Apellidos: Juan Diego, Pérez
-
Edad : 15
-
Sexo : Masculino
-
Dirección : Calle 94 # 55-17
-
Curso : Noveno A
-
Asignaturas : Matemáticas, Español, Geografía, Historia
Su estructura dinámica en 1997:
-
Nombres y Apellidos: Juan Diego, Pérez
-
Edad : 16
-
Sexo : Masculino
-
Dirección : Calle 33 # 76A-35
-
Curso : Décimo A
-
Asignaturas : Matemáticas, Español, Química, Física
•
Comportamiento: Viene determinado por la forma de actuar al recibir un mensaje para que realice
una acción. Un Mensaje es una orden que se manda a un objeto para que realice una operación con
un propósito específico, por medio de la invocación o llamada que se hace de los métodos del obje to.
Un mensaje viene definido por tres componentes:
-
El objeto receptor del mensaje, es decir, al objeto que se envía el mensaje.
-
El selector del mensaje, que es la acción que se quiere que realice el objeto.
-
Los argumentos, que son los valores que se transmiten con el selector y que, en muchos casos, pue den ser nulos.
Por ejemplo, el mensaje:
Facultad de Estudios Tecnológicos
pagina 4 de 10
Ciclo 1-2013
Introducción a la Programación
Juan Diego Pérez. VerAsignaturasde(1996)
Indica que se desea conocer las asignaturas en que estuvo matriculado el alumno “Juan Diego
Pérez” en el año 1996.
Creación de Clases y Objetos en Lenguaje C
La base del encapsulamiento es la Clase, a partir de ellas se le dan las características (llamados
ATRIBUTOS) y comportamiento (llamados METODOS) a los objetos. Bajo C, una Clase es un “tipo de
Datos compuesto”.
Haciendo una comparación entre los elementos de C vistos anteriormente con los elementos de una
Clase, se puede establecer una similitud entre las variables (que serán los atributos de la clase) y las
funciones (que conformaran a los métodos)
Cuando se crea un objeto a partir de una clase, se dice que el programador ha creado una
Instancia de dicha clase. Para crear una clase y crear un objeto en base a la misma, se realizan 2
pasos fundamentales.
Paso 1: definir a la Clase
Lo primero es crear la clase. Se definen las variables (que se consideran los Atributos) y las funciones
(que serán los métodos que definen su comportamiento).
Modificadores de Alcance de variables y funciones
Las variables y funciones de una Clase pueden ser públicas, privadas o protegidas Por defecto si no
se indica nada, estas serán privadas. Este alcance de los elementos de una Clase nos indica ¿En cuales
partes de un programa se pueden utilizar las funciones y variables de la clase? y son los siguientes:
private: Solo tendrán acceso los miembros de la misma clase donde estén definidos.
public: Se pude hacer referencia desde cualquier parte del programa.
protected: Se implementa con la Herencia de clases. Se puede hacer referencia dentro de la misma
clase y las subclases.
La definición de una Clase en C++ consiste de la palabra reservada class, seguida del nombre de la
clase y finalmente el cuerpo de la clase encerrado entre llaves y finalizando con (;)
El cuerpo de la clase contiene la declaración de los atributos de la clase (variables) y la declaración
de los métodos (funciones), ver ejemplo a la derecha.
Tanto los atributos como los métodos pertenecen exclusivamente a la clase y sólo pueden ser usados a
través de un objeto de esa clase.
Facultad de Estudios Tecnológicos
pagina 5 de 10
Ciclo 1-2013
Introducción a la Programación
Miembros de una clase
Una clase está formada por un conjunto de miembros que pueden ser datos, funciones, clases anidadas,
enumeraciones, tipos de datos, etc.
Por el momento nos vamos a centrar en los datos y las funciones (Atributos y Métodos).
Atributos Miembros
Creación de una clase:
Todos los atributos que forman parte de una clase deben
ser declarados dentro de la misma. Tome en cuenta las
reglas siguientes:
class nomb_clase{
- Un miembro no puede ser declarado más de una vez.
public:
funciones y variables publicas;
- No es posible añadir miembros después de la declaración
de la clase.
private:
funciones y variables privadas;
}
Métodos Miembros
Los métodos al igual que los atributos, deben ser definidos
en la clase, pero el cuerpo de la función puede ir dentro o
fuera de la clase. Si un método se declara completo dentro
de la clase, se considera como inline.
Para definir un método miembro (el cuerpo de la funcion)
de una Clase fuera de la misma, se puede escribir luego
del cierre de la definición de la clase. El método se define
colocando el nombre de la clase a la cual está asociado y
luego el nombre del método. Para esto se ocupa el
operador de resolución de alcance (::)
Observe el siguiente ejemplo:
Ej 1: Metodo funX (en línea inline) y funY ()
Ej2: Metodo funY de la clase Miclase del Ej1,
definido fuera de la declaración de la clase.
Paso 2: Implementando los Objetos (instancias de una Clase)
Ahora vamos a ver cómo es posible crear objetos o instancias de esa clase. Hay que recordar que una
de las características de los objetos es que cada uno guarda un estado particular de acuerdo al valor de
sus atributos.
Facultad de Estudios Tecnológicos
pagina 6 de 10
Ciclo 1-2013
Introducción a la Programación
En la programación orientada a objetos, a las funciones son llamadas métodos y la invocación o llamada
se conoce como mensaje.
En C++ un objeto es una variable de un tipo definido por el usuario. Un objeto se puede crear dentro de
las diferentes funciones creadas en el código fuente, por lo general en la función principal main.
En resumen, observe a continuacion la sintaxis general para:
a) Crear a una Clase y definir a sus funciones Miembros, para luego
b) Crear a un objeto basado en esa clase especifica y como llamar/invocar a estas funciones
(métodos de la clase).
Y luego, analice los ejemplos de creación de clases e instanciación de objetos:
Creación de una clase:
class nomb_clase{
Creación del objeto:
public:
funciones y variables publicas;
nomb_clase nombre_objeto1;
nomb_clase nombre_objeto2;
private:
funciones y variables privadas;
Llamadas a las funciones de una clase:
}
nombre_objeto.nomb_funcion(parámetros);
Desarrollo de funciones miembro:
val_devuelto
nomb_clase::nomb_funcion(parametros){
cuerpo;
}
Ejemplos de programación con POO
Ejemplo 1: Como ejemplo, crearemos el primer programa utilizando objetos y clases para ver la teoría
llevada a la práctica.
#include <stdio.h>
#include <stdlib.h>
//definiendo a la funcion principal main
main()
//definicion de la clase miclase
class miclase{
{
/*instanciando a 2 variables objetos
prívate: //atributos privados
de la clase miclase*/
int a;
miclase obj1, obj2;
public: //metodos publicos
system("cls");
void pasar_a(int num);
Facultad de Estudios Tecnológicos
/*se envian mensajes a cada objeto obj1 y obj2, por medio de la
pagina 7 de 10
Ciclo 1-2013
int mostrar_a();
};
Introducción a la Programación
llamada
del método público (pasar_a) de cada uno*/
obj1.pasar_a(10);
//definiendo métodos de la clase (miclase)
void miclase::pasar_a(int num)
{
obj2.pasar_a(99);
/*se envian mensajes a ambos objetos, para que muestren el
valor de atributo privado (a) por medio de la llamada del método
público (mostrar_a) de la clase miclase*/
a=num;
printf("%d\n",obj1.mostrar_a());
}//fin método pasar_a de función mi clase
printf("%d\n",obj2.mostrar_a());
int miclase::mostrar_a()
{
system("pause");
}//fin función main
return a;
}//fin método mostrar_a de función mi clase
* Nota: system(“cls”): Se utiliza para limpiar la pantalla, para este ejemplo es innecesaria esa línea.
Ejemplo # 2: Realizar una aplicación en C que calcule la suma de 2 números introducidos por el
usuario, la operación debe implementarse en una Clase llamada: Suma, y a la vez Suma debe de tener
un método llamado: calcular, que reciba 2 parametros enteros(a y b) y retorne el valor entero del total
de la suma.
#include <stdio.h>
//definiendo a la funcion principal main
#include <conio.h>
int main()
#include <iostream.h>
{
int a, b;
//definición clase Suma
//creando objeto s basado en clase Suma
class Suma
Suma s;
{
// atributos de la clase Suma
cout<<"Digite el número a: ";
double resultado; //alcance privado
cin>>a;
cout<<"Digite el número b: ";
public:
cin>>b;
// métodos públicos de clase Suma
//llamando método calcular del objeto s
int calcular(int a, int b);
cout << "La suma de a + b es: " << s.calcular(a, b) << endl;
};
getch();
// implementación de método Suma
Facultad de Estudios Tecnológicos
}
pagina 8 de 10
Ciclo 1-2013
Introducción a la Programación
int Suma::calcular(int a, int b) {
return (a + b);
}
Ejemplo # 3: Este pequeño programa trata de calcular el área y la longitud de una circunferencia. Es
sencillo y usa clases e instancias de objetos.
#include<iostream.h>
#include<stdlib.h>
const double pi=3.141516;
class calcular{
double radio,area,longitud;
public:
void iniciar(void);
void entradaDatos(void);
void salidaDatos(void);
} calcular1;
main(void) {
calcular calcular2;
calcular1.iniciar();
calcular2.iniciar();
calcular1.entradaDatos();
calcular2.entradaDatos();
calcular1.salidaDatos();
calcular2.salidaDatos();
system("pause");
}
void calcular::iniciar(void) {
cout <<"PROGRAMA QUE CALCULA EL AREA Y LONGITUD DE UNA CIRCUNFERENCIA"<<"\n\n";
}
void calcular::entradaDatos(void) {
Facultad de Estudios Tecnológicos
pagina 9 de 10
Ciclo 1-2013
Introducción a la Programación
cout<<"INTRODUZCA EL RADIO DE LA CIRCUNFERENCIA"<<"\n";
cin>>radio;
area=pi*radio*radio;
longitud=2*pi*radio;
}
void calcular::salidaDatos(void) {
cout<<"AREA =\t\t" <<area <<"\n";
cout<<"LONGITUD =\t\t" <<area <<"\n\n";
}
"Bibliografía"
1. Fundamentos de programación
Autor: Ortiz, Alma Lissette, No clasificación: Trab: 005.1 0771999 Editorial: UDB
2. Introducción a la informática: Programas
Autor: Ruiz Coello, Roberto No. Clasificación: Trab 001.6403 R934 1999 Editorial UDB
3. Fundamentos de programación (Algoritmos y estructuras de datos)
Autor: Luis Joyanes Aguilar, Mc Graw Hill, 1999
4. Programación y resolución de problemas con C++
Nell Dale, Chip Weems, Cuarta edición, Mc Graw Hill, 2007
5. http://c.conclase.net/?id=vercodigo
2008
Facultad de Estudios Tecnológicos
pagina 10 de 10