Unidad III Prog - Orientada Objeto Poo

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 13

Profesor: Ing.

Wilmer León

Unidad Curricular: Procesamientos de Datos

UNIDAD III

La programación orientada a objetos permite trasladar a los


programas la forma de pensar que tenemos en la solución o descripción de
problemas en general. Normalmente nos referimos a entidades (objetos),
que solemos clasificar en grupos con características y funcionamiento
comunes (clases), y de las cuales nos interesan ciertas características
(propiedades) y su funcionamiento (métodos). Además, al relacionar unos
objetos con otros para diseñar sistemas complejos, solemos utilizar la
encapsulación, esto es, permitimos que los objetos interactúen entre sí sólo
a través de las características y funcionalidades expuestas al exterior,
mientras que las características y funcionalidades internas de cada uno son
ignoradas por el resto. El lenguaje C++ es una extensión a C para soportar
la programación orientada a objetos (POO). Lo que sigue no es un manual
de C++, sino una muy breve introducción para ser capaz de manejar los
objetos, propiedades y métodos de las clases de MFC Para escribir código
en C++ se pondrá la extensión ‘.cpp’ a los archivos de código fuente.

El prototipo de una función en C++ es una declaración que informa al


compilador sobre los tipos de retorno y los tipos de los parámetros que
tendrá una función. Esto permite que el compilador compruebe que los tipos
sean correctos cada vez que se utilice la función.
Por otro lado, el prototipado rápido es una estrategia que se utiliza
para desarrollar productos, en la que se construye un modelo preliminar del
producto, se revisa y se itera. Esta técnica se puede aplicar a objetos
tangibles, software o procesos.
La metodología RAD (Rapid Application Development) es un modelo
de desarrollo de aplicaciones ágil que incluye la creación de prototipos, el
desarrollo interactivo y el uso de utilidades CASE (Computer Aided
Software Engineering).
El prototipado rápido se utiliza en muchos sectores industriales,
como el mecánico, el de la automoción, el de la óptica o el médico. Se
puede emplear en diferentes fases del ciclo productivo, como en la fase de
primer diseño, en pruebas con usuarios, en presentaciones o en pruebas de
producción.

Prototipado rápido: Qué es y cómo puede ayudarte - Miro


El prototipado rápido es una estrategia utilizada en el desarrollo de
productos en la que se construye rápidamente un prototipo o ...
Miro

Qué es y para qué sirve la metodología RAD - Incentro


