c







En programación, mecanismo que permite derivar características de una clase a otra y así
extender sus funcionalidades. Uno de sus funciones más importantes es proveer polimorfismo.
Existen dos tipos de herencias:
Herencia simple: una clase sólo puede heredar características de una sola clase, o sea, puede
tener un padre. Smalltalk, Java y Ada soportan herencia simple.
Herencia múltiple: una clase puede heredar características de una o más clases, por lo tanto,
puede tener varios padres. C++ soporta herencia múltiple.
La herencia es una de las características de los lenguajes del paradigma orientado a objetos.








La herencia en C++ es un mecanismo de abstracción creado para poder facilitar y

mejorar el diseño de las clases de un programa. Con ella se pueden crear nuevas clases a
partir de clases ya hechas, siempre y cuando tengan un tipo de relación especial.

En la herencia, las clases derivadas "heredan" los datos y las funciones miembro de las
clases base, pudiendo las clases derivadas redefinir estos comportamientos
(polimorfismo) y añadir comportamientos nuevos propios de las clases derivadas. Para
no romper el principio de encapsulamiento (ocultar datos cuyo conocimiento no es
necesario para el uso de las clases), se proporciona un nuevo modo de visibilidad de los
datos/funciones: "protected". Cualquier cosa que tenga visibilidad protected se
comportará como pública en la clase Base y en las que componen la jerarquía de
herencia, y como privada en las clases que NO sean de la jerarquía de la herencia.

Antes de utilizar la herencia, nos tenemos que hacer una pregunta, y si tiene sentido,
podemos intentar usar esta jerarquía: Si la frase <claseB> ES-UN <claseA> tiene
sentido, entonces estamos ante un posible caso de herencia donde clase A será la clase
base y clase B la derivada.

Ejemplo: clases Barco, Acorazado, Carguero, etc. un Acorazado ES-UN Barco, un

Carguero ES-UN Barco, un Trasatlántico ES-UN Barco, etc.

En este ejemplo tendríamos las cosas generales de un Barco (en C++)

class Barco {
protected:
char* nombre;
float peso;
public:
//Constructores y demás funciones básicas de barco
};

y ahora las características de las clases derivadas, podrían (a la vez que heredan las de
barco) añadir cosas propias del subtipo de barco que vamos a crear, por ejemplo:
class Carguero: public Barco { // Esta es la manera de especificar que hereda de Barco
private:
float carga;
//El resto de cosas
};

class Acorazado: public Barco {

private:
intnumeroArmas;
int Soldados;
// Elresto de cosas
};

Por último, hay que mencionar que existen 3 clases de herencia que se diferencian en el
modo de manejar la visibilidad de los componentes de la clase resultante:

ëÊ Herencia publica (class Derivada: publicBase ) : Con este tipo de herencia se

respetan los comportamientos originales de las visibilidades de la clase Base en la
clase Derivada.
ëÊ Herencia privada (clase Derivada: private Base) : Con este tipo de herencia todo
componente de la clase Base, será privado en la clase Derivada (ojo! siempre será
privado aunque ese dato fuese público en la clase Base)
ëÊ Herencia protegida (clase Derivada: protected Base) : Con este tipo de herencia,
todo componente publico y protegido de la clase Base, será protegido en la clase
Derivada, y los componentes privados, siguen siendo privados.




 



La herencia múltiple es el mecanismo que permite al programador hacer clases

derivadas a partir, no de una sola clase base, sino de varias. Para entender esto mejor,
pongamos un ejemplo: Cuando ves a quien te atiende en una tienda, como persona que
es, podrás suponer que puede hablar, comer, andar, pero, por otro lado, como empleado
que es, también podrás suponer que tiene un jefe, que puede cobrarte dinero por la
compra, que puede devolverte el cambio, etc. Si esto lo trasladamos a la programación
sería herencia múltiple (clase empleado_tienda):

class Persona {
...
Hablar();
Caminar();
...
};

class Empleado {
Persona jefe;
int sueldo;
Cobrar();
...
};
classempleado_tienda: public Persona, Empleado {
...
AlmacenarStock();
ComprobarExistencias();
...
};

Por tanto, es posible utilizar más de una clase para que otra herede sus características.






 





 

â


  







Lo primero que se les viene a la cabeza a los estudiantes (y a muchos profesionales) cuando se les
menciona la reutilización del código es el famoso copiar y pegar al que se han acostumbrado en
la programación estructurada, y de echo muchos lo hacen en poo, lo cual es una de las practicas
que más encarece el desarrollo de software. Como todo en Java, el problema se resuelve con las
clases. Para reutilizar el código creamos nuevas clases pero, en lugar de partir de cero, partimos
de clases, relacionadas con nuestra clase, que han sido ya creadas y depuradas. El truco está en
usar las clases sin ensuciar el código existente.

Una forma de hacer esto es crear objetos de nuestras clases existentes dentro de la nueva clase.
Esto se conoce como composición porque la nueva clase está compuesta de objetos de clases
existentes. Estamos reutilizando la funcionalidad del código, y no la forma.

Otra forma es crear una nueva clase como un tipo de una clase ya existente. Tomamos la forma
de la clase existente y añadimos código a la nueva, sin modificar la clase existente. Esta forma
de crear nuevos objetos se llamada herencia, y lo que hacemos es extender la clase en la que nos
basamos para crear la nueva.

m
 
Hasta ahora hemos usado la composición de cierta manera, ej. cuando hacemos una interfaz
gráfica de usuario, nuestra clase de interfaz gráfica esta compuesta por un frame, unos panel,
botones, etc. todos estos objetos componen el objeto de interfaz gráfica. Es decir que la
composición consiste en poner manejadores de objetos dentro de nuestra clase, estos
manejadores de objetos no serán otra cosa que instancias de las clases en las que nos estamos
basando para crear la nueva clase.

Recordemos que la forma para determinar cuando usar composición es cuando podemos decir
que nuestra nueva clase ´tiene unµ elemento de otro tipo de objetos, por ejemplo un cronómetro
tiene: horas, minutos y segundos, es decir que una clase Cronometro esta compuesta por otras
clases llamadas: Horas, Minutos y Segundos.
Veamos como seria esta clase:

publicclass Cronometro {
Horas h;
Minutos m;
Segundos s;

String cadena;
intseg,min,hor;

public Cronometro() {
seg=0;
min=0;
hor=0;
h = new Horas();
m = new Minutos();
s = new Segundos();
cadena = new String("0 : 0 : 0");
}

publicString avanzar(){
seg = s.forward();
if(seg==0){
min=m.forward();
if(min==0){
hor=h.forward();
}
}
cadena = hor + " : " + min + " : " + seg;
return cadena;
}

publicStringreset(){
seg = s.reset();
min = m.reset();
hor = h.reset();
cadena = hor + " : " + min + " : " + seg;
return cadena;
}
}

Nuestra clase Cronometro está compuesta entre otras cosas por objetos del tipo Horas, Minutos
y Segundos y a través del constructor de nuestra clase creamos las instancias de cada una de
ellas