Universidad de Costa Rica Sede Guanacaste IFIF-2000 Programacin I Programacin

Programacin Orientada a Objetos

Herencia

Concepto de Herencia
La herencia tiene connotaciones de transmisin Concepto de herencia en Programacin Orientada a Objetos:

Transmisin de la vista pblica (mtodos pblicos) y de la vista privada (atributos, (atributos mtodos privados y definicin de los mtodos) de una clase a otra

M.C.I Kenneth Snchez S.

Concepto de Herencia
ClasePadre -atributo1 -atributo2 -metodo1() +metodo2() +metodo3()

Se hereda el comportamiento (la interfaz) y los datos + (l i f ) l d cdigo (implementacin)

ClaseHija -atributo1 -atributo2 -metodo1() +metodo2() +metodo3()

M.C.I Kenneth Snchez S.

Relacin de Herencia
Se establece entre dos clases, es una relacin binaria

Clase Padre / Clase Base / Superclase

hereda de

Clase Hija / Clase Derivada / Subclase

M.C.I Kenneth Snchez S.

Jerarqua de clasificacin
La relacin de herencia permite establecer j jerarquas por grado d t bl d de clasificacin Si en la jerarqua de clasificacin intervienen N clases se establecern clases, entonces N-1 relaciones de herencia
M.C.I Kenneth Snchez S.

Jerarqua de clasificacin
Caractersticas:
Eminentemente subjetivas
Dificultad para establecer una clasificacin perfecta

Surgen elementos no categorizables categorizables

Elementos que no se acomodan completamente en ninguna categora

M.C.I Kenneth Snchez S.

Jerarqua de clasificacin
Animal
-celulas +comer()

Vertebrado
-celulas -huesos +comer() +romperHuesos()

InVertebrado
-celulas +comer()

Mamifero
-celulas -huesos -labios +comer() +romperHuesos() +mamar()

Ave
-celulas -huesos -alas -pico +comer() +romperHuesos() +volar()

Canino
-celulas -huesos -labios -colmillos +comer() +romperHuesos() +mamar()

Humano
-celulas -huesos -labios -raciocinio +comer() +romperHuesos() +mamar() +pensar()

?
Ornitorrinco
-celulas -huesos -pico +comer() +romperHuesos()

M.C.I Kenneth Snchez S.

Jerarqua de clasificacin
Reglas de Construccin
REGLA DE GENERALIZACIN / ESPECIALIZACIN
Especializacin: Especializacin: presencia de unas caractersticas especficas de un subconjunto de elementos de un determinado conjunto como, para que si bien mantienen las caractersticas esenciales e identificativas del conjunto al que pertenecen, tambin son lo suficientemente relevantes como para ser rasgos distintivos de dicho subconjunto de elementos.

REGLA ES UN?

M.C.I Kenneth Snchez S.

Jerarqua de clasificacin
Ave
-celulas -huesos -alas -pico +comer() +romperHuesos() +volar()

Coche
-ruedas -combustible -motor +arrancar() +acelerar() + l () +frenar()

Moto
Aguila
-celulas -huesos -alas -pico +comer() +romperHuesos() +volar()

-ruedas -combustible -motor +arrancar() +acelerar() frenar() +frenar() +hacerCaballito()

Se cumple la regla Es un? No se cumple la regla de especializacin

M.C.I Kenneth Snchez S.

No se cumple la regla Es un? Se cumple la regla de especializacin

Tipos de Herencia
Herencia simple: se produce cuando una clase hija hereda de una nica clase padre

Herencia mltiple: se produce cuando una clase hija hereda de ms de una clase padre

M.C.I Kenneth Snchez S.

Tipos de Herencia
Ejemplo de herencia mltiple:
Espaol Argentino

Posibilidad de ambigedades y colisiones

HispanoArgentino

M.C.I Kenneth Snchez S.

Herencia de Clases
Es la base de la reutilizacin de cdigo. cdigo. Permite crear una clase a partir de otra o de otras (h i lti l ) (herencia mltiple) En C++ se basa en permitir que una clase contenga a otra clase en su declaracin. declaracin. Sintaxis: Sintaxis: class nombre_clase:modificacin_acceso clase_base { nombre_clase: ........} ........}; donde modificacion_acceso es opcional y puede modificacion acceso tomar como valor protegido, public o private. Si el acceso private. es publico significa que todos los miembros pblicos de la clase base sern pblicos en la nueva clase (clase derivada). derivada).
M.C.I Kenneth Snchez S.

