Herencia y cosas varias

19 Diciembre, 2009

Soy libre. La semana fatídica de fin de cuatrimestre y entrega de prácticas ha terminado y por delante se asoma un nuevo horizonte navideño y un enero cargadito de examenes, pero por ahora, soy libre. Tras echar horas delante del ordenador para entregar la segunda práctica de la asignatura de “Programación Orientada a Objetos”, más conocida como POO (no, no es el teletubbie), he aprendido unas cuantas cosas, de las cuales, la que más interesante me ha parecido ha sido la herencia.

La herencia es un método orientado a objetos que permite ahorrar la escritura de código, así como implementar una funcionalidad de la manera más óptima posible. En herencia existen dos clases básicas, la clase padre y la clase derivada. La clase padre implementa funcionalidades que comparten las clases derivadas, de este modo, si tenemos una clase “vehículo” como padre, podemos tener varias clases derivadas como “moto”, “coche” o “avión” como derivadas o hijas. En este caso y, fijándonos en un posible método que nos cuenta el número de ruedas de cada uno de ellos, esta funcionalidad se implementaría en la clase vehículo, ya que todas las clases derivadas comparten esta característica. Otro posible ejemplo de herencia sería el de “figuras”, teniendo como clases derivadas “círculo” o “rectangulo” y compartiendo funcionalidades como una posible función de color de relleno o de grosor de borde.

De este modo conseguimos asociar distintas clases a una única clase que comparte características y nos ahorramos la reescritura de código. A la hora de implementar la herencia, tendremos que tener en cuenta que los constructores de las clases derivadas llamarán automáticamente a los contructores de la clase heredada o padre, por lo que en el caso de constructores sobrecargados de clases derivadas, tendremos que tener en cuenta los parámetros que pasamos a la clase padre. Un ejemplo sencillito:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class Figura
{
	public:
		Figura2D(); // constructor por defecto
		Figura2D(int borde, int color); //constructor sobrecargado de Figura2D, recibe la llamada del mismo en Circulo
		virtual ~Figura2D(); // hacemos el destructor virtual al tratarse de una clase abstracta que tendrá implementación vacía
		void setBorde(); // método de seteo del grosor del borde
		void setColorFondo(); // método de seteo del fondo de la figura
		int getBorde(); // método de get del borde
		int getColor(); // método de get del color
 
	private:
		int bordeLinea;
		int colorFondo;
}
 
class Circulo: public Figura // implementamos la herencia, en este caso pública
{
	public:
		Circulo() // llamada automática al constructor por defecto de figura
		Circulo(float radio, int borde, int fondo);
		/*
		*	En la librería de Circulo tendremos que implementar el constructor de la siguiente forma:
		*	Circulo(float radio, int borde, int fondo) : Figura(borde,fondo) { ... }
		*	Esto enviará los dos atributos indicados al constructor sobrecargado de la clase padre.
		*/
		~Circulo() // destructor
		void setRadio(float); // método para setear el radio
		float getRadio(); // método de get para radio
 
	private:
		float radio;
 
}

Archivado en: Universidad

Etiquetas: C++, Herencia, programación