HERENCIA

Integrantes:
1.Ivan esmit Condori mayhua.
2.Alvaro uber ochoa chipile.
3.Roly anibal quellca hancco.
¿QUE ES HERENCIA?

 Herencia es crear una clase a partir de otra

existente.
 Gracias a la herencia es posible especializar o
extender la funcionalidad de una clase, derivando
de ella nuevas clases.
 Una clase siempre es transitiva.
USOS DE LA HERENCIA

 La herencia como reutilización de código: Una clase derivada puede

heredar comportamiento de una clase base, por tanto, el código no necesita
volver a ser escrito para la derivada.

 La herencia como reutilización de conceptos: Esto ocurre cuando una

clase derivada sobrescribe el comportamiento definido por la clase base.
Aunque no se comparte ese código entre ambas clases, ambas comparten el
prototipo del método (comparten el concepto).
ejemplo

ANIMAL

VERTEBRADO
INVERTEBRADOS

AVES MANIFEROS

CABALLO
 PERSONA

Clase base o
Nombre súper clase
Cedula
Imprimir()

Estudiante Empleado
Clases
derivadas o
Indice HorasTra
subclases
Año PagoHora
Imprimir() Cal_sueldo()
QUE NO SE HEREDA

 Los miembros privados(datos y métodos)

 Los constructores
 Destructores
LOS CONSTRUCTORES Y DESTRUCTORES

 Los constructores y destructores no son heredados

por las clases derivadas. Sin embargo, una instancia
de una clase derivada contendrá todos los miembros
de la clase base, y éstos deben ser iniciados. En
consecuencia, el constructor de la clase base debe ser
llamado por el constructor de la clase derivada.
 OJO: Cuando se escribe un constructor para la clase
derivada, se debe especificar una forma de inicio para
la base. La forma de hacerlo es utilizar una sintaxis
#include<iostream>
#include<stdlib.h>
using namespace std;

class Persona{
private: //Atributos
string nombre;
int edad;
public: //Metodos
Persona(string,int); //Constructor Persona
void mostrarPersona();
};

class Empleado : public Persona{

private: //Atributos
float sueldo;
public: //Metodos
Empleado(string,int,float); //Constructor Empleado
void mostrarEmpleado();
};

class Estudiante : public Persona{

private: //Atributos
float notaFinal;
public: //Metodos
Estudiante(string,int,float);
void mostrarEstudiante();
};
//Constructor de la clase Persona(Clase Padre)
Persona::Persona(string _nombre,int _edad){
nombre = _nombre;
edad = _edad;
}

void Persona::mostrarPersona(){
cout<<"Nombre: "<<nombre<<endl;
cout<<"Edad: "<<edad<<endl;
}

//Constructor de la clase Empleado (Clase Hija)

Empleado::Empleado(string _nombre,int _edad,float _sueldo) : Persona(_nombre,_edad){
sueldo = _sueldo;
}

void Empleado::mostrarEmpleado(){
mostrarPersona();
cout<<"Sueldo: "<<sueldo<<endl;
}

//Constructor de la clase Estudiante

Estudiante::Estudiante(string _nombre,int _edad,float _notaFinal) : Persona(_nombre,_edad){
notaFinal = _notaFinal;
}

void Estudiante::mostrarEstudiante(){
mostrarPersona();
cout<<"Nota Final: "<<notaFinal<<endl;}
int main(){
Empleado empleado1("Juan",35,1300);
cout<<"-Empleado-"<<endl;
empleado1.mostrarEmpleado();
cout<<"\n";

Estudiante estudiante1("Maria",21,16.7);
cout<<"-Estudiante-"<<endl;
estudiante1.mostrarEstudiante();
cout<<"\n";

system("pause");
return 0;
}
Clase persona o padre

package herencia;