EJEMPLO
class Vehiculo{ protected: int peso; int i t pasajeros; j public: void CambiaPeso(int NuevoPeso); int RetornaPeso(void); void cambiaPasajeros(int NuevoPeso); int RetornaPasajeros(void); }

class Camion:public Vehiculo { //Hereda de la clase vehiculo int carga; public: void CambiaCarga(int NuevoPeso); int RetornaCarga(void); Void mostrar(void); }

Tabla de Modificadores de Acceso

Si el modo de derivacin es: y el miembro en la clase base es: private private protected public private protected protected public private public protected public Se obtiene un miembro inaccesible private private inaccesible protected protected inaccesible protected public

Reglas obtenidas de la tabla anterior

1) Los datos miembros privados no son derivables sea cual sea el modo de derivacin. derivacin. 2) Derivando en modo privado se obtienen miembros privados. privados. 3) Derivando en modo protegido se obtienen miembros protegidos. protegidos. 4) Derivando en modo pblico se respetan las caractersticas de los miembros de la clase base. base.

Representacin Grfica de Herencia

M.C.I Kenneth Snchez S.

// PERSONAS.HPP class Persona { protected: // Permite que estos char Nombre[30]; atributos sean int Edad; // conocidos en las clases derivadas public: Persona(char Nom[30], int Ed); void Muestra(void); void CambiaNombre(char NuevoNom[30]); void CambiaEdad(int NuevaEdad); void ObtNombre(char Nom[30]); int ObtEdad(void); };

class Estudiante : public Persona { protected: float Examen1; float Examen2; float Promedio; public: bli Estudiante(char Nom[30], int Ed, float Ex1, float Ex2); void CalculaPromedio(void); void Muestra(void); void CambiaNotas(float NuevaNota1, float NuevaNota2); float ObtEx1(void); float ObtEx2(void); float ObtProm(void); };

