capitulo # 4 herencia programacion iii universidad salesiana de bolivia

CAPITULO # CAPITULO # 44

HERENCIA HERENCIA PROGRAMACION III

UNIVERSIDAD SALESIANA DE BOLIVIA

CONCEPTO Y JUSTIFICACIÓN DE LA HERENCIA

La clase que hereda se denomina subclase o clase derivada.

La clase de la cual se hereda se denomina superclase o clase base.

Concepto y justificación de la herencia

Todo objeto de una subclase es un objeto de la superclase de la cual deriva.

Concepto y justificación de la herencia Las subclases pueden redefinir los

métodos y atributos de la clase padre y añadir otros nuevos.

JERARQUIA DE CALSES

Las subclases de una clase pueden ser a su vez superclases de otras clases. Esto da lugar a jerarquías de clases. 

→ Jerarquías de Generalización/Especialización que son relaciones conceptuales ‘

EJEMPLOS:EJEMPLOS:

Libros y Revistas tienen propiedades comunes. Una Pila puede definirse a partir de una Cola o

viceversa. Un Rectángulo es una especialización de Polígono Puede haber distintos tipos de Cuentas.

JERARQUIA DE CALSES

GENERALIZACIGENERALIZACIONON

ESPECIALIZACIESPECIALIZACION ON

Se detectan clases con un comportamiento común. Ejemplo: Triangulo y polígono son figuras.

Se detecta que una clase es un caso especial de otra Ejemplo: Triangulo es un tipo de Polígono.

No hay receta mágica para crear buenasjerarquías

Tipos de herencia

Herencia simple Una clase puede heredar de una única clase.

Ejemplo: Ejemplo: Java, C#

Herencia múltiple Una clase puede heredar de varias clases. Clases forman un grafo dirigido acíclico.

Ejemplos: Ejemplos: Eiffel, C++

La sintaxis que indica la herencia en JAVA

Para indicar que una clase hereda sus atributos y métodos de otra, en Java se utiliza la palabra clave extends. Herencia Simple class subclase extendsextends superclase:

public class Vocal extends Letra

Clase persona public class Persona Persona {String nombre = "";int edad; public Persona(String nom, int ed) {nombre = nom;edad = ed;} public void mostrar() { System.out.println("Nombre: "+ nombre); System.out.println("Edad: "+ edad);}public static void main(String args[]) {Persona yo= new Persona("Balta", 99);yo.mostrar(); } }

La sintaxis que indica la herencia en JAVA