25 dic 2019 — La metodología RAD o DRA (por sus siglas en inglés
Rapid Application Development y en castellano Desarrollo Rápido de A...
Incentro
Prototipo de una función en C++ - LinkedIn
3 dic 2020 — Un prototipo sirve para indicar al compilador los tipos
de retorno y los tipos de los parámetros que tendrá una función,
LinkedIn

Mostrar todos

1.1 Clases y objetos

El elemento fundamental de la POO es la clase. Una clase es una


definición de propiedades y métodos para un conjunto de entidades que
comparten características comunes. En C++, una clase se define de
manera similar a una estructura, pero utilizando la palabra
clave ‘class’ en lugar de ‘struct’, y pudiendo declarar como integrantes de la
misma tanto variables (propiedades) como métodos (funciones que
manipulan dichas variables; sólo se
indica su prototipo en la declaración de la clase).
Por ejemplo, para la manipulación de números complejos podemos crear
una clase Complejo, que incluiría como variables la parte real e imaginaria,
y como métodos el cálculo del módulo, argumento, la suma , multiplicación
y división de otro complejo, la exponenciación, etc. Tanto las variables
como los métodos pueden ser públicos (accesibles desde dentro y fuera del
objeto), privados (accesibles sólo desde las funciones de la clase) o
protegidos (accesibles desde las funciones de la clase y de sus derivadas.

Introducción a la programación orientada a objetos


con C++

Programación orientada a objetos o POO es un paradigma de


programación que usa objetos y sus interacciones, para diseñar
aplicaciones y programas informáticos. Está basado en varias técnicas,
incluyendo herencia, abstracción, polimorfismo y encapsulamiento.
Objecto:

 Los objetos son estructuras de datos en memoria.


 Un objeto lleva dos tipos de cosa : datos (o atributos) y
Código ejecutable (operaciones que este objeto puede hacer,
como funciones C).
 Los objetos tienen una interfaz y una implementación; solo la interfaz
esta visible por los otros objetos del entorno.

Datos:

Son guardados en variables propias al objeto.

Operaciones:
 Las operaciones que puede hacer el objeto se llaman métodos.
 La interfaz precisa el prototipo de cada método: nombre
Valor de regreso, nombre y tipos de los argumentos.

 Los métodos pueden cumplir tareas diversas: crear objetos, enviar


mensajes, hacer manipulación sobre las variables internas del
objeto.

Clase:

Son definiciones de las propiedades y comportamiento de un tipo de


objeto concreto. La instanciación es la lectura de estas definiciones y
la creación de un objeto a partir de ellas.

Herencia:

Es la facilidad mediante la cual la clase D hereda en ella cada uno de


los atributos y operaciones de C, como si esos atributos y
operaciones hubiesen sido de nidos por la misma D. Por lo tanto,
puede usar los mismos métodos y variables publicas declaradas en
C. Los componentes registrados como "privados"(private) también se
heredan, pero como no pertenecen a la clase, se mantienen
escondidos al programador y solo pueden ser accedidos a través de
otros métodos públicos. Esto es as para mantener hegemónico el
ideal de OOP.
Objeto

Entidad provista de un conjunto de propiedades o atributos (datos) y


de comportamiento o funcionalidad (métodos) los mismos que
consecuentemente reaccionan a eventos. Se corresponde con los
objetos reales del mundo que nos rodea, o a objetos internos del
sistema (del programa). Es una instancia a una clase.

Método

Son algoritmo asociado a un objeto (o a una clase de objetos), cuya


ejecución se desencadena tras la recepción de un \mensaje". Desde
el punto de vista del comportamiento, es lo que el objeto puede
hacer. Un método puede producir un cambio en las propiedades del
objeto, o la generación de un .eventocon un nuevo mensaje para otro
objeto del sistema.

1.5.3 Polimorfismo
En C++ se pueden declarar varias funciones con el mismo nombre
pero con parámetros o tipo devuelto distintos. El compilador
escogerá para cada llamada la función que se corresponda con los
parámetros y el tipo devuelto de cada llamado definiciones y la
creación de un objeto a partir de ellas.

Ejemplo
Polimorfismo
Ejemplo

class Rectangulo{
int x;
int y;
int ancho;
int alto;
//faltan las funciones miembro
}

****METODO***
class Rectangulo{
int x;
int y;
int ancho;
int alto;
int calcularArea(){
return (ancho*alto);
}
}

***SET***
class Rectangulo{
int x;
int y;
int ancho;
int alto;
void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
}

***CONSTRUCTORES***
class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int x1, int y1, int w, int h){
x=x1;
y=y1;
ancho=w;
alto=h;
}
}

***Public, Private***
public class Rectangulo {
int x;
int y;
int ancho;
int alto;
public Rectangulo() {
x=0;
y=0;
ancho=0;
alto=0;
}

***Public, Private***
public Rectangulo(int x1, int y1, int w, int h) {
x=x1;
y=y1;
ancho=w;
alto=h;
}

public Rectangulo(int w, int h) {


x=0;
y=0;
ancho=w;
alto=h;
}

***Public, Private***
int calcularArea(){
return (ancho*alto);
}
void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
boolean estaDentro(int x1, int y1){
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
return true;
}
return false;
}
}
La instanciación

En la programación orientada a objetos (POO) es el proceso de crear


objetos concretos a partir de una clase. Las instancias son un
elemento fundamental de la POO y están relacionadas con el
encapsulamiento y el polimorfismo, dos de los conceptos
fundamentales de esta programación.

Encapsulamiento:

Consiste en agrupar una líneas de código fuertemente relacionadas,


darles un nombre y encapsularlas en un método o una clase.

Existen tres herramientas que debes tener presentes siempre que


encapsules código:

 Usa nombres que revelen la intención


 Pasa pocos parámetros, tres ya son multitud
 Usa abstracciones del mismo nivel
Pasa pocos parámetros a los métodos creados

Pasa pocos parámetros a los métodos creados

Cuando lees un método que recibe parámetros necesitas saber qué


es cada uno de ellos para comprender qué hace. Por tanto, cuantos
menos haya, más fácil será de comprender. EL objetivo sigue siendo
el mismo, ahorrar memoria.

Tienes dos opciones para reducir parámetros:

 Opción 1: encapsular varios parámetros en una nueva clase y pasar


dicha clase como parámetro.

 Opción 2: dividir el método en otros que reciban menos parámetros.


Es decir, hacer encapsulaciones más pequeñas.

En ambos casos se trata de encapsular. :)


Ejemplo para la opción 1:

Imagina un método de búsqueda de contactos. El usuario puede


buscar por diferentes criterios, cada nuevo criterio de búsqueda se
convierte en un nuevo parámetro del método.

public Contacto BuscarContactoPor(


string nombre,
string dirección,
int estado,
int pais,
string email,
string empresa,
string telefono)
{
// código del método
}

Para resolver este problema podemos crear una nueva abstracción


que se llame CriteriosDeBusqueda y en ella encapsular los
parámetros de búsqueda. Esto nos permite pasar de varios
parámetros a uno solo

/ abstracción que representa todos los criterios por los que puede
buscar el usuario
public class CriteriosDeBusqueda
{
public string Nombre { get; set; }
public string Direccion { get; set; }
public int Estado { get; set; }
public int Pais { get; set; }
public string Email { get; set; }
public string Empresa { get; set; }
public string Telefono { get; set; }
}

public Contacto BuscarContactoPor(CriteriosDeBusqueda criterios) //


un sólo parámetro
{
// código del método
}
Ejemplo para la opción 2:

Imagina que tienes una clase Usuario a la que le puedes modificar


ciertas propiedades. Para ello, creas un método Modificar al que le
pasas todos los parámetros posibles:

public class Usuario


{
// Constructor omitido por brevedad

public string Nombre { get; private set; } // fíjate que todas las
propiedades son privadas
public string Apellidos { get; private set; }
public string Email { get; private set; }
public string Contraseña { get; private set; }

public void Modificar(string nombre, string apellidos, string


contraseña, string email)
{
// validaciones omitidas por brevedad

Nombre = nombre;
Apellidos = apellidos;
Email = email;
Contraseña = contraseña;
}

Puedes reducir el número de parámetros si en lugar de un único


método, creas tres diferentes:

public class Usuario


{
// propiedades de usuario

public void ModificarNombre(string nombre, string apellidos)


{
// validaciones omitidas por brevedad
Nombre = nombre;
Apellidos = apellidos;
}
public void ModificarContraseña(string contraseña)
{
// validaciones
Contraseña = contraseña;
}

public void CambiarEmail(string email)


{
// validaciones
Email = email;
}
}

En este ejemplo se ve claramente cómo la encapsulación ha


generado más código que la versión previa.

Siempre que hagas este tipo de cambios valora si el beneficio es


mayor que el coste.

Compara:

// menos código pero más costoso de leer


usuario.Modificar("Juan", "García", "123456",
"[email protected]");

// más código pero más fácil de leer / es más explícito y mantenible


usuario.ModificarNombre("Juan", "García");
usuario.ModificarContraseña("123456");
usuario.ModificarEmail("[email protected]");

Abtraccion:

es el resultado de encapsular una serie de variables, propiedades,


comportamientos, etc. en un método o clase generando un concepto
genérico cuyo objetivo es reducir la complejidad.

i cogemos piezas de nuestro código y las juntamos de modo que


puedan comportarse como una sola, habremos creado una
abstracción. Cada nueva abstracción es un puzle montado.
Hasta aquí la definición. Veamos ahora en este ejemplo a qué se
refiere con niveles:

A) Camino hacia el árbol y cojo una fruta

B) Giro hasta encarar el árbol,


mientras la distancia al árbol sea superior a un metro
muevo las piernas alternativamente hacia delante,
me paro,
alzo el brazo derecho,
cojo la fruta

Ambas instrucciones finalizan con el mismo resultado, pero la A) se


entiende mejor poque su nivel de abstracción es superior.

Veamos cómo sería un método que contiene instrucciones con


diferentes niveles de abstraccion:

void CojerFrutaDeArbol()
{
Girar();

while(1 < _distancia) // este while no tiene el mismo nivel de


abstracción que el resto de instrucciones
{
var piernaAMover = DetectarPiernaQueTocaMover();
MoverHaciDelanteCon(piernaAMover);
}

Parar();
AlzarElBrazo();
Coger(Fruta);
}

Podemos encapsular el while en un nuevo método que tenga el


mismo nivel de abstracción que el resto:

// encapsulamos generando una abstracción


void Caminar()
{
while(1 < _distancia)
{
MoverHaciaDelanteCon(PiernaDerecha);
MoverHaciaDelanteCon(PiernaIzquierda);
}
}

// un método con abstracciones del mismo nivel


void CojerFrutaDeArbol()
{
Girar();
Caminar();
Parar();
AlzarElBrazo();
Coger(Fruta);
}

También podría gustarte