public class persona {

private String nombre;

private String apellido;

private int edad;

public persona(String nombre, String apellido, int edad) {

this.nombre = nombre;

this.apellido = apellido;

this.edad = edad;

public String getNombre() {

return nombre;

public String getApellido() {

return apellido;

public int getEdad() {

return edad;

}
 Clase heredada o clase hija
package herencia;

public class estudiante extends persona{

private int codigoEstudiante;
private float notaFinal;
public estudiante(String nombre,String apellido,int edad,int codigoEstudiante,float notaFinal){
super(nombre, apellido, edad);
this.codigoEstudiante = codigoEstudiante;
this.notaFinal = notaFinal;
}
public void mostrarDatos(){
System.out.println("nombre: "+getNombre()+
"\napellido: "+getApellido()+
"\nedad:"+getEdad()+
"\ncodigo de estudiante: "+codigoEstudiante+
"\nnota final: "+notaFinal);
}
}
Clase principal

package herencia;

public class principal {

public static void main(String[] args) {
estudiante alumno = new estudiante("Roly","quellca",18,171826,12f);
alumno.mostrarDatos();
}
}
HERENCIA SIMPLES Y
MULTIPLES
HERENCIA SIMPLE

 Cuando sólo se tiene una clase base de la

cual hereda la clase derivada, se dice que
hay herencia simple Sin embargo, la
herencia simple no excluye la posibilidad de
que de una misma clase base se pueda
derivar más duna subclase o clase derivada.
PERSONA MANIFERO

VACUNO OVINO
EMPLEADO
VENTAJAS E INCONVENIENTES DE LA DERIVACIÓN
PRIVADA Y PROTEGIDA

 Cuando se utiliza el especificador de acceso private o el

especificador de acceso protected en la herencia, se está
asegurando que sólo las partes públicas de la clase derivada
podrán ser utilizadas por el resto del programa, y por las otras
clases derivadas que se derivan a partir de ésta.

 El acceso private “corta” el acceso, no la herencia, a partir de la

clase derivada. El acceso protected “corta” el acceso, no la
herencia, desde el exterior, pero no desde las clases derivadas
 Cuando se utiliza el especificador de acceso private o el especificador de
acceso protected en la herencia, se está asegurando que sólo las partes
públicas de la clase derivada podrán ser utilizadas por el resto del programa, y
por las otras clases derivadas que se derivan a partir de ésta.

 El acceso private “corta” el acceso, no la herencia, a partir de la clase

derivada. El acceso protected “corta” el acceso, no la herencia, desde el
exterior, pero no desde las clases derivadas.

 Los inconvenientes llegan porque al utilizar estos tipos de accesos se está

complicando el árbol de herencia, alcanzando una mayor complejidad la
determinación por parte del programador, o de alguien que lea el programa, del
derecho de acceso a los miembros de cada clase.
HERENCIA MULTIPLE

 La definición es concisa, se trata de si se puede heredar de más de una clase,

pero ¿cómo surgió esa necesidad? Smalltalk fue un lenguaje popular en
objetos, antecesor de C++, donde solo se consideró la herencia simple,
empezando por object. Allí no se podía crear una clase sin una existente, así
que C++ propone el uso de la herencia múltiple (aunque no se dieran tantos
escenarios donde fuese necesario). Básicamente se involucra con los
contenedores, donde para el caso de C++, un fabricante de objetos construía
una jerarquía con un contenedor Holder, y otro fabricante da otra jerarquía de
clases donde se encuentran, suponiendo que se requieran los dos, requeriría
que existiese la herencia múltiple.
 En el tipo de herencia múltiple se usan dos o más clases base para derivar una
clase. Es decir, la clase derivada comparte los atributos y los métodos de más
de una clase.
Clase Base 1 Clase Base 2
(profesor) (programador)

Clase Derivada
(profesor de sistemas)
Problema del diamante: Si dos clases heredan de una tercera y una cuarta clase tiene como padre a las dos
iniciales, como se observa en la figura (formando un diamante), cuando una instancia de la clase A, llame un
método de la clase D , desde donde lo hereda, ¿desde la clase B o C?. Cada lenguaje presenta mecanismos para
responder a este caso.
Colisiones: En la herencia múltiple pueden coincidir el nombre de los
atributos y de los métodos entre las clases base. En el caso de Java establece
unas reglas al respecto:
 Si se repite un atributo: Obliga al programador a especificar de qué
interfaz base lo va a utilizar.
 Si se repiten nombres en los métodos: Se dan ciertas condiciones: Si
tienen diferentes parámetros se produce sobrecarga de los métodos, así
existen diversas alternativas para llamar al método, si solo cambia el valor
que devuelve se da un error de compilación indicando que no se pueden
implementar simultáneamente y si coinciden en sus declaraciones se
elimina uno de los dos.
Para definir una relación de herencia múltiple se utiliza la siguiente sintaxis:

class Base1 {

//Declaracion de atributos y métodos de la clase Base1

};

Class Base2{

//Declaración de atributos y métodos de la clase Base2

}
class BaseN

{ // Declaración de atributos y métodos de la clase BaseN

};

// Relación de herencia múltiple entre las clases Base1, Base2,

BaseN y Derivada class Derivada: public Base1, public Base2, public
BaseN

{ // Declaración de atributos y métodos de la clase Derivada

};
 Para definir el constructor de la clase “Derivada”, se procede de la siguiente manera:

Derivada :: Derivada (parámetros) : Base1 (parámetros propios de la

clase Base1), Base2

(parámetros propios de la clase Base2), …, BaseN (parámetros propios

de la clase BaseN) { // Cuerpo del constructor de la clase Derivada
}

Al llamar al constructor de la clase Derivada, primero se ejecuta el constructor de la clase Base1,

después el constructor de la clase Base2, y así sucesivamente hasta el constructor de la clase Basen.
Por último, se ejecutan las instrucciones que aparezcan en el cuerpo del constructor de la clase
Derivada.
Qué pasa con los lenguajes.

En vista de todos los inconvenientes que puede generar los lenguajes han desarrollado diversas estrategias para admitirlo (en
el caso de los que no los implementan) y otros han sido diseñados para soportarla:

Lenguaje Mecanismo

Java No soporta herencia múltiple. Se emplean las interfaces como mecanismo de solución.

Python Soporta la herencia múltiple simil a C++. Simplemente se emplea la sintaxis class ClaseDerivada(Clase Base
Uno, Clase Base Dos):

Responde al problema del diamante, tomando toda clase descendiente de object. Crea una lista de clases
(de derecha a izquierda y de abajo hacia arriba), luego va eliminando toda repetición menos la de la
última clase, generando un orden.

Ruby No soporta la herencia múltiple, emplea los mixins como mecanismo de solución.

C++ Soporta herencia múltiple. La sintaxis empleada es class ClaseHija: public ClasePadreA [,ClasePadreB].

Utiliza la herencia virtual en caso de tener elementos repetidos entre las clases base, esto permite que cada
objeto de la clase derivada no contenga todos los objetos de la clase base si están duplicados.