Clase trabajadorpublic class TrabajadorTrabajador extends PersonaPersona {float sueldoHora;int numHoras;public Trabajador(String nom, int ed, float suel, int num) { super(nom, ed); // llamada al constructor de // llamada al constructor de Persona Persona sueldoHora = suel;numHoras = num;}public double sueldo() {return sueldoHora * numHoras; }Trabajador yo= new Trabajador("Balta", 99, 200.5f, 45); yo.mostrar(); // se invoca al método heredado // se invoca al método heredado mostrar mostrar double pelas = yo.sueldo();System.out.println("Cobra: " + pelas); }}

La sintaxis que indica la herencia en JAVA

Herencia y Reglas de Acceso   Existen cuatro posibles visibilidades de atributosatributos

ymétodosmétodos: De más restrictivo a menos:De más restrictivo a menos: private visible sólo en la clase donde se define. Sin modificador (por defecto) visible a las clases del paquete. protected visible a las subclases y al resto de clases del

paquete. public visible a todas las clases.

Herencia y Reglas de Accesoclass Vuelo {  char nombre[30];    // private (por defecto)// private (por defecto)  int capacidad;      // private (por defecto)// private (por defecto)private:  float peso;         // private// privateprotected:  void carga(&operacion};    // protected// protectedpublic:  void despegue(&operacion}; // public// public  void crucero(&operacion);  // public// public  char* getName();           // obtener el nombre del vuelo// obtener el nombre del vuelo};

Evitando la herencia

Se puede evitar que una clase sea heredada:

public final class Clasepublic final class Clase

Paquetes

Los paquetes son contenedores de clases que permite delimitar el espacio en el cual una clase existe.

Los paquetes permiten que exista más de una

clase con el mismo nombre. Para indicar que una clase pertenece a un cierto

paquete, se utiliza la palabra clave package La forma de esta sentencia es:

package nombrePaquete;package nombrePaquete;

Constructores y destructores Constructor es un:Constructor es un: Método que inicializa el objeto en su creación. Se llama automáticamente cuando se crea un

objeto. Su nombre es igual que el de la clase y no

tiene tipo de retorno. Java proporciona un constructor sin

parámetros por defecto que deja de estar disponible cuando se añade algún constructor.

Constructores y destructores Destructor es un:Destructor es un: Es un método perteneciente a una clase

que es ejecutado de forma automática cuando un objeto es destruido. Java no soporta los destructores.

Constructores y destructores en herencia En principio se hereda todo menos:En principio se hereda todo menos: Constructor y destructor

Aunque no se heredan ni el constructor ni el destructor de la clase base, cuando se crea o se destruye un objeto de la clase derivada se invocan automáticamente los de la clase base. Se usa el constructor por defecto (es decir sin parámetros).

Constructores y destructores en herencia Antes ejecutarse el cuerpo de un

constructor se debe llamar a su constructor basebase.En Java se utiliza la palabra reservada super.

public Rectangulo(int x,int y,int ancho,int alto) {super(x,y);this.ancho=ancho;this.alto=alto;}

public Rectangulo(int x,int y,int ancho,int alto) {super(x,y);this.ancho=ancho;this.alto=alto;}

Constructores y destructores en herencia Al contrario que con los constructores,

una funcion destructor de una clase derivada se ejecuta antes que el destructor de la clase base. (los destructores no se heredan).

Ejemplo :

Constructores y destructores en herencia

class Punto{private int x;private int y;public Punto () {x=0;y=0;}public Punto (int x, int y){this.x=x;this.y=y;}public int darX(){return x;}public int darY(){return y;}public void cambiarX (int val) {x=val;}public void cambiarY (int val) {y=val;}}

class Tripleta extends Punto {int z;public Tripleta() {cambiarX(0);cambiarY(0);z = 0;}

int darZ() { return z; }void cambiarZ(int val){ z = val; }}

Cuando creamos un objeto con:

Tripleta t = new Tripleta (1, 2, 3);

Se llama al constructor con parámetros, con parámetros de Tripleta.

Una mejora a este método sería:

public Tripleta(int vx, int

vy, int vz) {super (vx,vy);z = vz;}

Cuando creamos un objeto con:

Tripleta t = new Tripleta (1, 2, 3);

Se llama al constructor con parámetros, con parámetros de Tripleta.

Una mejora a este método sería:

public Tripleta(int vx, int

vy, int vz) {super (vx,vy);z = vz;}

public Tripleta(int vx, int vy, int vz) {cambiarX(vx);cambiarY(vy);z = vz; }

HERENCIA MULTIPLE

Algunos lenguajes orientados a objetos, como C++ permiten herencias múltiples, lo que significa que una clase puede heredar los atributos de otras dos superclases. Este método puede utilizarse para agrupar atributos y métodos desde varias clases dentro de una sola.

En el language Java no existe la herencia multiple, si no que se puede simular con las interfaces que se vera en proximos capitulos.

Ejemplo de herencia multiple en C++

#include <cstdio> #include <cstdlib> #include <iostream>   using namespace std;   class Cama { public:       Cama() // constructor     {    cout << "Creando una Cama" << endl;     }

~Cama() // destructor en C++    {    cout << "Destruyendo la Cama" << endl;     } };

#include <cstdio> #include <cstdlib> #include <iostream>   using namespace std;   class Cama { public:       Cama() // constructor     {    cout << "Creando una Cama" << endl;     }

~Cama() // destructor en C++    {    cout << "Destruyendo la Cama" << endl;     } };

class Sofa { public:       Sofa()     {         cout << "Creando un Sofa" << endl;     }       ~Sofa()     {         cout << "Destruyendo el Sofa" << endl;     } };

class Sofa { public:       Sofa()     {         cout << "Creando un Sofa" << endl;     }       ~Sofa()     {         cout << "Destruyendo el Sofa" << endl;     } };

Ejemplo de herencia multiple en C++  class Sofacama : public Cama, public Sofa

{ public:       Sofacama()     {         cout << "Ahora tenemos un Sofacama" << endl;     }       ~Sofacama()     {         cout << "Destruyendo el Sofacama" << endl;     } };  int main() {     Sofacama ss;     return 0; }

class Sofacama : public Cama, public Sofa { public:       Sofacama()     {         cout << "Ahora tenemos un Sofacama" << endl;     }       ~Sofacama()     {         cout << "Destruyendo el Sofacama" << endl;     } };  int main() {     Sofacama ss;     return 0; }