class EstCompu :public Estudiante {

float Examen3; public: EstCompu(char Nom[30],int Ed, float Ex1, float Ex2, float Ex3); void CalculaPromedio(void); float ObtEx3(void); }; class Asistente : public Persona { float Promedio; int HorasAs; char Curso[50]; char Carrera[50];

public: Asistente(char Nom[30],int Ed,float Prom,char Cur[50],int HA,char Carr[50]); void Muestra(void); float ObtPromedio(void); int ObtHorasAs(void); void ObtCurso(char Cur[50]); void ObtCarrera(char Carr[50]); void CambiaPromedio(float NuevoProm); void CambiaHorasAs(int id C bi A (i NuevaHo); void CambiaCurso(char NuevoCurso[50]); void CambiaCarrera(char NuevaCarrera[50]); };

// Personas.cpp #include "personas.hpp" #include <string.h> #include <stdio.h> #include <iostream.h> /*----P /*----P E R S O N A--------*/ A--------*/ Persona::Persona(char Nom[30],int Ed) { strcpy(Nombre,Nom); Edad = Ed; } void Persona::Muestra(void) { cout<<"Persona: <<Nombre; cout cout<< endl; cout<<"Edad: <<Edad; } void Persona::CambiaNombre(char NuevoNom[30]) { strcpy(Nombre,NuevoNom); }

void Persona::CambiaEdad(int NuevaEdad) { Edad = NuevaEdad; } void Persona::ObtNombre(char Nom[30]) { strcpy(Nom,Nombre); } int Persona::ObtEdad(void) { return Edad; }

/*----E /*----E S T U D I A N T E---*/ E---*/ // Llama al constructor de la clase base Estudiante::Estudiante(char Nom[30],int Ed,float Ex1,float Ex2) : Persona(Nom,Ed) { Examen1 = Ex1; Examen2 = Ex2; } void Estudiante::CalculaPromedio(void) { Promedio = (Examen1 + Examen2)/2; } void Estudiante::Muestra(void) { cout<<"Estudiante: <<Nombre; cout<<"Promedio: <<Promedio; }

void Estudiante::CambiaNotas(float NuevaNota1, float NuevaNota2) { Examen1 = NuevaNota1; Examen2 = NuevaNota2; } float Estudiante::ObtEx1(void) { return Examen1; } float Estudiante::ObtEx2(void) { return Examen1; } float Estudiante::ObtProm(void) { return Promedio; }

10

/*----ESTUDIANTE COMPUTACION-----*/ /*----ESTUDIANTE - COMPUTACION-----*/ // Llama al constructor de la clase base EstCompu::EstCompu(char Nom[30],int Ed,float Ex1,float Ex2,float Ex3) : Estudiante(Nom,Ed,Ex1,Ex2) { Examen3 = Ex3; } void EstCompu::CalculaPromedio(void) { Promedio = (Examen1 + Examen2 + Examen3)/3; } float EstCompu::ObtEx3(void) { return Examen3; }

*------A S I S T E N T E-----------*/ ------A E-----------*/ Asistente::Asistente(char Nom[30],int Ed,float Prom,char Cur[50], int HA, char Carr[50]) : Persona(Nom,Ed){ Promedio = Prom; strcpy(Curso,Cur); strcpy(Curso Cur); HorasAs = HA; strcpy(Carrera,Carr); } void Asistente::Muestra(void) { cout<<"Asistente: <<Nombre; cout<<"Edad: <<Edad; cout<<"Carrera: <<Carrera;
cout<<"Horas Asignadas: <<HorasAs;

float Asistente::ObtPromedio(void) { return Promedio; }

cout<<"Curso Asignado: <<Curso; cout<<"Promedio Ponderado:<< Promedio; }

int Asistente::ObtHorasAs(void) { return HorasAs; } void Asistente::ObtCurso(char Cur[50]) { strcpy(Cur,Curso); strcpy(Cur Curso); } void Asistente::ObtCarrera(char Carr[50]) { strcpy(Carr,Carrera); }

11

void Asistente::CambiaPromedio(float NuevoProm) { Promedio = NuevoProm; } void Asistente::CambiaHorasAs(int NuevaHo) { HorasAs = N H A NuevaHo; H } void Asistente::CambiaCarrera(char NuevaCarrera[50]) { strcpy(Carrera,NuevaCarrera); } void Asistente::CambiaCurso(char NuevoCurso[50]) { strcpy(Curso,NuevoCurso); }

// Programa Principal #include "Personas.hpp" #include <conio.h> void main() { Persona P1("Carlos",20), P1( Carlos 20) P2("Maria",30); Asistente A1("Carlos",20,90,"Programacin I",10,"Computacin"), A2("Maria",30,80,"Clculo 1",12,"Matemtica"); Estudiante E1("A d " 23 70 90) E t di t E1("Andrea",23,70,90), E2("Roberto",18,70,80); EstCompu EC1("Karla",19,70,90,100),

EC2("Galois",40,70,80,89); clrscr(); P1.Muestra(); P2.Muestra(); getch(); P1.CambiaNombre( Luis ); P1 CambiaNombre("Luis"); P1.CambiaEdad(40); P1.Muestra(); getch(); A1.Muestra(); A2.Muestra(); g getch(); ();

12

Ejemplo (cont)
E1.CalculaPromedio(); E2.CalculaPromedio(); E1.Muestra(); E2.Muestra(); getch(); EC1.CalculaPromedio(); EC2.CalculaPromedio(); EC1.Muestra(); EC1 M () EC2.Muestra(); getch(); }

13